Week1-P1: 实现mnist手写数字识别

e601

已于 2023-12-30 16:14:54 修改

阅读量1.4k

点赞数 49

文章标签： python 机器学习深度学习 pytorch

于 2023-12-29 15:47:15 首次发布

本文链接：https://blog.csdn.net/weixin_56547604/article/details/135290375

版权

🍨 本文为[🔗365天深度学习训练营] 中的学习记录博客
🍖 原作者：[K同学啊 | 接辅导、项目定制]

我的环境：

语言环境：Anaconda3 (Python3)

编译器：jupyter notebook

深度学习环境：Pytorch

torch == 1.12.1+cu116

torchvision == 0.13.1+cu116

1. 准备

1.1 设置GPU

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

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

device

输出

device(type='cuda')

1.2 导入数据

torchvision.datasets.MNIST：这是专门设计用于加载MNIST数据集的PyTorch数据集类。

'data'：这是数据集将被存储或检索的目录。如果目录不存在，将会被创建。在这里，设置为'data'。

train=True：这表示应加载MNIST数据集的训练部分。

train=False，用于加载测试部分。

transform=torchvision.transforms.ToTensor()：这是应用于数据集中每个样本的转换。在这种情况下，使用ToTensor()将图像转换为PyTorch张量。MNIST图像最初是PIL图像的形式，而此转换将其转换为PyTorch张量。

download=True：这指定如果目录中不存在数据集，则应下载数据集。

变量train_ds 将保存MNIST的训练集，变量test_ds 将保存MNIST的测试集。

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

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

总的来说，这些代码行设置并加载了MNIST数据集的训练和测试集，确保图像被转换为PyTorch张量。

batch_size：这是每个训练或测试批次中包含的图像数量。在这里，设置为10，但根据你的电脑内存情况，你可以调整这个值以更好地适应你的硬件。

torch.utils.data.DataLoader：这是PyTorch中用于创建数据加载器的类。

train_ds：这是之前加载的MNIST训练数据集。

batch_size=batch_size：这是指定每个批次中包含的图像数量，即上面定义的batch_size。

shuffle=True：这是表示在每个时期（epoch）开始前是否对数据进行随机重排。设置为True可以帮助模型更好地学习，因为它可以在每个时期中看到不同的数据顺序。

总的来说，这段代码创建了用于训练和测试的数据加载器，以便以批次的方式有效地加载MNIST数据集。

batch_size = 10 # 根据电脑内存调整大小

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)

iter(train_dl)：这是创建了一个迭代器，允许我们逐个获取训练数据加载器中的批次。

next(...)：这是用于获取迭代器的下一个元素，即训练数据加载器的下一个批次。

imgs, labels：这是将批次中的图像和标签分别赋值给变量 imgs 和 labels。

imgs.shape：这是显示图像张量的形状。在这里，输出的形状是 [10, 1, 28, 28]，解释如下：

10：这是批次大小，表示一批中有10张图像。

1：这是通道数，表示图像是单通道的（灰度图像）。

28：这是图像的高度。

28：这是图像的宽度。

这说明了图像数据张量的结构，有助于理解神经网络的输入。

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

输出

torch.Size([10, 1, 28, 28])

1.3 数据可视化

这段代码使用Matplotlib库绘制图像，展示从训练数据加载器中获取的一个批次的图像。

import numpy as np：这是导入NumPy库，并使用别名np。NumPy通常用于处理和操作数组数据。

plt.figure(figsize=(20, 5))：这是创建一个新的图形窗口，设置图形的大小为宽20英寸、高5英寸。这个图形窗口将用于绘制图像。

for i, imgs in enumerate(imgs[:20]):：这是一个循环，遍历批次中的前20张图像。enumerate同时返回索引i和对应的元素imgs。

np.squeeze(imgs.numpy())：这是将PyTorch张量转换为NumPy数组，并使用np.squeeze函数将维度为1的维度去除。这是因为Matplotlib期望的图像是三维数组，而原始数据可能是四维的。

plt.subplot(2, 10, i+1)：这是在图形窗口中创建一个子图，将整个图形窗口分成2行10列，然后选择第i+1个子图进行绘制。

plt.imshow(npimg, cmap=plt.cm.binary)：这是用Matplotlib的imshow函数绘制图像。cmap=plt.cm.binary表示使用二进制（黑白）的颜色映射。

plt.axis('off')：这是关闭坐标轴，使图像更清晰。

plt.show()：这是显示绘制的图形。如果你使用的是PyCharm编译器，需要添加这一行代码以确保图形显示。

import numpy as np

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

#plt.show()  如果你使用的是Pycharm编译器，请加上这行代码

输出

2. 构建简单的CNN网络

对于一般的CNN网络来说，都是由特征提取网络和分类网络构成，其中特征提取网络用于提取图片的特征，分类网络用于将图片进行分类。

nn.Conv2d为卷积层，用于提取图片的特征，传入参数为输入channel，输出channel，池化核大小

nn.MaxPool2d为池化层，进行下采样，用更高层的抽象表示图像特征，传入参数为池化核大小

nn.ReLU为激活函数，使模型可以拟合非线性数据

nn.Linear为全连接层，可以起到特征提取器的作用，最后一层的全连接层也可以认为是输出层，传入参数为输入特征数和输出特征数（输入特征数由特征提取网络计算得到，如果不会计算可以直接运行网络，报错中会提示输入特征数的大小，下方网络中第一个全连接层的输入特征数为1600）

nn.Sequential可以按构造顺序连接网络，在初始化阶段就设定好网络结构，不需要在前向传播中重新写一遍

网络结构图：

这段代码定义了一个简单的卷积神经网络（CNN）模型，用于分类图像。

import torch.nn.functional as F：导入PyTorch的函数模块

torch.nn.functional，通常用于定义神经网络的各种操作函数。

num_classes = 10：定义图像的类别数量，这里是10，因为MNIST数据集包含10个数字类别。

class Model(nn.Module):：定义了一个继承自nn.Module的模型类。

super().__init__()：调用父类的初始化方法。

self.conv1 = nn.Conv2d(1, 32, kernel_size=3)：定义第一层卷积层，输入通道数为1（灰度图像），输出通道数为32，卷积核大小为3x3。

self.pool1 = nn.MaxPool2d(2)：定义第一层池化层，使用最大池化，池化核大小为2x2。

self.conv2 = nn.Conv2d(32, 64, kernel_size=3)：定义第二层卷积层，输入通道数为32，输出通道数为64，卷积核大小为3x3。

self.pool2 = nn.MaxPool2d(2)：定义第二层池化层，使用最大池化，池化核大小为2x2。

self.fc1 = nn.Linear(1600, 64)：定义全连接层1，输入大小为1600（由于两次最大池化，图像尺寸减小到原来的1/4，再乘以64个通道），输出大小为64。

self.fc2 = nn.Linear(64, num_classes)：定义全连接层2，输入大小为64，输出大小为类别数num_classes。

def forward(self, x):：定义了前向传播方法，描述了数据在网络中的流动。

x = self.pool1(F.relu(self.conv1(x)))：应用第一层卷积、激活函数ReLU和池化。

x = self.pool2(F.relu(self.conv2(x)))：应用第二层卷积、激活函数ReLU和池化。

x = torch.flatten(x, start_dim=1)：将特征图展平为一维张量，以便输入全连接层。

x = F.relu(self.fc1(x))：应用全连接层1和激活函数ReLU。

x = self.fc2(x)：应用全连接层2，得到最终输出。

最终，该模型通过这个前向传播方法，将输入的图像数据经过卷积、池化、全连接等操作，得到最终的分类输出。这个模型结构适用于处理28x28像素大小的灰度图像，并输出属于10个类别中的一个。

import torch.nn.functional as F

num_classes = 10  # 图片的类别数

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

        x = torch.flatten(x, start_dim=1)

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

这段代码使用了torchinfo库中的summary函数来输出关于神经网络模型的详细信息。

from torchinfo import summary：这一行导入了torchinfo库中的summary函数。torchinfo库提供了有关PyTorch模型的详细信息摘要。

model = Model().to(device)：这一行创建了一个模型实例并将其移动到指定的设备（这里是GPU）。Model()是前面定义的神经网络模型类的实例化。to(device)的目的是将模型参数和计算都放在指定的设备上进行，这有助于加速模型的训练和推断。

summary(model)：这一行调用了torchinfo库中的summary函数，用于输出模型的详细信息摘要。该函数会显示模型的层次结构、输入和输出的形状，以及模型的总参数数量等信息。

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

summary(model)

输出

这段代码输出了一个神经网络模型的详细结构信息，包括各个层次的类型、深度索引、参数数量等。

Layer (type:depth-idx)：这一列显示了网络中每一层的类型以及深度索引。例如，Conv2d: 1-1 表示第一层卷积层的深度索引为1。

Param #：这一列显示了每一层的参数数量。

Model：表示整个模型，深度索引为0。

Conv2d：表示卷积层。

MaxPool2d：表示最大池化层。

Linear：表示全连接层。

Total params：总参数数量，即网络中所有层的参数之和。

Trainable params：可训练参数数量，指的是在训练过程中可以更新的参数数量。

Non-trainable params：不可训练参数数量，指的是在训练过程中不会更新的参数数量，比如某些层的权重初始化。

=================================================================
Layer (type:depth-idx)                   Param #
=================================================================
Model                                    --
├─Conv2d: 1-1                            320
├─MaxPool2d: 1-2                         --
├─Conv2d: 1-3                            18,496
├─MaxPool2d: 1-4                         --
├─Linear: 1-5                            102,464
├─Linear: 1-6                            650
=================================================================
Total params: 121,930
Trainable params: 121,930
Non-trainable params: 0
=================================================================

3. 训练模型

3.1 设置超参数

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

3.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

3.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

3.4 正式训练

这段代码是一个训练循环，用于训练神经网络模型，并在每个训练周期结束后记录并输出模型的性能指标。

epochs = 5：定义了训练循环的总训练周期数，这里设置为5。

train_loss、train_acc、test_loss、test_acc：分别定义了四个空列表，用于存储每个训练周期结束后的训练损失、训练准确率、测试损失和测试准确率。

for epoch in range(epochs):：这是一个循环，遍历每个训练周期。

model.train()：将模型切换到训练模式，启用训练时的特定操作，例如使用Dropout。

epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)：调用train函数执行一次训练，得到当前训练周期的准确率和损失。

model.eval()：将模型切换到评估模式，禁用特定于训练的操作，以便进行测试。

epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)：调用test函数执行一次测试，得到当前训练周期的测试准确率和测试损失。

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')：在所有训练周期结束后输出'Done'，表示训练循环完成。

综合起来，这段代码实现了一个简单的神经网络训练循环，通过多次迭代训练，记录每个训练周期的性能指标，并输出这些指标，以监测模型的训练过程。

epochs     = 5
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')

输出

这段代码输出了神经网络模型在每个训练周期（Epoch）结束时的性能指标，包括训练准确率、训练损失、测试准确率和测试损失。

Epoch: 1：表示第1个训练周期。

Train_acc:88.7%：表示训练准确率为88.7%。

Train_loss:0.360：表示训练损失为0.360。

Test_acc:96.7%：表示测试准确率为96.7%。

Test_loss:0.100：表示测试损失为0.100。

Epoch: 1, Train_acc:88.7%, Train_loss:0.360, Test_acc:96.7%，Test_loss:0.100
Epoch: 2, Train_acc:97.2%, Train_loss:0.089, Test_acc:98.2%，Test_loss:0.058
Epoch: 3, Train_acc:98.0%, Train_loss:0.063, Test_acc:98.4%，Test_loss:0.051
Epoch: 4, Train_acc:98.5%, Train_loss:0.050, Test_acc:98.5%，Test_loss:0.047
Epoch: 5, Train_acc:98.8%, Train_loss:0.041, Test_acc:98.9%，Test_loss:0.033
Done

4. 结果可视化

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()