机器学习 —— MNIST手写体识别（下）

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

#创建模型，部署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)

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

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

# 调用
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()# 显示图像