•  🍨 本文为🔗365天深度学习训练营 中的学习记录博客
• 🍖 原作者：K同学啊

我的环境：

• 语言环境：Python3.10.7
• 编译器：VScode
• 深度学习环境：TensorFlow 2.13.0

一、前期工作： 

1.导入数据集

准备用于训练和测试的CIFAR-10数据集，将图像数据转换为适合PyTorch处理的Tensor类型，并为后续的机器学习任务做准备。

使用PyTorch和TorchVision库来处理CIFAR-10数据集的示例代码。CIFAR-10是一个常用的计算机视觉数据集，包含了10个不同类别的图像，每个类别有6000张32x32像素大小的彩色图像。

代码

import torch
import torch.nn as nn
import matplotlib.pyplot as plt
import torchvision

train_ds = torchvision.datasets.CIFAR10('data',
                                        train=True,
                                        transform=torchvision.transforms.ToTensor(), # 将数据类型转化为Tensor
                                        download=True)

test_ds = torchvision.datasets.CIFAR10('data',
                                       train=False,
                                       transform=torchvision.transforms.ToTensor(), # 将数据类型转为成Tensor
                                       download=True)

部分代码解释：
   torch：PyTorch库，用于构建和训练神经网络。
   torch.nn：PyTorch中的神经网络模块。
   matplotlib.pyplot：用于绘制图像的库。
   torchvision：PyTorch的视觉工具库，包含了常用的数据集、模型架构等。

定义训练数据集（`train_ds`）:

•    使用'torchvision.datasets.CIFAR10'函数创建一个CIFAR-10训练数据集对象。
•    'data'：指定数据集下载和保存的文件夹路径。
•     'train=True'：表示这是训练数据集。
•    'transform=torchvision.transforms.ToTensor()'：将图像数据转换为PyTorch的`Tensor`类型，以便后续处理。
•    'download=True'：如果数据集没有下载，将自动下载。

 定义测试数据集（`test_ds`）:

•     使用与训练数据集相同的函数创建一个CIFAR-10测试数据集对象。
•     'train=False'：表示这是测试数据集。

数据集的用途:

•     训练数据集（`train_ds`）用于训练机器学习模型，例如神经网络。
•     测试数据集（`test_ds`）用于评估模型在未见过的数据上的性能。

运行结果

 

2. 创建训练数据加载器（train_dl）和测试数据加载器（test_dl）

使用PyTorch的`DataLoader`来创建训练数据加载器（'train_dl'）和测试数据加载器（'test_dl'），将数据划分成批次，以便用于训练和评估模型。同时，它展示了如何从数据加载器中获取一个批次的数据，并打印出图像数据的形状。

代码 

batch_size = 32

train_dl = torch.utils.data.DataLoader(train_ds,
                                       batch_size=batch_size,
                                       shuffle=True)

test_dl = torch.utils.data.DataLoader(test_ds,
                                      batch_size=batch_size)
# 取一个批次查看数据格式
# 数据的shape为：[batch_size, channel, height, weight]
# 其中batch_size为自己设定， channel, height, weight 分别是图片的通道数，高度，宽度
imgs, labels = next(iter(train_dl))
print(imgs.shape)

部分代码解释：

 定义批次大小：

•    batch_size = 32：指定每个批次中包含的样本数。

 创建训练数据加载器（`train_dl`）：

•     使用'torch.utils.data.DataLoader'函数创建一个数据加载器用于训练数据集。
•     'train_ds'：之前定义的训练数据集对象。
•     'batch_size=batch_size'：每个批次包含的样本数。
•     'shuffle=True'：将训练数据集随机打乱，以便在每个 epoch 中获取随机的批次样本。

 创建测试数据加载器（'test_dl'）：

•     使用与训练数据加载器相同的函数创建一个数据加载器用于测试数据集。
•     'test_ds'：之前定义的测试数据集对象。
•     'batch_size=batch_size'：每个批次包含的样本数。

 查看一个批次的数据形状：

•    使用`next(iter(train_dl))`获取训练数据加载器的一个批次的数据。
•    这个批次包含了`batch_size`个图像和对应的标签。
•    'imgs'包含了图像数据，`labels`包含了对应的标签。
•    'imgs.shape'打印出了这个批次图像数据的形状，即'[batch_size, channel, height, width]'，其中'channel'是通道数，'height'是图像高度，'width'是图像宽度。

运行结果

3.数据可视化 

使用matplotlib库来绘制一个包含多个子图的图像显示，用于可视化训练数据中的图像样本。

代码

import numpy as np

# 指定图片大小，图像大小宽度为20宽、5高的绘图（单位为英寸inch)
plt.figure(figsize=(20, 5))
for i, imgs in enumerate(imgs[:20]):
    # 维度缩减
    npimg = imgs.numpy().transpose((1, 2, 0))
    # 将整个figure分成2行10列， 绘制第i+1个子图
    plt.subplot(2, 10, i+1)
    plt.imshow(npimg, cmap=plt.cm.binary)
    plt.axis('off')
plt.show()

指定图片大小：
   'plt.figure(figsize=(20, 5))'：创建一个图像对象，指定图像的大小为20英寸宽和5英寸高。 

循环绘制子图：

•     使用'enumerate'函数遍历'imgs[:20]'中的图像数据（这里只绘制前20个图像）。
•     'imgs'是从之前的数据加载器中获取的一个批次的图像数据。
•     'npimg = imgs.numpy().transpose((1, 2, 0))'：将图像数据从Tensor格式转换为NumPy数组格式，并且将通道维度移动到最后一个维度，以便与matplotlib的图像显示兼容。 

运行结果

 

 

二、构建简单的CNN网络 

这段代码定义了一个简单的卷积神经网络（Convolutional Neural Network，CNN）模型,该模型包含了特征提取网络和分类网络两个部分，用于将CIFAR-10数据集中的图像进行分类。特征提取网络使用卷积和池化操作来提取图像特征，而分类网络使用全连接层将提取的特征映射到类别上。模型的`forward`方法定义了数据在网络中的传递过程。并解释了每个部分的作用。该模型用于处理CIFAR-10数据集的图像分类任务。

 代码

import torch.nn.functional as F

num_classes = 10  # 图片的类别数

class Model(nn.Module):
     def __init__(self):
        super().__init__()
         # 特征提取网络
        self.conv1 = nn.Conv2d(3, 64, kernel_size=3)   # 第一层卷积,卷积核大小为3*3
        self.pool1 = nn.MaxPool2d(kernel_size=2)       # 设置池化层，池化核大小为2*2
        self.conv2 = nn.Conv2d(64, 64, kernel_size=3)  # 第二层卷积,卷积核大小为3*3   
        self.pool2 = nn.MaxPool2d(kernel_size=2) 
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3) # 第二层卷积,卷积核大小为3*3   
        self.pool3 = nn.MaxPool2d(kernel_size=2) 
                                      
        # 分类网络
        self.fc1 = nn.Linear(512, 256)          
        self.fc2 = nn.Linear(256, num_classes)
     # 前向传播
     def forward(self, x):
        x = self.pool1(F.relu(self.conv1(x)))     
        x = self.pool2(F.relu(self.conv2(x)))
        x = self.pool3(F.relu(self.conv3(x)))
        
        x = torch.flatten(x, start_dim=1)

        x = F.relu(self.fc1(x))
        x = self.fc2(x)
       
        return x


from torchinfo import summary
# 将模型转移到GPU中（我们模型运行均在GPU中进行）
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = Model().to(device)

summary(model)

部分代码解释：

1. 定义类别数：

   'num_classes = 10'：指定图片的类别数，对于CIFAR-10数据集，共有10个不同的类别。

 2.定义CNN模型类（`Model`类）：
   继承自'nn.Module'，这是PyTorch中构建神经网络模型的基类。

 3.初始化函数：

•     '__init__(self)'：构造函数，在创建类的实例时被调用。
•     定义了模型的各个层。

 4.特征提取网络部分：

•     定义了卷积层和池化层，用于提取图像的特征。
•     'nn.Conv2d'：卷积层，进行卷积操作，提取图像的局部特征。
•     'nn.MaxPool2d'：最大池化层，进行下采样操作，减小特征图的尺寸。

 5.分类网络部分：

•     定义了全连接层，用于将提取的特征映射到类别上。
•     'nn.Linear'：全连接层，进行线性变换和非线性激活。

6. 前向传播方法：

•     'forward(self, x)'：定义了模型的前向传播过程。
•     通过特征提取网络处理输入的图像数据，然后通过全连接层得到分类结果。

7. 前向传播过程：

•     通过卷积层、激活函数和池化层进行特征提取。
•     使用'orch.flatten'将特征图展平为向量，以便输入全连接层。
•     通过激活函数和全连接层将特征映射到最终的类别数上。

运行结果

 

三、训练模型 

1.设置超参数

模型的训练过程损失函数的定义和优化器的设置

该代码段的作用是准备用于模型训练的损失函数和优化器。损失函数用于衡量模型预测与真实标签之间的差异，而优化器根据这个差异来更新模型参数，以便在训练过程中逐步提升模型的性能。

loss_fn    = nn.CrossEntropyLoss() # 创建损失函数
learn_rate = 1e-2 # 学习率
opt        = torch.optim.SGD(model.parameters(),lr=learn_rate)

代码解释：

1. 定义损失函数：

•    'loss_fn = nn.CrossEntropyLoss()'：创建了一个交叉熵损失函数的实例。交叉熵损失通常用于多类别分类问题，例如本例中的CIFAR-10数据集。

2. 设置学习率：

•    'learn_rate = 1e-2'：定义了学习率，它决定了在优化过程中参数更新的步幅大小。

3. 定义优化器：

•    'opt = torch.optim.SGD(model.parameters(), lr=learn_rate)'：创建了一个随机梯度下降（SGD）优化器的实例。
•    'model.parameters()'：获取模型的所有可训练参数。
•    'lr=learn_rate'：设置优化器的学习率为之前定义的学习率。

   
优化器是用于更新模型参数以最小化损失函数的工具。在训练过程中，优化器根据损失函数计算的梯度信息来调整模型参数，使损失逐渐减小，从而提高模型在训练数据上的性能。

2.编写训练函数

定义训练循环函数，该训练循环函数用于在训练数据上对模型进行训练。它通过反向传播来更新模型参数，同时记录训练过程中的正确率和损失，以便在每个训练周期结束后评估模型的性能。

# 训练循环
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 训练集的大小，一共60000张图片
    num_batches = len(dataloader)   # 批次数目，1875（60000/32）

    train_loss, train_acc = 0, 0  # 初始化训练损失和正确率
    
    for X, y in dataloader:  # 获取图片及其标签
        X, y = X.to(device), y.to(device)
        
        # 计算预测误差
        pred = model(X)          # 网络输出
        loss = loss_fn(pred, y)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失
        
        # 反向传播
        optimizer.zero_grad()  # grad属性归零
        loss.backward()        # 反向传播
        optimizer.step()       # 每一步自动更新
        
        # 记录acc与loss
        train_acc  += (pred.argmax(1) == y).type(torch.float).sum().item()
        train_loss += loss.item()
            
    train_acc  /= size
    train_loss /= num_batches

    return train_acc, train_loss

代码逻辑：

1. 定义训练循环函数（train函数）：

   • 这个函数接受数据加载器（dataloader）、模型（model）、损失函数（loss_fn）和优化器（optimizer）作为输入。

2. 获取训练集大小和批次数目：

   • size = len(dataloader.dataset)：获取整个训练数据集的大小，即60000张图片。
   • num_batches = len(dataloader)：获取数据加载器中的批次数目，即1875（60000/32）。

3. 初始化训练损失和正确率：

   • train_loss, train_acc = 0, 0：初始化训练损失和训练正确率。

4. 进入训练循环：

   • for X, y in dataloader:：对数据加载器中的每个批次进行迭代，其中X是图像数据，y是对应的标签。

5. 将数据移至设备：

   • X, y = X.to(device), y.to(device)：将批次中的图像数据和标签移至指定的设备（例如GPU）进行计算。

6. 计算预测误差：

   • pred = model(X)：将图像数据输入模型，获得模型的预测输出。
   • loss = loss_fn(pred, y)：使用定义的损失函数计算预测输出与真实标签之间的误差。

7. 反向传播：

   • optimizer.zero_grad()：将模型参数的梯度归零，准备进行反向传播。
   • loss.backward()：根据损失计算参数的梯度。
   • optimizer.step()：根据梯度更新模型的参数。

8. 记录正确率和损失：

   • train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()：计算并累加正确分类的样本数，.argmax(1)得到每个批次的预测类别，与真实标签比较，判断是否正确。
   • train_loss += loss.item()：将当前批次的损失值累加。

9. 计算平均正确率和损失：

   • train_acc /= size：计算平均正确率。
   • train_loss /= num_batches：计算平均损失。

10. 返回训练过程中的正确率和损失。

3.编写测试函数

定义一个测试函数，用于在测试数据集上对模型进行评估，返回测试过程中的正确率和损失。该测试函数用于在测试数据集上对模型进行评估，不进行参数更新。它计算并返回测试过程中的平均正确率和损失，以评估模型在未见过的数据上的性能。

def test (dataloader, model, loss_fn):
    size        = len(dataloader.dataset)  # 测试集的大小，一共10000张图片
    num_batches = len(dataloader)          # 批次数目，313（10000/32=312.5，向上取整）
    test_loss, test_acc = 0, 0
    
    # 当不进行训练时，停止梯度更新，节省计算内存消耗
    with torch.no_grad():
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)
            
            # 计算loss
            target_pred = model(imgs)
            loss        = loss_fn(target_pred, target)
            
            test_loss += loss.item()
            test_acc  += (target_pred.argmax(1) == target).type(torch.float).sum().item()

    test_acc  /= size
    test_loss /= num_batches

    return test_acc, test_loss

代码逻辑：

1. 定义测试函数（test函数）：

   • 这个函数接受数据加载器（dataloader）、模型（model）和损失函数（loss_fn）作为输入。

2. 获取测试集大小和批次数目：

   • size = len(dataloader.dataset)：获取整个测试数据集的大小，即10000张图片。
   • num_batches = len(dataloader)：获取数据加载器中的批次数目，即313（10000/32，向上取整）。

3. 初始化测试损失和正确率：

   • test_loss, test_acc = 0, 0：初始化测试损失和测试正确率。

4. 进入测试循环：

   • with torch.no_grad():：在这个上下文管理器中，不进行梯度更新，以减少计算内存的消耗。
   • for imgs, target in dataloader:：对数据加载器中的每个批次进行迭代，其中imgs是图像数据，target是对应的标签。

5. 将数据移至设备：

   • imgs, target = imgs.to(device), target.to(device)：将批次中的图像数据和标签移至指定的设备（例如GPU）进行计算。

6. 计算预测误差：

   • target_pred = model(imgs)：将图像数据输入模型，获得模型的预测输出。
   • loss = loss_fn(target_pred, target)：使用定义的损失函数计算预测输出与真实标签之间的误差。

7. 记录正确率和损失：

   • test_loss += loss.item()：将当前批次的损失值累加。
   • test_acc += (target_pred.argmax(1) == target).type(torch.float).sum().item()：计算并累加正确分类的样本数，与训练循环中类似。

8. 计算平均正确率和损失：

   • test_acc /= size：计算平均正确率。
   • test_loss /= num_batches：计算平均损失。

9. 返回测试过程中的正确率和损失。

4.正式训练

epochs     = 20
train_loss = []
train_acc  = []
test_loss  = []
test_acc   = []

for epoch in range(epochs):
    model.train()
    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)
    
    model.eval()
    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)
    
    train_acc.append(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)
    
    template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%，Test_loss:{:.3f}')
    print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss, epoch_test_acc*100, epoch_test_loss))
print('Done')

 

四、结果可视化

import matplotlib.pyplot as plt
#隐藏警告
import warnings
warnings.filterwarnings("ignore")               #忽略警告信息
plt.rcParams['font.sans-serif']    = ['SimHei'] # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False      # 用来正常显示负号
plt.rcParams['figure.dpi']         = 100        #分辨率

epochs_range = range(epochs)

plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)

plt.plot(epochs_range, train_acc, label='Training Accuracy')
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()