本文使用工具
       Anaconda下载安装与使用
       Jupyter Notebook的使用
       pytorch配置
             Jupyter notebook
             Pycharm

本文使用数据集
      机器学习实验所需内容.zip

---

        点击跳转至正文部分

---

pytorch配置

Jupyter notebook

1、打开 Anaconda Prompt（anaconda 3）

2、在终端输入：conda create -n torch python=3.9

3、查看环境确认创建成功

4、激活虚拟环境：activate torch

5、创建内核：conda install -n torch ipykernel

6、创建新内核：python -m ipykernel install --user --name torch --display-name "torch"


7、安装 pytorch：https://pytorch.org/
进入 pytorch 官网，选择合适的版本安装，并复制安装指令

8、检查安装是否成功

方法2

Pycharm

1、选择环境

2、选择 torch 环境解释器



3、测试

独显安装参考（就是先装好CUDA和cudnn，然后剩下的和集显一样，
先创建好虚拟环境和相应的 kernel，然后安装）：Pytorch环境配置（anaconda安装+独显+CUDA+cuDNN)

---

数据集介绍

    给定数据集MNIST，Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz

    MNIST是一个计算机视觉数据集，它包含各种手写数字图片0，1，2，…，9

    MNIST数据集包含：60000行的训练数据集（mnist.train）和10000行的测试数据集（mnist.test）。训练数据集和测试数据集都包含有一张手写的数字，和对应的标签，训练数据集的图片是 mnist.train.images ，训练数据集的标签是 mnist.train.labels；测试数据集的图片是 mnist.test.images ，训练数据集的标签是 mnist.test.labels每一张图片都是28*28像素（784个像素点），可以用点矩阵来表示每张图片

MNIST手写体识别

（一） 加包

import torch # 导入PyTorch库，用于构建和训练神经网络模型。
import torch.nn as nn # 导入PyTorch的神经网络模块，用于定义神经网络的层和模型。
import torch.nn.functional as F # 导入PyTorch的函数式接口模块，包含一些常用的非线性激活函数和损失函数。
import torch.optim as optim # 导入PyTorch的优化器模块，用于定义和实现不同的优化算法。
from torchvision import datasets, transforms # 从torchvision库中导入数据集和数据处理的功能。
import time # 导入Python的time模块，用于计时和时间相关的操作。
from matplotlib import pyplot as plt # 从matplotlib库中导入绘图功能，用于可视化数据和结果。

图1：加包

（二） 数据预处理

        这段代码主要涉及数据预处理和数据加载的过程。

        pipline_train和pipline_test是数据预处理的管道，通过transforms.Compose方法将多个预处理操作组合在一起。将transforms.RandomRotation添加到训练数据预处理中来进行随机旋转图片。使用transforms.Resize调整图片的尺寸，确保在将图片转化为Tensor格式之前调整好。将transforms.Normalize的参数从元组形式改为单个值形式，以便适应PyTorch 1.2.0版本及以上的要求。

        train_set和test_set是使用MNIST数据集构建的训练集和测试集对象，参数说明如下：root=“./data”：数据集存储的根目录。train=True（对应train_set）或train=False（对应test_set）：指定加载训练集还是测试集。download=True：如果数据集不存在，则自动从互联网上下载。transform=pipline_train（对应train_set）或transform=pipline_test（对应test_set）：应用之前定义的数据预处理管道。

        trainloader和testloader是数据加载器，用于将数据集分批次加载到模型进行训练和测试。torch.utils.data.DataLoader用于构建数据加载器。batch_size控制每个批次的样本数量。将trainloader和testloader中的shuffle参数设置为布尔值，指示是否对数据进行洗牌操作。

pipline_train = transforms.Compose([
    #随机旋转图片
    transforms.RandomRotation(10),
    #将图片尺寸resize到32x32
    transforms.Resize((32, 32)),
    #将图片转化为Tensor格式
    transforms.ToTensor(),
    #正则化(当模型出现过拟合的情况时，用来降低模型的复杂度)
    transforms.Normalize((0.1307,),(0.3081,))    
])
pipline_test = transforms.Compose([
    #将图片尺寸resize到32x32
    transforms.Resize((32, 32)),
    #将图片转化为Tensor格式
    transforms.ToTensor(),
    # 正则化
    transforms.Normalize((0.1307,),(0.3081,))
])
#下载数据集 使用MNIST数据集构建的训练集和测试集对象
train_set = datasets.MNIST(root="./data", train=True, download=True, transform=pipline_train)
test_set = datasets.MNIST(root="./data", train=False, download=True, transform=pipline_test)
#加载数据集 torch.utils.data.DataLoader用于构建数据加载器
trainloader = torch.utils.data.DataLoader(train_set, batch_size=64, shuffle=True)
testloader = torch.utils.data.DataLoader(test_set, batch_size=32, shuffle=False)

图2：数据预处理

图3：下载数据集

（三） 搭建网络

        这段代码定义了一个名为Net的神经网络模型类，模型包含了卷积层、激活函数、最大池化层、全连接层和Dropout层。

        __init__(self)函数是模型类的初始化函数，通过卷积、激活、池化定义模型的层和参数。

        forward(self, x)函数是模型类的前向传播函数，定义数据在模型中的流动方式。

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 16, kernel_size=3, stride=1, padding=1)  # 输入通道数为1，输出通道数为16，卷积核大小为3，步长为1，填充为1
        self.relu = nn.ReLU()  # ReLU激活函数
        self.maxpool = nn.MaxPool2d(kernel_size=2, stride=2)  # 最大池化层，池化核大小为2，步长为2
        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1)  # 输入通道数为16，输出通道数为32，卷积核大小为3，步长为1，填充为1
        self.conv3 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)  # 输入通道数为32，输出通道数为64，卷积核大小为3，步长为1，填充为1
        self.fc = nn.Linear(64 * 4 * 4, 10)  # 全连接层，输入大小为64*4*4，输出大小为10
        self.dropout = nn.Dropout(0.5)  # Dropout层，丢弃概率为0.5
    def forward(self, x):
        x = self.conv1(x)  # 卷积层1
        x = self.relu(x)  # ReLU激活函数
        x = self.maxpool(x)  # 最大池化层
        x = self.conv2(x)  # 卷积层2
        x = self.relu(x)  # ReLU激活函数
        x = self.maxpool(x)  # 最大池化层
        x = self.conv3(x)  # 卷积层3
        x = self.relu(x)  # ReLU激活函数
        x = self.maxpool(x)  # 最大池化层
        x = x.view(-1, 64 * 4 * 4)  # 展开成一维向量
        x = self.dropout(x)  # Dropout层
        x = self.fc(x)  # 全连接层
        output = F.log_softmax(x, dim=1)  # 使用log_softmax函数进行分类
        return output

图4：搭建网络

（四） 计算、优化

        使用Adam优化器，对模型的参数进行优化，学习率为0.001。这是一种常用的优化器，适用于大多数深度学习任务。

        使用SGD优化器，对模型的参数进行优化，学习率为0.001，动量为0.9，权重衰减为0.00004。SGD是随机梯度下降的一种变体，动量和权重衰减可以帮助加速模型训练和提高泛化能力。这里给出了两个优化器的选择，可以根据实际情况选择其中之一进行使用。

        我选择是的SGD优化器。

#创建模型，部署GPU或CPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = Net().to(device)
#定义优化器，这里给了两个优化器，大家可以结合上课讲的感受一下优劣（运行的时候选择其一即可）
# 使用Adam优化器
# optimizer = optim.Adam(model.parameters(), lr=0.001)
# 使用SGD优化器，设置学习率为0.001，动量为0.9，权重衰减为0.00004
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9, weight_decay=0.00004)

图5：创建模型，选择优化器

（五） 训练

        定义train_runner函数用于使用指定的优化器在给定数据集上训练模型。

        先通过model.train(): 将模型设置为训练模式，启用批标准化（BatchNormalization）和随机失活（Dropout）功能。接着初始化计数器以及遍历 trainloader数据集。最后以元组的形式返回最终的损失、准确率和 top-5 准确率。

def train_runner(model, device, trainloader, optimizer, epoch):
    #训练模型, 启用 BatchNormalization 和 Dropout, 将BatchNormalization和Dropout置为True
    model.train()
    total = 0 # 初始化总样本数为0
    corrects = 0.0 # 初始化正确预测的样本数为0.0
    correct_5 = 0.0 # 初始化 top-5 准确率的样本数为0.0
    #enumerate迭代已加载的数据集,同时获取数据和数据下标
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data # 将迭代得到的数据和标签分别赋值给 inputs 和 labels
        #把模型部署到device上
        inputs, labels = inputs.to(device), labels.to(device)
        optimizer.zero_grad()#初始化梯度为0
        outputs = model(inputs)#把数据喂给模型
        #计算acc和top-5 error
        _, preds = torch.max(outputs.data, 1)#top-1 根据模型的输出，获取预测结果中的最大值及其对应的索引，即 top-1 预测结果。
        maxk = max((1,5))#top-5 设置最大的 top-k 值为1和5中较大的一个
        _, pred_5 = outputs.topk(maxk, 1, True, True)#top-5 根据模型的输出，获取前k个最大值及其对应的索引，即 top-5 预测结果。
        total += labels.size(0)# 累加总样本数，通过标签的大小得到当前批次的样本数
        corrects += float(torch.sum(preds == labels.data))# 累加正确预测的样本数，通过判断预测结果和标签是否相等来计算正确预测的数量。
        for k in range(maxk):#遍历 top-k 值
            #累加 top-k 准确率的样本数，通过判断 top-k 预测结果和标签是否相等来计算准确预测的数量
            correct_5 += float(torch.sum(pred_5[:, k] == labels.data))
        #计算损失和
        #多分类情况通常使用cross_entropy(交叉熵损失函数), 而对于二分类问题, 通常使用sigmod
        loss = F.cross_entropy(outputs, labels)
        loss.backward()#反向传播
        optimizer.step()#更新参数
        if i % 1000 == 0:
            #loss.item()表示当前loss的数值
            print("Train Epoch{} \t Loss: {:.6f}, accuracy: {:.6f}%, top-5: {:.6f}%".format(epoch, loss.item(), 100*(corrects/total), 100*(correct_5/total)))
            Loss.append(loss.item())
            Accuracy.append(corrects/total)
    return loss.item(), corrects/total, correct_5/total

图6：train_runner函数

（六） 测试

        test_runner函数用于在给定数据集上验证模型的性能。

        先通过model.eval()将模型设置为评估模式，禁用批标准化（BatchNormalization）和随机失活（Dropout）功能。接着初始化统计变量，使用 torch.no_grad() 包装，确保在评估模式下不会计算梯度或进行反向传播。遍历 testloader 中的测试数据和标签以及计算准确率和 top-5 准确率。最后打印验证结果，包括平均损失、准确率和 top-5 准确率。

def test_runner(model, device, testloader):
    #模型验证, 必须要写, 否则只要有输入数据, 即使不训练, 它也会改变权值
    #因为调用eval()将不启用 BatchNormalization 和 Dropout, BatchNormalization和Dropout置为False
    model.eval()
    #统计模型正确率, 设置初始值
    corrects = 0.0 # 记录正确预测的样本数
    correct_5 = 0.0 # 记录在前5个预测中正确的样本数
    test_loss = 0.0 # 记录测试损失的累加值
    total = 0 # 记录总样本数
    #torch.no_grad将不会计算梯度, 也不会进行反向传播
    with torch.no_grad():
        for data, labels in testloader:
            data, labels = data.to(device), labels.to(device)
            #把测试数据喂给模型
            outputs = model(data)
            #计算测试损失
            loss = F.cross_entropy(outputs, labels)
            test_loss += loss.item() * data.size(0)
            #计算acc和top-5
            _, preds = torch.max(outputs.data, 1)  # top-1 根据模型的输出，获取预测结果中的最大值及其对应的索引
            maxk = max((1, 5))  # top-5 设置最大的 top-k 值为1和5中较大的一个
            _, pred_5 = outputs.topk(maxk, 1, True, True)  # top-5 根据模型的输出，获取前k个最大值及其对应的概率
            total += labels.size(0)# 将当前批次中的样本数添加到总计数中
            corrects += float(torch.sum(preds == labels.data))#通过将预测类别与真实标签进行比较，计算正确预测的数量
            correct_5 += float(torch.sum(pred_5[:, 0] == labels.data))#通过将 top-5 预测与真实标签进行比较，计算正确 top-5 预测的数量。
        #打印结果：平均损失、准确率和 top-5 准确率。
        print("test_avarage_loss: {:.6f}, accuracy: {:.6f}%, top-5: {:.6f}%".format(test_loss/total, 100*(corrects/total), 100*(correct_5/total)))

图7：test_runner函数

（七） 主函数调用

        初始化训练过程的相关变量：epoch表示训练的总轮数，Loss、Accuracy和 Accuracy_5用于记录训练过程中的损失、准确率和top-5准确率。

        进行训练循环，从第1轮到第epoch（5）轮：调用train_runner函数进行模型训练，并获取训练过程中的损失、准确率和top-5准确率，并且将损失、准确率和 top-5 准确率记录到对应的列表中。

        最后使用matplotlib进行可视化，绘制损失曲线、准确率曲线、top-5 准确率曲线，显示图片并将图片保存为 “zhan.png”。

# 调用
epoch = 5# 训练的总轮数
Loss = []# 记录训练过程中的损失
Accuracy = []# 记录训练过程中的准确率
Accuracy_5 = []# 记录训练过程中的top-5 准确率
for epoch in range(1, epoch+1):## 开始训练循环，每个 epoch 迭代一次
    # 打印当前时间作为训练开始时间
print("start_time",time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())))
    # 调用 train_runner 函数进行模型训练
    loss, acc, acc_5 = train_runner(model, device, trainloader, optimizer, epoch)
    # 将训练过程中的损失、准确率和 top-5 准确率记录下来
    Loss.append(loss)
    Accuracy.append(acc)
    Accuracy_5.append(acc_5)
    # 调用 test_runner 函数进行模型验证
    test_runner(model, device, testloader)
    # 打印当前时间作为训练一次结束的时间
    print("end_time: ",time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())),'\n')
# 打印 "Finished Training" 表示训练结束
print('Finished Training')
# matplotlib画图# 绘制训练过程中的损失、准确率和 top-5 准确率曲线
plt.figure(figsize=(10, 8))
plt.subplot(3, 1, 1)
plt.plot(Loss, label='Loss')
plt.title('Loss')# 损失曲线
plt.legend()# 绘制图例
plt.subplot(3, 1, 2)
plt.plot(Accuracy, label='Accuracy')
plt.title('Accuracy')# 准确率曲线
plt.legend()# 绘制图例
plt.subplot(3, 1, 3)
plt.plot(Accuracy_5, label='Accuracy_5')
plt.title('Accuracy_5')# top-5 准确率曲线
plt.legend()# 绘制图例
plt.savefig("zhan.png") # 保存图像
plt.tight_layout()# 自动调整子图参数,使之填充整个图像区域
plt.show()# 显示图像

图8：主函数

图9：打印模型训练验证结果

图10：训练过程中的损失、准确率和 top-5 准确率曲线（zhan.png）

异常问题与解决方案

异常问题1： No module named 'pyparsing’
解决方案：%pip install pyparsing但是失败了，最后重新启动内核便可以使用更新的包了。

图11：解决方法

        
异常问题2：TypeError:super(type, obj) : obj must be an instance or subtype of type。其实是找不到名字为LeNet()的类。

图12：异常问题
解决方案：通过查看之前的代码，发现定义的是名为Net的神经网络模型类，所以将LeNet()修改为Net()便可以运行了。

图13：解决方法
        

异常问题3：模型训练验证结果和绘制的损失、准确率和 top-5 准确率曲线不一致。

图14：异常问题
解决方案：每一次都要重新启动并重新运行，重新启动后数据和曲线一致。

图15：解决方法

---

回到文章开头