说明：

① 下载并安装PyCharm；

② 创建Python文件，部署PyTorch；

③ 下载测试数据集、训练数据集和验证数据集；

④ 编写代码，实现手写体识别；

⑤ 运行代码，生成结果。

五、实验步骤

5.1 安装PyCharm

1.下载PyCharm

进入云主机，打开左侧Firefox浏览器，搜索https://www.jetbrains.com.cn/en-us/pycharm/download/download-thanks.html?platform=linux 点击下载PyCharm。

下载好后是一个压缩文件，选择将文件压缩到此处。

解压后目录内容显示如下。

2.安装PyCharm

双击进入bin目录，双击PyCharm图标打开PyCharm。

在PyCharm的左下角单击图标打开终端。

进入到终端后输入命令进入到bin目录下。

cd 下载
cd pycharm-2024.2.1
cd bin

输入命令执行脚本。

sh ./pycharm.sh

执行完命令后会自动弹出窗口，选择“开始30天免费试用”。

5.2 下载PyTorch框架

1.新建目录

打开PyCharm，单击左上角图标在弹出的菜单中选择“新建>目录”。

目录名称输入：demo。

2.新建文件

在PyCharm左侧新建的demo目录单击鼠标右键，在打开的菜单中选择“新建>Python文件”。

输入Python文件的名字，自定义即可。

3.部署Python框架

新建好后，在左侧找到新建好的Python文件双击打开。

单击左下角图标打开终端。

在终端输入命令，部署Python框架。

pip3 install torch torchvision torchaudio --index-url htt ps://download.pytorch.org/whl/cpu

5.3 数据集介绍

1.创建目录

在同一项目目录下创建文件夹data，在data目录下创建mnist目录。

2.数据集详细介绍

1)测试集图片，包含10000张图。
t10k-images.idx3-ubyte
2)标签集，包含10000张测试集图片所对应的标签。
t10k-labels.idx1-ubyte
3)训练集和验证集，包含55000张训练集和5000张验证集图片。
train-images.idx3-ubyte
4)标签集，包含训练集图片所对应的标签。
train-labels.idx1-ubyte

5.4 编写代码

1.创建和编写文件

在demo目录下新建一个py文件进行代码编辑。

import torch
import numpy as np
from matplotlib import pyplot as plt
from torch.utils.data import DataLoader
from torchvision import transforms
from torchvision import datasets
import torch.nn.functional as F

"""
卷积运算 使用mnist数据集，和10-4，11类似的，只是这里：1.输出训练轮的acc 2.模型上使用torch.nn.Sequential
"""

batch_size = 64
learning_rate = 0.01
momentum = 0.5
EPOCH = 10


transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
# softmax归一化指数函数,其中0.1307是mean均值和0.3081是std标准差

train_dataset = datasets.MNIST(root='./data/mnist', train=True, transform=transform,download=True)  # 本地没有就加上download=True
test_dataset = datasets.MNIST(root='./data/mnist', train=False, transform=transform,download=True)  # train=True训练集，=False测试集
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

fig = plt.figure()
for i in range(12):
    plt.subplot(3, 4, i+1)
    plt.tight_layout()
    plt.imshow(train_dataset.train_data[i], cmap='gray', interpolation='none')
    plt.title("Labels: {}".format(train_dataset.train_labels[i]))
    plt.xticks([])
    plt.yticks([])
plt.show()

# 训练集乱序，测试集有序

class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = torch.nn.Sequential(
            torch.nn.Conv2d(1, 10, kernel_size=5),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(kernel_size=2),
        )
        self.conv2 = torch.nn.Sequential(
            torch.nn.Conv2d(10, 20, kernel_size=5),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(kernel_size=2),
        )
        self.fc = torch.nn.Sequential(
            torch.nn.Linear(320, 50),
            torch.nn.Linear(50, 10),
        )

    def forward(self, x):
        batch_size = x.size(0)
        x = self.conv1(x)  # 一层卷积层,一层池化层,一层激活层(图是先卷积后激活再池化，差别不大)
        x = self.conv2(x)  # 再来一次
        x = x.view(batch_size, -1)  # flatten 变成全连接网络需要的输入 (batch, 20,4,4) ==> (batch,320), -1 此处自动算出的是320
        x = self.fc(x)
        return x  # 最后输出的是维度为10的，也就是（对应数学符号的0~9）

model = Net()
# Construct loss and optimizer ------------------------------------------------------------------------------
criterion = torch.nn.CrossEntropyLoss()  # 交叉熵损失
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, momentum=momentum)  # lr学习率，momentum冲量


# Train and Test CLASS --------------------------------------------------------------------------------------
# 把单独的一轮一环封装在函数类里

def train(epoch):
    running_loss = 0.0  # 这整个epoch的loss清零
    running_total = 0
    running_correct = 0
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, target = data
        optimizer.zero_grad()

        # forward + backward + update
        outputs = model(inputs)
        loss = criterion(outputs, target)

        loss.backward()
        optimizer.step()

        # 把运行中的loss累加起来，为了下面300次一除
        running_loss += loss.item()
        # 把运行中的准确率acc算出来
        _, predicted = torch.max(outputs.data, dim=1)
        running_total += inputs.shape[0]
        running_correct += (predicted == target).sum().item()

        if batch_idx % 300 == 299:  # 不想要每一次都出loss，浪费时间，选择每300次出一个平均损失,和准确率
            print('[%d, %5d]: loss: %.3f , acc: %.2f %%'
                  % (epoch + 1, batch_idx + 1, running_loss / 300, 100 * running_correct / running_total))
            running_loss = 0.0  # 这小批300的loss清零
            running_total = 0
            running_correct = 0  # 这小批300的acc清零

        # torch.save(model.state_dict(), './model_Mnist.pth')
        # torch.save(optimizer.state_dict(), './optimizer_Mnist.pth')

def test():
    correct = 0
    total = 0
    with torch.no_grad():  # 测试集不用算梯度
        for data in test_loader:
            images, labels = data
            outputs = model(images)
            _, predicted = torch.max(outputs.data, dim=1)  # dim = 1 列是第0个维度，行是第1个维度，沿着行(第1个维度)去找1.最大值和2.最大值的下标
            total += labels.size(0)  # 张量之间的比较运算
            correct += (predicted == labels).sum().item()
    acc = correct / total
    print('[%d / %d]: Accuracy on test set: %.1f %% ' % (epoch+1, EPOCH, 100 * acc))  # 求测试的准确率，正确数/总数
    return acc
# Start train and Test --------------------------------------------------------------------------------------
if __name__ == '__main__':
    acc_list_test = []
    for epoch in range(EPOCH):
        train(epoch)
        # if epoch % 10 == 9:  #每训练10轮 测试1次
        acc_test = test()
        acc_list_test.append(acc_test)

    plt.plot(acc_list_test)
    plt.xlabel('Epoch')
    plt.ylabel('Accuracy On TestSet')
    plt.show()

当代码编写完毕后在导包的部分会出现爆红(在包名下面会出现红色波浪线)的情况，直接将鼠标放到爆红(代码下方会出现)部分，会自动弹出下载，然后点击“下载”即可。如果没有弹出下载，请打开终端，在终端输入命令：pip3 install matplotlib 指令下载。

2.代码部分讲解

1)导入数据包

首先对于导包部分导入，Pytorch、NumPy、Matplotlib等库，用于进行深度学习模型

的构建数据可视化。

2)设置超参数

这里定义了几个训练过程中的重要参数:

batch_size:每次训练的样本数量；

Learning_rate:学习率，用于控制模型权重更新的幅度；

momentum:动量，用于加速训练过程中的权重更新；

EPOCH:训练的总轮数。

3)数据预处理

这一串代码定义了数据预处理的流程，包括将图片转换为张量，并进行标准理。

加载MNIST数据集，并将其分为训练集和测试集，同时用DataLoader来批量加载数据集。

使用Matplotlib显示部分训练数据，以便直观地了解数据集。

4)创建模型和函数

定义一个卷积神经网络模型NET,包括两个卷积层和两个全连接层。

创建模型实例，交叉熵损失函数和梯度下降的优化器。

定义训练和测试的函数，分别用于训练模型和在测试集上评估模型性能训练函数。

编写测试函数。

最后是主函数，这里：

1.对模型进行指定轮数的训练；

2.在每个训练轮数后，测试模型性能，并将其准确记录下来；

3.最后绘制测试集准确率随着训练轮数的变化图。

5.5 运行结果生成

代码编写完毕后右击鼠标，点击运行。

运行后会出现手写体识别的结果，可以看到在数据集图片上放有Labels字样，后面紧跟着就是手写体识别后识别出来的数字。

运行结果中有loss损失函数，以及acc准确率，可以看到loss损失函数在慢慢的降低，而acc准确率在慢慢的升高。acc准确率提高的原因是因为训练轮数的不断增加，交叉熵损失衡量了模型预测与真实标签之间的差异。在训练过程中，优化器的目标是使损失函数最小化。随着训练轮数的增加，损失函数的值逐渐降低，这意味着模型的预测越来越接近真实标签，从而提高准确率。

acc准确率折线图，横轴表示训练轮次，纵轴表示准确率，acc准确率的提高因为训练轮数的不断增加，模型通过不断地优化参数，逐步学习到数据中的特征和模式，减少预测误差，从而提高在测试集上的准确率。

            至此，实验完毕。

            想了解更多手写体识别的内容可以访问：https://yann.lecun.com/exdb/mnist/

            想了解更多关于PyTorch框架的可以访问：https://pytorch.org/