模型的深度优化

一、测试模型是否正确

本文承接我的上一篇文章完整网络模型训练（一）
运用测试数据集（test_dataloader）进行检验

total_test_loss = 0
    with torch.no_grad():
        for data in test_dataloader:
            imgs, targets = data
            outputs = sen(imgs)
            #这里的loss是一个tensor数据类型
            loss = loss_fn(outputs, targets)
            #加上item进行转换成整形
            total_test_loss = total_test_loss + loss.item()
    print(f"整体测试集上的Loss{total_test_loss}")

注释：
with torch.no_grad()使用 no_grad() 上下文，禁用梯度计算，以节省内存和加快计算速度（因为在测试阶段不需要反向传播）

在pycharm的运行框中按下crtl+f可以弹出搜索框
运行结果：

可以看到确实有整体数据集的信息，但是被很多乱七八遭的信息给掩盖了，所以可以改善一下代码

 if total_train_step % 100 == 0:
            print(f"训练次数：{total_train_step}，Loss：{loss.item()}")

每当步骤为整百的时候才进行打印，这样子输出结果能够整洁一点：

二、图形打印直观观察

也可以用tensorboard进行画图观察，补上一下代码：

writer = SummaryWriter("./logs_train")

 if total_train_step % 100 == 0:
            print(f"训练次数：{total_train_step}，Loss：{loss.item()}")
            writer.add_scalar("train_loss", loss.item(), total_train_step)

print(f"整体测试集上的Loss{total_test_loss}")
    writer.add_scalar("test_loss", total_test_loss,total_test_step)
    total_test_step = total_test_step + 1

运行结果：


可以直观的看到训练的模型的loss损失函数在不断的下降。

三、保存训练模型

还可以保存每一轮训练的模型：

torch.save(sen, f"sen_{i}.pth")
    print("模型已保存")

使用 torch.save() 将模型 ‘sen’ 保存到文件中，文件名为 “sen_{i}.pth”

四、正确率（仅使用于分类问题）

哪怕我们已经得到整体测试数据集上的Loss，也不能很好的说明数据集实际上的表现效果
在分类问题中我们可以用正确率进行表示

    total_accuracy = 0

accuracy = (outputs.argmax(1) == targets).sum()
            total_accuracy = total_accuracy + accuracy

使用 writer.add_scalar() 方法，将标量数据记录到日志文件中，用于在 TensorBoard 中可视化
“test_accuracy” 是图表的名称，用于表示测试集的准确率
total_accuracy/test_data_size 表示计算出的测试集上的准确率（总正确预测数 / 测试集数据总量）
total_test_step 表示当前测试步骤，用作 X 轴上的标记，表明该数据是在第几次测试时记录的

    writer.add_scalar("test_accuracy", total_accuracy/test_data_size, total_test_step)

运行结果：

可以看到计算处理整体数据集上的正确率，为32%

有时我们能看到有些代码会写上以下两段代码：

在训练模型开始的时候

sen.train（）

例如：

	sen.train()
    for data in train_dataloader:
        imgs, targets = data
        outputs = sen(imgs)
        loss = loss_fn(outputs, targets)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

在测试步骤开始的时候

sen.eval()

例如：

 	sen.eval()
    total_test_loss = 0
    total_accuracy = 0
    with torch.no_grad():
        for data in test_dataloader:
            imgs, targets = data
            outputs = sen(imgs)
            #这里的loss是一个tensor数据类型
            loss = loss_fn(outputs, targets)
            #加上item进行转换成整形
            total_test_loss = total_test_loss + loss.item()
            accuracy = (outputs.argmax(1) == targets).sum()
            total_accuracy = total_accuracy + accuracy

这些只对特定模型起作用，例如dropout，不过一般都写上，反正无影响。

训练模型总体过程
准备数据->加载数据->准备模型->设置损失函数->设置优化器->开始训练->最后验证->结果聚合展示

整体代码展示：

import torch
import torchvision.datasets
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

#创建网络模型
class Sen(nn.Module):
    def __init__(self):
        super(Sen, self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3, 32, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, 5, 1 ,2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5, 1, 2),
            nn.MaxPool2d(2),
            nn.Flatten(),
            nn.Linear(64*4*4, 64),
            nn.Linear(64, 10)
        )
    def forward(self,x):
        x = self.model(x)
        return x
#准备数据集
#因为CIFAR10是属于PRL的数据集，所以需要转化成tensor数据集
train_data = torchvision.datasets.CIFAR10(root="./data", train=True, transform=torchvision.transforms.ToTensor(),download=True)
test_data = torchvision.datasets.CIFAR10(root="./data", train=False, transform=torchvision.transforms.ToTensor(),download=True)

#length长度
train_data_size = len(train_data)
test_data_size = len(test_data)
print(f"训练数据集的长度为{train_data_size}")
print(f"测试数据集的长度为{test_data_size}")

#利用DataLoader来加载数据集
train_dataloader = DataLoader(train_data,batch_size=64)
test_dataloader = DataLoader(test_data,batch_size=64)

#创建网络模型
sen = Sen()

#损失函数
loss_fn = nn.CrossEntropyLoss()

#优化器
learning_rate = 1e-2
optimizer = torch.optim.SGD(sen.parameters(), lr=learning_rate)

#记录训练的次数
total_train_step = 0
#记录测试的次数
total_test_step = 0
#训练的轮数
epoch= 10

#添加tensorboard
writer = SummaryWriter("./logs_train")

for i in range(epoch):
    print(f"-------第{i+1}轮训练开始-------")

    #训练步骤开始
    sen.train()
    for data in train_dataloader:
        imgs, targets = data
        outputs = sen(imgs)
        loss = loss_fn(outputs, targets)

        #优化器模型
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        total_train_step = total_train_step + 1
        if total_train_step % 100 == 0:
            print(f"训练次数：{total_train_step}，Loss：{loss.item()}")
            writer.add_scalar("train_loss", loss.item(), total_train_step)

    #测试步骤开始
    sen.eval()
    total_test_loss = 0
    total_accuracy = 0
    #不需要梯度进行调整或者优化
    with torch.no_grad():
        for data in test_dataloader:
            imgs, targets = data
            outputs = sen(imgs)
            #这里的loss是一个tensor数据类型
            loss = loss_fn(outputs, targets)
            #加上item进行转换成整形
            total_test_loss = total_test_loss + loss.item()
            accuracy = (outputs.argmax(1) == targets).sum()
            total_accuracy = total_accuracy + accuracy

    print(f"整体测试集上的Loss{total_test_loss}")
    print(f"整体数据集上的正确率；{total_accuracy/test_data_size}")
    writer.add_scalar("test_loss", total_test_loss,total_test_step)
    writer.add_scalar("test_accuracy", total_accuracy/test_data_size, total_test_step)
    total_test_step = total_test_step + 1


writer.close()