PyTorch笔记(5)-完整模型训练套路

PyTorch中训练完整完整模型通常包含以下步骤：

1、准备数据集：

加载、预处理和组织训练数据和验证数据。PyTorch提供了torch.utils.data模块，可以使用Dataset和DataLoader来处理数据。

2、定义模型：创建模型的类，继承自'nn.Module'，并在'__init__‘方法中定义模型的层次结构，在forward方法中实现前向传播。

3、选择损失函数：根据任务的性质选择合适的损失函数。

4、选择优化器：选择优化器来更新模型参数。

5、训练循环：编写训练循环，包含多个迭代（epoch）。每个迭代包含以下步骤：

        a.前向传播：将输入数据传递给模型，计算模型输出。

        b.计算损失：将模型输出与真实标签进行比较，计算损失。

        c.反向传播：使用反向传播算法计算损失。

        d.优化器步骤：使用优化器根据梯度更新模型参数。

6、验证：在每个迭代之后，可以使用验证集进行模型性能的评估，以监控模型的泛化能力。

7、保存模型：选择在训练过程中保存模型的方式，以便在需要时加载和使用。

（可以使用tensorboard进行可视化，（打开日志文件的方法：在终端输入：tensorboard --logdir=所保存的目录名））

简单示例：

import torch
import torchvision
from torch import nn
#准备数据集
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter, writer

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)
test_data_size=len(test_data)
#利用Dataloader来加载数据集
train_dataloader=DataLoader(train_data,batch_size=64)
test_dataloader=DataLoader(test_data,batch_size=64)
#搭建神经网络
class My_model(nn.Module):
    def __init__(self):
        super().__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(1024,64),
            nn.Linear(64,10)
        )
    def forward(self,x):
        x=self.model(x)
        return x

#创建网络模型
my_model=My_model()
#损失函数
loss_fn=nn.CrossEntropyLoss()
#优化器
optimizer=torch.optim.SGD(my_model.parameters(),lr=0.01)
#设置训练网络的一些参数
#记录训练及测试的次数
total_train_step=0
total_test_step=0
#训练的轮数
epoch=10

#添加tensorboard
write=SummaryWriter('../logs_train')

for i in range(epoch):
    print('第{}轮训练开始：'.format(i+1))

    #训练步骤开始
    my_model.train()#该行的详细用法，可以查看官方文档
    for data in train_dataloader:
        imgs,targets=data
        outputs=my_model(imgs)
        loss=loss_fn(outputs,targets)

        #使用优化器优化模型
        optimizer.zero_grad()#使梯度清零
        loss.backword()
        optimizer.step()#对参数进行优化

        total_train_step+=1
        total_test_step+=1
        print('训练次数为{}时，损失值为{}'.format(total_train_step,loss.item))

        writer.add_scalar('train_loss',loss.item(),total_test_step)

    #测试步骤开始
    my_model.eval()#该行的详细用法，查看官方文档
    total_test_loss=0

    total_accuracy=0#计算正确率

    with torch.no_grad():
        for data in test_dataloader:
            imgs,targets=data
            outputs=my_model(imgs)
            loss=loss_fn(outputs,targets)
            total_test_loss=total_test_loss+loss.item()

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

    print('整体测试集上的损失：{}'.format(total_test_loss))

    print('整体测试集上的正确率：{}'.format(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+=1

    torch.save(my_model,'my_model_{},.pth',format(i))
    #保存的方式二（官方推荐）
    #torch.save(my_model.state_dict(),'my_model_{}.pth'.format(i))
writer.close()