27-28-29 完整的模型训练套路

一、训练流程

1. 准备数据集

2. 计算训练集和测试集的长度

2.1 输出训练集和测试集的长度

3. 利用DataLoader来加载数据集

4. 搭建神经网络

• 在另外的页面搭建好神经网络模型（test27_2_model）
• 在当前页面进行调用（test27_1_train）

5.创建网络模型

6.定义损失函数

7.定义优化器

8.设置训练网络的一些参数

• 记录训练的次数
• 记录测试的次数
• 训练的轮数

8.1 训练步骤开始

• 开启训练模式
• 获得训练集的数据
• 由模型转化输出
• 优化器优化模型
• 记录训练次数
• 输出每一轮中对应训练次数的loss
• 将对应的loss和step写入tensorboard

8.2 测试步骤开始

• 开启测试模型
• 初始化整体的loss和整体的正确率
• 不再进行梯度更新
• 获得测试集的数据
• 由模型转化输出
• 计算loss
• 计算accuracy
• 分别将step对应的loss和accuracy添加到tensorboard

设置train和val模式:当有Dropout和batchsize层的才有效

tudui.train()

tudui.eval()

9. 添加tensorboard显示训练和测试的效果

• 对应训练次数和训练的loss形成的图像
• 对应测试次数和测试的loss形成的图像
• 对应测试次数与测试的准确率形成的图像
• 关闭writer

10. 模型保存

• 每一轮循环保存一次

11.计算正确率

• 分类问题：用准确率输出
  举例：
  

代码：test28_classification

点击查看代码

import torch
#一般网络输出的结果
outputs=torch.tensor([[0.1,0.2],
                      [0.3,0.4]])
print(outputs.argmax(1)) #1是横向比较，0是纵向比较，，输出对应类别的数字

#转化预测的结果为数字
preds=outputs.argmax(1)
targets=torch.tensor([0,1])
print(preds==targets)

#计算准确率
acc=(preds==targets).sum()/2
print(acc)

结果:

• 目标检测及语义分割：用tensorboard直接显示

二、完整代码

• test27_1_train

import torch
import torchvision

from torch.utils.tensorboard import SummaryWriter
# 4.2 引入模型
from test27_2_model import Tudui

# 1. 准备数据集
from torch import nn
from torch.utils.data import DataLoader

train_data=torchvision.datasets.CIFAR10(root="./CIFAR10_dataset",train=True,transform=torchvision.transforms.ToTensor(),download=True) #注意ToTensor的括号不能忘，不让模型无法调用
test_data=torchvision.datasets.CIFAR10(root="./CIFAR10_dataset",train=False,transform=torchvision.transforms.ToTensor(),download=True)

# 2. 计算训练集和测试集的长度
train_data_size=len(train_data)
test_data_size=len(test_data)

# 2.1 输出训练集和测试集的长度
'''
训练数据集的长度为：50000
测试数据集的长度为：10000
'''
print("训练数据集的长度为：{}".format(train_data_size))
print("测试数据集的长度为：{}".format(test_data_size))

# 3. 利用DataLoader来加载数据集

train_dataloader=DataLoader(train_data,batch_size=64)
test_dataloader=DataLoader(test_data,batch_size=64)


# 5.创建网络模型
tudui=Tudui()

# 6.损失函数
loss_fn=nn.CrossEntropyLoss() #交叉熵

# 7.优化器
# 1e-2=1*(10)*(-2)=1/100=0.01
learning_rate=1e-2
optimizer=torch.optim.SGD(tudui.parameters(),lr=learning_rate)

# 8.设置训练网络的一些参数
total_train_step=0 #记录训练的次数
total_test_step=0 #记录测试的次数
epoch=10 #训练的轮数

# 9. 添加tensorboard
writer=SummaryWriter("./logs_27")
for i in range(epoch):
    print("------第{}轮训练开始-------".format(i+1))
    # 8.1 训练步骤开始
    tudui.train()
    for data in train_dataloader:
        imgs, targets = data
        outputs = tudui(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: #当训练次数为 100 200 时训练输出
            print("训练次数：{}，loss:{}".format(total_train_step,loss.item()))#loss tensor类型， loss.item() 数字类型
            # 9.1 训练的效果
            writer.add_scalar("train_loss",loss.item(),total_train_step)
    # 8.2 测试步骤开始
    '''
    判断训练的结果如何
    '''
    tudui.eval()
    total_test_loss=0  #整体的loss
    total_accuracy=0   #整体正确率
    with torch.no_grad(): #不再进行梯度更新，也就是不进行优化，单纯的测试
        for data in test_dataloader:
            imgs,targets=data
            outputs=tudui(imgs)
            loss=loss_fn(outputs,targets) #计算测试集上的误差（一部分数据）
            total_test_loss=total_test_loss + loss.item() #计算整体测试集上的loss
            # 11.计算正确率
            accuracy=(outputs.argmax(1)==targets).sum()
            total_accuracy+=accuracy
        print("整体测试集上的loss:{}".format(total_test_loss))
        # 11.1  输出准确率
        print("整体测试集上的正确率:{}".format(total_accuracy/test_data_size))
        # 9.2 测试的效果
        writer.add_scalar("test_loss",total_test_loss,total_test_step)
        # 11.2 添加显示正确率
        writer.add_scalar("test_accuracy",total_accuracy/test_data_size,total_test_step)

        total_test_step=total_test_step + 1 #测试完一次就+1，不让图像不会变化

        # 10. 模型保存
        '''
        存放每一轮保存的结果
        '''
        torch.save(tudui,"tudui_{}.pth".format(i))
        print("模型已保存")

# 9.3 关闭writer
writer.close()

• test27_2_model

import torch
from torch import nn

# 4. 搭建神经网络
class Tudui(nn.Module):
    def __init__(self):
        super(Tudui, self).__init__()
        self.model1=nn.Sequential(
            nn.Conv2d(3, 32, 5, stride=1,padding=2),  # in_channel 3;out_channel 32;kernel 5;padding需要计算（一般不会太大）
            nn.MaxPool2d(2),  # kennel_Size=2
            nn.Conv2d(32, 32, 5,stride=1,padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5,stride=1, padding=2),
            nn.MaxPool2d(2),
            nn.Flatten(),  # 展平 ：可以把后面的删掉 获得输出的大小
            nn.Linear(64*4*4, 64),  # 看上一层的大小64*4*4=1024 ，可以看到是1024
            nn.Linear(64, 10)  # 输入大小 64 输出大小 10
        )
    def forward(self,x):
            x=self.model1(x)
            return x

# 4.1 测试网络模型
# if __name__ == '__main__':
#     tudui=Tudui()
#     input=torch.ones((64,3,32,32))
#     output=tudui(input)
#     print(output.shape) #torch.Size([64, 10])

三、运行结果

1.运行tensorboard

tensorboard --logdir=logs_27 --host=127.0.0.1

• 训练集和测试集的loss都在下降

test_accuracy:

test_loss:

train_loss: