李宏毅课程作业食物分类数据集详解

本文还有配套的精品资源，点击获取

简介：Sub_data.zip是李宏毅教授视频课作业3中提供的微型食物分类数据集，专为深度学习图像分类学习设计。该数据集分为训练集、验证集和测试集，适用于初学者掌握图像分类任务中的数据结构、预处理流程和模型训练方法。通过使用CNN等深度学习框架，学习者可以实践图像分类的核心技术，包括特征提取、损失函数优化和模型泛化能力评估。

1. 食物图像分类任务与深度学习背景

图像分类是计算机视觉中最基础且关键的任务之一，尤其在深度学习迅猛发展的推动下，其准确率与实用性得到了显著提升。在众多应用场景中，食物图像分类因其在智能餐饮、营养分析、健康管理等领域的潜在价值，成为近年来研究的热点之一。

本章将聚焦于食物图像分类任务，探讨其技术挑战与现实意义。同时，简要回顾深度学习的发展历程，包括神经网络的基本结构、训练机制以及其在图像识别中的突破性表现。通过本章的学习，读者将对图像分类任务有初步认知，并理解深度学习为何成为当前解决该问题的主流方法。

2. Sub_data.zip数据集结构与数据准备

在构建食物图像分类模型之前，首先需要对数据集进行充分的了解与准备。本章将围绕 Sub_data.zip 这一图像数据集展开详细分析，包括其整体结构、文件组织方式、图像格式与命名规范、数据统计信息等内容。随后，我们将介绍如何使用Python对图像数据进行加载和可视化，并深入探讨样本分布与类别平衡问题。最后，本章将系统讲解训练集、验证集和测试集的划分策略，包括常见的划分比例、实现方法以及如何通过分层抽样确保数据分布的合理性。

2.1 数据集整体结构分析

在深度学习任务中，数据集的组织结构直接影响模型训练的效率与数据预处理的便捷性。 Sub_data.zip 是一个专为图像分类任务设计的小型食物图像数据集，其内部结构经过良好的组织，便于后续的模型训练与测试。

2.1.1 文件夹组织方式与类别划分

Sub_data.zip 数据集的组织方式遵循经典的图像分类数据集结构。解压后，主目录下通常包含多个子文件夹，每个子文件夹对应一个具体的类别标签。例如：

Sub_data/
├── apple_pie/
├── chicken_wings/
├── fried_rice/
├── hamburger/
├── pizza/
└── sushi/

每个子文件夹中存放对应类别的图像样本。这种结构便于使用PyTorch或TensorFlow等深度学习框架提供的 ImageFolder 类自动加载数据，并将文件夹名称作为类别标签。

优势分析：

• 清晰的类别划分 ：每个类别的图像集中在一个文件夹内，便于管理。
• 自动化加载 ：深度学习框架可以直接识别此类结构，无需手动标注。
• 可扩展性强 ：新增类别只需添加对应文件夹即可。

2.1.2 图像格式与命名规范

Sub_data.zip 中的图像大多为常见的 .jpg 或 .png 格式，且命名通常遵循统一的规范。例如：

apple_pie/
    apple_pie_001.jpg
    apple_pie_002.jpg
    ...
chicken_wings/
    chicken_wings_001.jpg
    chicken_wings_002.jpg
    ...

命名规则通常为“类别名_编号.jpg”，这种命名方式有助于：

• 快速识别图像类别
• 避免文件名重复
• 方便后续数据处理与分析

2.1.3 图像数据的基本统计信息

为了更好地理解数据集的整体情况，我们可以统计每个类别的图像数量、图像尺寸分布、图像平均大小等信息。

示例统计表格：

类别名	图像数量	平均尺寸 (宽x高)	平均文件大小 (KB)
apple_pie	120	400x400	85
chicken_wings	115	398x402	83
fried_rice	125	400x400	87
hamburger	130	402x398	89
pizza	128	400x400	86
sushi	122	399x401	84

通过上述统计信息，我们可以初步判断数据集的类别分布是否均衡，图像尺寸是否统一，从而决定是否需要进行图像缩放或裁剪等预处理操作。

2.2 图像数据的加载与可视化

在对数据集进行建模之前，通常需要对图像数据进行加载和可视化，以便观察图像质量、样本分布以及是否存在噪声或异常样本。

2.2.1 使用Python进行图像读取与显示

我们可以使用Python的 PIL 库或 OpenCV 库来读取图像，并借助 matplotlib 进行可视化。

示例代码：

from PIL import Image
import matplotlib.pyplot as plt
import os

# 指定图像路径
img_path = 'Sub_data/apple_pie/apple_pie_001.jpg'

# 读取图像
img = Image.open(img_path)

# 显示图像
plt.imshow(img)
plt.title("Apple Pie Sample")
plt.axis('off')
plt.show()

逐行解释：

• Image.open() ：使用PIL库打开图像文件。
• plt.imshow() ：将图像转换为matplotlib可识别的格式并显示。
• plt.title() ：添加图像标题。
• plt.axis('off') ：关闭坐标轴显示。

输出效果：

该代码将显示一张苹果派的图像，并关闭坐标轴，便于观察图像内容。

2.2.2 样本分布可视化与类别平衡分析

图像分类任务中，类别不平衡可能导致模型偏向于预测样本较多的类别，影响整体性能。因此，我们需要分析各个类别的样本数量分布。

示例代码：

import os
import matplotlib.pyplot as plt

# 指定数据集路径
data_dir = 'Sub_data/'

# 获取所有类别文件夹
classes = os.listdir(data_dir)
class_counts = [len(os.listdir(os.path.join(data_dir, cls))) for cls in classes]

# 绘制柱状图
plt.bar(classes, class_counts)
plt.xlabel('Food Class')
plt.ylabel('Number of Images')
plt.title('Class Distribution in Sub_data')
plt.xticks(rotation=45)
plt.show()

逻辑分析：

• os.listdir() ：获取目录下的所有文件夹（类别）。
• len(...) ：统计每个类别中的图像数量。
• plt.bar() ：绘制柱状图，展示类别分布。
• plt.xticks(rotation=45) ：旋转x轴标签以避免重叠。

输出效果：

该代码将绘制出一个柱状图，展示各个食物类别的图像数量，帮助我们判断是否存在类别不平衡问题。

2.2.3 数据增强前的初步观察

在进行数据增强之前，我们需要观察原始数据是否存在以下问题：

• 图像质量是否清晰
• 是否存在模糊或黑边图像
• 是否有重复样本
• 是否有类别标签错误的图像

我们可以使用 PIL 和 matplotlib 对多个图像进行批量展示，以便快速识别问题样本。

示例代码：

import os
import random
from PIL import Image
import matplotlib.pyplot as plt

data_dir = 'Sub_data/'
classes = os.listdir(data_dir)
fig, axes = plt.subplots(2, 3, figsize=(12, 8))

for i, ax in enumerate(axes.flat):
    cls = random.choice(classes)
    img_file = random.choice(os.listdir(os.path.join(data_dir, cls)))
    img_path = os.path.join(data_dir, cls, img_file)
    img = Image.open(img_path)
    ax.imshow(img)
    ax.set_title(cls)
    ax.axis('off')

plt.tight_layout()
plt.show()

逻辑分析：

• random.choice() ：随机选择一个类别和该类别中的图像。
• plt.subplots() ：创建一个2x3的图像展示网格。
• axes.flat ：遍历所有子图区域。
• ax.imshow() ：在子图中显示图像。

该代码将随机展示6张图像及其对应的类别标签，帮助我们快速了解数据质量。

2.3 数据集划分策略详解

为了评估模型在未知数据上的表现，通常需要将数据集划分为训练集、验证集和测试集。合理的划分策略能够有效防止过拟合，并提高模型的泛化能力。

2.3.1 训练集、验证集与测试集的作用

数据集	作用描述
训练集	用于模型参数的学习，即模型通过训练集调整权重
验证集	用于模型超参数调优和模型选择，监控训练过程中的性能表现
测试集	模拟模型在真实场景中的表现，仅在最终评估时使用，不能参与训练过程

2.3.2 常见划分比例与实现方法

常见的数据集划分比例包括：

• 训练集:验证集:测试集 = 70%:15%:15%
• 训练集:验证集 = 80%:20% （适用于数据量较小的情况）
• 训练集:验证集:测试集 = 60%:20%:20% （适用于需要更严格测试的情况）

实现方法：

• 使用 sklearn.model_selection.train_test_split() 进行两次划分。
• 使用 torchvision.datasets.ImageFolder 配合 random_split() 进行划分。
• 自定义划分函数，手动控制划分比例。

2.3.3 分层抽样与数据集划分代码实现

在类别分布不均的情况下，应使用 分层抽样 来保证训练集、验证集和测试集中各类别的比例与原始数据集保持一致。

示例代码（使用PyTorch实现）：

from torchvision import datasets, transforms
from torch.utils.data import random_split, DataLoader
import math

# 定义图像预处理
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor()
])

# 加载数据集
dataset = datasets.ImageFolder(root='Sub_data/', transform=transform)

# 计算各子集大小
total_size = len(dataset)
train_size = int(0.7 * total_size)
val_size = int(0.15 * total_size)
test_size = total_size - train_size - val_size

# 使用random_split进行分层划分
train_dataset, val_dataset, test_dataset = random_split(dataset, [train_size, val_size, test_size])

# 创建DataLoader
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

代码解释：

• transforms.Resize((224, 224)) ：将图像统一缩放为224x224大小，便于后续模型处理。
• datasets.ImageFolder() ：自动识别文件夹结构并加载图像与标签。
• random_split() ：对数据集进行随机划分，保证分层采样。
• DataLoader ：将数据集封装为可迭代的数据加载器，支持批量加载和GPU加速。

流程图示意：

graph TD
    A[加载Sub_data.zip数据集] --> B[应用图像预处理]
    B --> C[计算训练集、验证集、测试集大小]
    C --> D[使用random_split进行分层划分]
    D --> E[创建DataLoader对象]
    E --> F[用于模型训练与评估]

该流程图展示了从数据集加载到最终用于训练的完整数据准备流程。

本章从 Sub_data.zip 数据集的组织结构出发，详细介绍了图像文件夹的分类方式、命名规范与图像统计信息。随后，我们演示了如何使用Python加载并可视化图像数据，并分析了类别分布情况。最后，本章系统讲解了数据集的划分策略，包括训练集、验证集与测试集的功能、常见划分比例以及使用PyTorch进行分层抽样划分的具体实现。这些内容为后续的图像预处理与模型训练打下了坚实的基础。

3. 图像预处理与模型输入准备

在深度学习任务中，数据预处理是决定模型性能的关键步骤之一。对于图像分类任务而言，原始图像数据往往具有不一致的尺寸、色彩分布和光照条件，这会直接影响模型的学习效果。因此，为了提升模型的训练效率和泛化能力，我们需要对图像进行一系列预处理操作，包括尺寸归一化、色彩空间转换、标准化以及数据增强等。这些步骤不仅有助于提升模型的收敛速度，还能增强其对输入数据的鲁棒性。

本章将深入探讨图像预处理的核心技术，重点分析图像尺寸统一的必要性、标准化操作的实现方式以及数据增强策略的应用。通过结合PyTorch框架中的具体实现方法，我们将逐步构建一个完整的图像输入准备流程，为后续的模型训练打下坚实基础。

3.1 图像尺寸归一化与裁剪

图像尺寸的统一是图像预处理中的基础步骤。不同尺寸的图像无法直接输入到深度学习模型中，因为大多数模型（如CNN）要求输入张量的维度是固定的。因此，我们需要对图像进行尺寸归一化处理，确保所有图像具有相同的尺寸。

3.1.1 统一图像尺寸的必要性

深度学习模型的输入通常是一个固定大小的张量，例如 [batch_size, channels, height, width] 。如果输入图像的尺寸不一致，将导致张量维度不统一，从而无法进行批量训练。此外，不同尺寸的图像在卷积操作中会产生不一致的特征图，影响模型的学习能力。

为了解决这一问题，常见的做法是将所有图像缩放到统一尺寸。例如，在ImageNet等大型图像数据集中，通常将图像统一缩放到 224x224 大小，以适配标准的CNN模型输入要求。

3.1.2 双线性插值与中心裁剪方法

图像缩放通常使用插值算法来实现，其中最常用的是 双线性插值（Bilinear Interpolation） 。该方法通过计算周围像素的加权平均值来估计新像素点的值，能够在保持图像清晰度的同时实现平滑缩放。

此外，为了保留图像的主要内容区域，通常会在缩放后进行 中心裁剪（Center Crop） 。例如，先将图像缩放至一个较大的尺寸（如 256x256 ），然后从中裁剪出中心区域的 224x224 部分，这样可以避免边缘信息的丢失。

3.1.3 在PyTorch中实现图像缩放与裁剪

在PyTorch中，我们可以使用 torchvision.transforms 模块来实现图像尺寸归一化和裁剪操作。以下是一个示例代码：

import torchvision.transforms as transforms

transform = transforms.Compose([
    transforms.Resize(256),          # 缩放图像到256x256
    transforms.CenterCrop(224),      # 中心裁剪到224x224
    transforms.ToTensor()            # 转换为张量
])

代码逐行解读：

1. transforms.Resize(256) ：将图像的短边缩放到 256 像素，长边按比例缩放。
2. transforms.CenterCrop(224) ：从图像中心裁剪出 224x224 的区域。
3. transforms.ToTensor() ：将 PIL 图像转换为 PyTorch 张量，并将像素值归一化到 [0, 1] 区间。

参数说明 ：
- Resize 的参数是目标尺寸，可以是整数（表示短边长度）或元组（表示 (height, width) ）。
- CenterCrop 的参数是裁剪尺寸，通常为 (224, 224) 。

表格：图像尺寸归一化方法对比

方法	描述	优点	缺点
双线性插值	通过周围像素加权平均估算新像素	图像质量高，适用于大多数任务	计算复杂度略高
最近邻插值	选择最近像素的值	计算速度快	图像质量较差，易出现锯齿效应
双三次插值	使用更高阶的插值函数	图像质量更高	计算开销大

3.2 色彩空间转换与标准化

图像的色彩空间决定了像素值的表示方式。常见的色彩空间包括 RGB（红绿蓝）、GRAY（灰度图）等。为了提升模型对图像特征的提取能力，我们通常会对图像进行色彩空间转换和标准化处理。

3.2.1 RGB与灰度图转换方法

RGB 图像是最常见的图像格式，每个像素由红、绿、蓝三个通道组成。但在某些任务中，如纹理识别或边缘检测，灰度图可能更合适。在 PyTorch 中，可以通过 transforms.Grayscale() 将图像转换为灰度图：

transform = transforms.Compose([
    transforms.Grayscale(num_output_channels=1),  # 转换为单通道灰度图
    transforms.ToTensor()
])

参数说明 ：
- num_output_channels ：输出图像的通道数，1 表示单通道灰度图，3 表示三通道灰度图（每个通道相同）。

3.2.2 图像归一化与通道标准化

标准化操作可以将图像的像素值从 [0, 255] 范围映射到 [0, 1] 或 [-1, 1] 等标准化区间，以加快模型的收敛速度。PyTorch 提供了 transforms.Normalize() 方法，用于对每个通道进行均值和标准差的标准化：

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # ImageNet标准化参数
])

代码逻辑分析：

• Normalize(mean, std) ：对每个通道应用 (x - mean) / std 的标准化操作。
• 这里使用的是 ImageNet 数据集的均值和标准差，适用于大多数基于 ImageNet 预训练的模型。

3.2.3 在训练流程中集成标准化操作

在实际训练中，我们需要将图像预处理步骤集成到数据加载器中。以下是一个完整的数据加载示例：

from torchvision import datasets, transforms
from torch.utils.data import DataLoader

transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

dataset = datasets.ImageFolder(root='path/to/dataset', transform=transform)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

代码逻辑分析：

• ImageFolder ：自动根据文件夹结构加载图像和标签。
• DataLoader ：用于批量加载图像数据，支持多线程加载和随机打乱。

Mermaid 流程图：图像标准化流程

graph TD
    A[原始图像] --> B[Resize]
    B --> C[CenterCrop]
    C --> D[ToTensor]
    D --> E[Normalize]
    E --> F[标准化图像]

3.3 数据增强策略与实现

数据增强（Data Augmentation）是提升模型泛化能力的重要手段。通过对训练数据进行随机变换，可以人为增加数据的多样性，从而减少过拟合现象。

3.3.1 随机翻转、旋转与色彩扰动

常见的数据增强操作包括：

• 随机翻转（Random Flip） ：左右翻转图像，常用于增强对称性特征。
• 随机旋转（Random Rotation） ：对图像进行一定角度的旋转。
• 色彩扰动（Color Jitter） ：随机调整图像的亮度、对比度、饱和度等颜色参数。

3.3.2 使用torchvision.transforms增强图像

在 PyTorch 中，我们可以使用 transforms 模块中的增强函数来实现上述操作。以下是一个典型的增强流水线：

transform = transforms.Compose([
    transforms.RandomHorizontalFlip(p=0.5),       # 50%概率水平翻转
    transforms.RandomRotation(degrees=30),        # 随机旋转30度
    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),  # 颜色扰动
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

参数说明：

• RandomHorizontalFlip(p=0.5) ：以 50% 的概率进行水平翻转。
• RandomRotation(degrees=30) ：图像旋转角度范围为 ±30 度。
• ColorJitter(...) ：随机调整亮度、对比度、饱和度和色相。

3.3.3 数据增强对模型泛化能力的影响分析

数据增强的核心思想是通过增加训练数据的多样性来提升模型的泛化能力。在训练过程中，模型会看到更多样化的图像变体，从而学习到更具鲁棒性的特征。以下是一些增强操作对模型性能的影响分析：

增强操作	对模型的影响
随机翻转	提升模型对图像方向的不变性
随机旋转	增强模型对角度变化的鲁棒性
色彩扰动	提升模型对光照变化和颜色差异的适应能力
随机裁剪	增强模型对局部特征的关注能力

表格：增强策略对比

增强方法	实现方式	对模型的益处	适用场景
随机翻转	RandomHorizontalFlip	提高对称性识别能力	自然图像、人脸等
随机旋转	RandomRotation	增强角度不变性	文字识别、目标检测
色彩扰动	ColorJitter	提升对光照变化的适应性	室外图像、多光源环境
随机裁剪	RandomResizedCrop	增强模型对局部特征的提取能力	图像分类、目标识别

Mermaid 流程图：数据增强流程

graph TD
    A[原始图像] --> B[RandomFlip]
    B --> C[RandomRotation]
    C --> D[ColorJitter]
    D --> E[Normalize]
    E --> F[增强后的图像]

通过本章的学习，我们已经掌握了图像预处理的核心步骤，包括尺寸归一化、色彩空间转换、标准化以及数据增强策略。这些操作不仅提高了图像数据的一致性，还增强了模型的泛化能力，为后续的模型训练和评估打下了坚实的基础。在下一章中，我们将深入探讨卷积神经网络（CNN）的基本原理及其在图像分类任务中的应用。

4. 卷积神经网络基础与训练配置

深度学习在图像分类任务中取得了革命性的突破，而卷积神经网络（Convolutional Neural Network, CNN）正是这一突破的核心技术之一。本章将从CNN的基本原理出发，逐步深入探讨其在图像分类任务中的结构设计与训练配置方法。我们将从卷积层、池化层到全连接层，系统性地解析CNN的工作机制。随后，围绕损失函数的选择、优化器配置、学习率调整策略以及正则化方法等关键训练参数进行详细讲解。通过本章的学习，读者将掌握构建和训练图像分类模型所需的核心知识。

4.1 卷积神经网络（CNN）原理概述

4.1.1 卷积层与池化层的工作机制

卷积层是CNN的核心组成部分，负责从输入图像中提取局部特征。其基本操作是使用一个称为“卷积核”或“滤波器”的小矩阵在图像上滑动，与局部区域进行点积运算，从而提取出特定的特征（如边缘、角点、纹理等）。

import torch
import torch.nn as nn

# 定义一个简单的卷积层
conv_layer = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1)

# 模拟输入图像（batch_size=1, channels=3, height=32, width=32）
input_image = torch.randn(1, 3, 32, 32)

# 前向传播
output = conv_layer(input_image)
print(output.shape)  # 输出：torch.Size([1, 16, 32, 32])

代码逻辑分析：

• nn.Conv2d 定义了一个二维卷积层，参数说明如下：
• in_channels=3 ：输入图像的通道数（RGB图像）。
• out_channels=16 ：输出通道数，即卷积核的数量。
• kernel_size=3 ：卷积核大小为 3×3。
• stride=1 ：滑动步长为1。
• padding=1 ：边缘填充1层，保持输出尺寸不变。

执行后，输出张量的形状为 (1, 16, 32, 32) ，表示1个样本，16个通道，每个通道的特征图大小为 32×32。

池化层（Pooling Layer）用于降低特征图的空间维度，从而减少计算量并增强模型的平移不变性。最常用的池化方式是最大池化（Max Pooling）：

# 定义最大池化层
pool_layer = nn.MaxPool2d(kernel_size=2, stride=2)

# 输入特征图（batch_size=1, channels=16, height=32, width=32）
input_features = torch.randn(1, 16, 32, 32)

# 前向传播
output = pool_layer(input_features)
print(output.shape)  # 输出：torch.Size([1, 16, 16, 16])

参数说明：

• kernel_size=2 ：池化窗口大小为 2×2。
• stride=2 ：每次滑动2个像素，实现下采样。

输出张量的形状为 (1, 16, 16, 16) ，表示特征图尺寸缩小了一半。

4.1.2 全连接层与输出层设计

在经过多层卷积与池化之后，特征图会被展平并送入全连接层（Fully Connected Layer），最终输出分类结果。

# 定义全连接层
fc_layer = nn.Linear(in_features=16*16*16, out_features=10)  # 输出10类

# 假设输入为池化后的展平特征
input_flattened = torch.randn(1, 16*16*16)

# 前向传播
output = fc_layer(input_flattened)
print(output.shape)  # 输出：torch.Size([1, 10])

参数说明：

• in_features=16*16*16 ：输入特征的总维度，等于上一层输出的通道数 × 高 × 宽。
• out_features=10 ：输出类别数，如CIFAR-10为10类。

全连接层将高维特征映射到类别空间，为最终的分类决策提供支持。

4.1.3 CNN在图像分类任务中的优势

相比传统机器学习方法，CNN在图像分类中具有以下显著优势：

优势	描述
局部感知	卷积操作能够捕捉图像的局部空间特征，更符合视觉感知机制
参数共享	同一卷积核在整张图像上滑动，大幅减少参数数量，提升泛化能力
平移不变性	池化操作使模型对图像的平移具有一定的鲁棒性
自动特征提取	无需人工设计特征，CNN自动学习从像素到语义的映射

此外，CNN可以通过堆叠多个卷积-池化模块来提取更高级别的语义信息，从而在复杂图像分类任务中表现优异。

4.2 损失函数与优化器选择

4.2.1 交叉熵损失函数的数学原理

交叉熵损失函数（Cross Entropy Loss）是图像分类任务中最常用的损失函数，它衡量模型预测概率分布与真实标签之间的差异。

对于多类别分类问题，交叉熵损失函数定义如下：

L = -\sum_{i=1}^{C} y_i \log(p_i)

其中：
- $ y_i $ 是第 $ i $ 类的真实标签（one-hot编码）
- $ p_i $ 是模型预测第 $ i $ 类的概率

该函数鼓励模型将真实类别的预测概率最大化，从而提高分类准确率。

4.2.2 使用PyTorch实现交叉熵损失

在PyTorch中，交叉熵损失由 nn.CrossEntropyLoss 提供，它内部自动包含 Softmax 操作，因此无需手动添加。

import torch
import torch.nn as nn

# 模型输出（logits），假设输出为10类
logits = torch.randn(3, 10)  # batch_size=3, num_classes=10

# 真实标签（类别索引形式）
labels = torch.tensor([2, 5, 7])

# 定义损失函数
criterion = nn.CrossEntropyLoss()

# 计算损失
loss = criterion(logits, labels)
print(loss.item())  # 打印损失值

参数说明：

• logits ：模型输出的原始分数（未经过Softmax）。
• labels ：真实类别索引，形状为 (batch_size,) 。
• loss ：返回一个标量，表示当前batch的平均损失值。

4.2.3 Adam优化器的配置与参数调优

Adam优化器是一种自适应学习率优化算法，广泛用于深度学习训练。它结合了动量法和RMSProp的优点，能够自动调整学习率。

import torch.optim as optim

# 假设model为定义好的CNN模型
model = nn.Sequential(
    nn.Conv2d(3, 16, 3),
    nn.ReLU(),
    nn.MaxPool2d(2),
    nn.Flatten(),
    nn.Linear(16*14*14, 10)
)

# 配置Adam优化器
optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-5)

参数说明：

• lr=0.001 ：初始学习率，默认值，适用于大多数任务。
• weight_decay=1e-5 ：L2正则化系数，用于防止过拟合。

在训练过程中，通常会结合学习率调度器（如StepLR、Cosine退火等）进一步优化训练过程。

4.3 学习率策略与正则化方法

4.3.1 学习率衰减策略（StepLR、Cosine退火）

学习率衰减策略可以动态调整学习率，以提升训练效率和模型性能。

StepLR：阶梯式衰减

scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.1)

• step_size=30 ：每30个epoch降低一次学习率。
• gamma=0.1 ：每次衰减乘以0.1。

Cosine退火：余弦退火策略

scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=100)

• T_max=100 ：余弦周期长度，通常设置为总训练epoch数。

学习率策略对比表：

方法	特点	适用场景
StepLR	固定周期衰减，简单易用	稳定训练过程
CosineAnnealing	周期性变化，适合复杂模型	提升模型收敛速度
ReduceLROnPlateau	监控验证损失自动调整	自动优化学习率

4.3.2 Dropout与L2正则化防止过拟合

过拟合是深度学习中常见的问题，可以通过Dropout和L2正则化来缓解。

# 在模型中加入Dropout层
model = nn.Sequential(
    nn.Conv2d(3, 16, 3),
    nn.ReLU(),
    nn.MaxPool2d(2),
    nn.Dropout(0.5),  # 50%的神经元被随机关闭
    nn.Flatten(),
    nn.Linear(16*14*14, 10)
)

• Dropout(0.5) ：在训练阶段，以50%的概率将输入元素置为0，防止特征过度依赖。

L2正则化通过在损失函数中添加权重的平方和来惩罚模型复杂度：

optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-5)

• weight_decay=1e-5 ：L2正则化系数，控制惩罚强度。

4.3.3 Early Stopping机制与模型保存策略

Early Stopping是一种防止过拟合的策略，当验证损失在连续若干个epoch中不再下降时，提前终止训练。

class EarlyStopping:
    def __init__(self, patience=5, delta=0):
        self.patience = patience
        self.delta = delta
        self.counter = 0
        self.best_score = None
        self.early_stop = False

    def __call__(self, val_loss):
        score = -val_loss
        if self.best_score is None:
            self.best_score = score
        elif score < self.best_score + self.delta:
            self.counter += 1
            if self.counter >= self.patience:
                self.early_stop = True
        else:
            self.best_score = score
            self.counter = 0

参数说明：

• patience=5 ：连续5个epoch验证损失未改善则停止训练。
• delta=0 ：容忍的最小改善值。

模型保存策略建议在验证损失最优时保存模型：

if val_loss < best_val_loss:
    best_val_loss = val_loss
    torch.save(model.state_dict(), 'best_model.pth')

这有助于在训练完成后保留性能最佳的模型版本。

本章从卷积神经网络的基本结构讲起，详细解析了卷积层、池化层与全连接层的工作机制，并深入探讨了损失函数、优化器、学习率策略以及防止过拟合的正则化方法。通过代码实现与参数说明，帮助读者理解如何构建一个完整的图像分类训练流程。下一章我们将进入实战阶段，介绍如何搭建完整的训练循环并评估模型性能。

5. 模型训练与性能评估实战

在深度学习任务中，模型训练和性能评估是整个流程中最关键的环节。本章将围绕图像分类任务的训练流程展开，详细介绍如何构建一个完整的训练循环、使用GPU加速、记录训练日志，并借助TensorBoard进行可视化。随后，我们将深入探讨模型评估的核心指标，如准确率、混淆矩阵、分类报告等，并结合Sub_data.zip数据集，指导读者完成李宏毅课程作业3的实际操作与结果分析。

5.1 图像分类模型训练流程搭建

训练一个深度学习模型不仅仅是调用几个函数那么简单，它需要精心设计训练流程、数据加载方式以及训练日志的管理。以下将介绍一个典型的图像分类模型训练流程。

5.1.1 构建完整的训练循环

一个完整的训练循环通常包括以下几个步骤：

1. 加载数据集 ：使用 DataLoader 进行批量加载；
2. 定义模型 ：如ResNet、VGG等；
3. 定义损失函数与优化器 ；
4. 前向传播 ；
5. 计算损失 ；
6. 反向传播与参数更新 ；
7. 记录训练日志（如loss、accuracy） ；

以下是一个使用PyTorch实现的训练循环示例：

import torch
import torch.nn as nn
from torch.utils.data import DataLoader

# 假设 model, train_loader, optimizer, criterion 已经定义
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0
    correct = 0
    total = 0
    for inputs, labels in train_loader:
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        _, predicted = outputs.max(1)
        total += labels.size(0)
        correct += predicted.eq(labels).sum().item()
    train_acc = correct / total
    print(f"Epoch {epoch+1} | Loss: {running_loss:.4f} | Accuracy: {train_acc:.4f}")

参数说明 ：
- device ：指定使用GPU还是CPU；
- model.train() ：切换为训练模式；
- optimizer.zero_grad() ：清空梯度；
- loss.backward() ：反向传播；
- optimizer.step() ：更新参数；
- running_loss ：累计损失；
- correct / total ：计算准确率。

5.1.2 批次训练与GPU加速实现

在PyTorch中，通过 DataLoader 可以方便地进行批次训练。同时，借助GPU（如NVIDIA CUDA）可以显著提升训练速度。

from torch.utils.data import DataLoader

train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, num_workers=4)

num_workers ：用于多线程加载数据，加快训练速度。

如果GPU可用，可以通过以下方式启用：

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

5.1.3 日志记录与可视化工具TensorBoard

TensorBoard是PyTorch中常用的可视化工具，可以实时监控loss、accuracy、图像输入等信息。

from torch.utils.tensorboard import SummaryWriter

writer = SummaryWriter('runs/experiment1')

for epoch in range(num_epochs):
    # ... 训练代码 ...
    writer.add_scalar('Loss/train', running_loss, epoch)
    writer.add_scalar('Accuracy/train', train_acc, epoch)

writer.close()

执行逻辑说明 ：
- SummaryWriter 创建一个日志目录；
- add_scalar 将loss和accuracy写入日志；
- 使用命令 tensorboard --logdir=runs 启动可视化界面。

5.2 模型评估与性能指标分析

模型训练完成后，需要对其性能进行系统评估，常用指标包括准确率、混淆矩阵、分类报告等。以下将详细介绍这些评估方法，并通过代码示例展示如何在PyTorch中实现。

5.2.1 准确率、混淆矩阵与分类报告

from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
import numpy as np

model.eval()
all_preds = []
all_labels = []

with torch.no_grad():
    for inputs, labels in test_loader:
        inputs = inputs.to(device)
        outputs = model(inputs)
        _, preds = torch.max(outputs, 1)
        all_preds.extend(preds.cpu().numpy())
        all_labels.extend(labels.numpy())

acc = accuracy_score(all_labels, all_preds)
print(f"Test Accuracy: {acc:.4f}")

print("Confusion Matrix:")
print(confusion_matrix(all_labels, all_preds))

print("Classification Report:")
print(classification_report(all_labels, all_preds))

参数说明 ：
- model.eval() ：切换为评估模式；
- torch.no_grad() ：禁用梯度计算，节省内存；
- accuracy_score ：计算准确率；
- confusion_matrix ：显示预测与实际的对比矩阵；
- classification_report ：显示precision、recall、F1-score等指标。

5.2.2 验证集与测试集的性能对比

在训练过程中，我们通常将数据划分为训练集、验证集和测试集。验证集用于调参，测试集用于最终评估模型性能。

# 验证集评估示例
val_loss = 0.0
correct = 0
total = 0

with torch.no_grad():
    for inputs, labels in val_loader:
        inputs, labels = inputs.to(device), labels.to(device)
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        val_loss += loss.item()
        _, predicted = outputs.max(1)
        total += labels.size(0)
        correct += predicted.eq(labels).sum().item()

val_acc = correct / total
print(f"Validation Loss: {val_loss:.4f}, Accuracy: {val_acc:.4f}")

对比分析 ：
- 如果验证集准确率显著高于测试集，可能存在过拟合；
- 若两者差距不大，说明模型泛化能力较强。

5.2.3 泛化能力与模型鲁棒性评估

为了进一步评估模型的鲁棒性，可以尝试以下方法：

1. 对测试图像进行扰动 （如高斯噪声、亮度调整）；
2. 使用对抗样本攻击模型 ；
3. 交叉验证 （如K折交叉验证）；
4. 可视化注意力热力图 （如Grad-CAM）。

这些方法有助于发现模型的弱点并进行针对性优化。

5.3 李宏毅课程作业3实战指南

本节将结合Sub_data.zip数据集，详细讲解如何完成李宏毅课程作业3中的图像分类任务。

5.3.1 Sub_data.zip在课程作业中的使用方法

Sub_data.zip是一个食物图像分类数据集，包含多个类别，如 noodles , rice , vegetable 等。其文件夹结构如下：

Sub_data/
├── train/
│   ├── noodles/
│   ├── rice/
│   └── vegetable/
├── val/
│   ├── noodles/
│   ├── rice/
│   └── vegetable/
└── test/
    ├── 0001.jpg
    ├── 0002.jpg
    └── ...

其中 test 文件夹中没有子文件夹，仅包含待预测的图像。

加载方式 （使用 ImageFolder ）：

from torchvision import datasets, transforms

transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

train_dataset = datasets.ImageFolder(root='Sub_data/train', transform=transform)
val_dataset = datasets.ImageFolder(root='Sub_data/val', transform=transform)
test_dataset = datasets.ImageFolder(root='Sub_data/test', transform=transform)

注意： test_dataset 需要自定义 __getitem__ 方法以忽略标签。

5.3.2 代码结构与训练技巧总结

建议将代码结构划分为以下模块：

• models/ ：存放模型定义（如ResNet、VGG）；
• data/ ：数据加载与预处理；
• train.py ：训练主函数；
• evaluate.py ：评估与结果分析；
• submit.py ：生成提交文件；

训练技巧 ：
- 使用预训练模型（如 torchvision.models.resnet18(pretrained=True) ）；
- 设置合理的学习率（如 1e-4 ）；
- 使用早停（Early Stopping）防止过拟合；
- 多尺度训练或混合精度训练提升效率。

5.3.3 提交格式与结果分析建议

在完成模型训练与测试后，需将预测结果保存为 submission.csv 文件，格式如下：

id,label
0001.jpg,noodles
0002.jpg,rice

代码示例 ：

import pandas as pd

test_filenames = [f.name for f in test_dataset.samples]
preds = [...]  # 假设已经预测完成

submission = pd.DataFrame({
    'id': test_filenames,
    'label': preds
})
submission.to_csv('submission.csv', index=False)

结果分析建议 ：
- 观察测试集预测结果与验证集表现的差异；
- 若部分类别准确率较低，可尝试对该类进行数据增强；
- 使用混淆矩阵分析模型容易混淆的类别组合。

下一章将继续探讨模型优化与部署相关内容。

本文还有配套的精品资源，点击获取

简介：Sub_data.zip是李宏毅教授视频课作业3中提供的微型食物分类数据集，专为深度学习图像分类学习设计。该数据集分为训练集、验证集和测试集，适用于初学者掌握图像分类任务中的数据结构、预处理流程和模型训练方法。通过使用CNN等深度学习框架，学习者可以实践图像分类的核心技术，包括特征提取、损失函数优化和模型泛化能力评估。

本文还有配套的精品资源，点击获取