pytorch学习笔记----完整的训练套路

注意事项：1在训练的过重中喜欢将网络模型单独放在一个model.py文件里面，在训练脚本进行训练的时候只需要导入这个.py文件就可以了。除此之外，在模型脚本里面可以进行一定程度上的运行，防止网络出现问题。

 

 

 2.训练套路：下载数据集----》加载数据集------》定义网络模型-----》定义损失函数-----》定义学习率-------》定义优化器（可以搞个tensorboard）------>在epoch里面进行训练

 3.每进行100次迭代的时候可以打印下损失函数值，并且将损失函数值写进tensorboard里面

  if step%100 ==0:
            print("第 {} 次迭代,loss: {}".format(step,loss.item()))
            writer.add_scalar("train_loss",loss.item(),step)#在tensorboard上进行绘制每100个step和他的loss值
        step = step+1

 4.每训练完一个epoch之后，可以用验证集记性验证，在验证的时候参数不会进行更新，然后在验证完一轮之后给出验证集上的loss值和准确率（使用argmax进行计算）

 

 with torch.no_grad():#在这个模块下，不会计算节点的梯度
        for data in test_loader:
            imgs, targets = data
            output = network(imgs)  # 将图片送入网络中进行训练
            accuracy = (output.argmax(1) == targets).sum()
            loss = loss_fn(output, targets)  # 计算损失函数
            total_test_loss = total_test_loss +loss
            test_accuracy = test_accuracy+accuracy
    print("整体测试集的loss:{}".format(total_test_loss))
    print("整体测试集上预测正确率：{}".format(test_accuracy/len(test_datasets)))
    writer.add_scalar("epoch_test_loss",total_test_loss,epoch)
    writer.add_scalar("test_accuracy",test_accuracy,epoch)

 5.验证完，可以保存下这一轮训练的权重文件

 

#保存每一轮训练的模型
    torch.save(network,"network_{}.pth".format(epoch))#保存每一轮训练的模型

下面观看完整代码

1.train.py

import torchvision
from tensorboardX import SummaryWriter
from torch.nn import CrossEntropyLoss
from torch.utils.data import DataLoader
from torchvision import transforms
import ssl#导入ssl模块
from model import * #将网络部分导入进来

ssl._create_default_https_context = ssl._create_unverified_context  #全局取消证书认证
#从网络中获取数据集
train_datasets = torchvision.datasets.CIFAR10(root="../datasets2",train=True,transform=transforms.ToTensor(),download=True)
test_datasets = torchvision.datasets.CIFAR10(root="../datassts2",train=False,transform=transforms.ToTensor(),download=True)

#加载数据集
train_loader = DataLoader(dataset=train_datasets,batch_size=64)
test_loader = DataLoader(dataset=test_datasets,batch_size=64)

print(len(train_datasets))
print(len(test_datasets))


#定义网络模型，规范的使用model.py文件

network = NetWork()

#定义损失函数
loss_fn = CrossEntropyLoss()
#定义学习率
learning_rate = 0.01
#定义优化器
optim = torch.optim.SGD(params=network.parameters(),lr=learning_rate)

#定义tensorboard
writer = SummaryWriter("logs_train")

#进行训练
for epoch in range(3):
    print("-----第 {} 轮训练开始--------".format(epoch+1))
    step = 1
    for data in test_loader:
        imgs,targets = data
        output = network(imgs)#将图片送入网络中进行训练
        loss = loss_fn(output,targets)#计算损失函数
        optim.zero_grad()#使用优化器进行梯度请0
        loss.backward()#反向传播计算每个节点的梯度
        optim.step()#进行参更新
        if step%100 ==0:
            print("第 {} 次迭代,loss: {}".format(step,loss.item()))
            writer.add_scalar("train_loss",loss.item(),step)#在tensorboard上进行绘制每100个step和他的loss值
        step = step+1

    total_test_loss = 0
    test_accuracy = 0#在测试集计算一下正确率
    #每次训练完之后，会进行一个测试评估一下模型的效果,验证的时候就不需要进行梯度调优了
    with torch.no_grad():#在这个模块下，不会计算节点的梯度
        for data in test_loader:
            imgs, targets = data
            output = network(imgs)  # 将图片送入网络中进行训练
            accuracy = (output.argmax(1) == targets).sum()
            loss = loss_fn(output, targets)  # 计算损失函数
            total_test_loss = total_test_loss +loss
            test_accuracy = test_accuracy+accuracy
    print("整体测试集的loss:{}".format(total_test_loss))
    print("整体测试集上预测正确率：{}".format(test_accuracy/len(test_datasets)))
    writer.add_scalar("epoch_test_loss",total_test_loss,epoch)
    writer.add_scalar("test_accuracy",test_accuracy,epoch)
    #保存每一轮训练的模型
    torch.save(network,"network_{}.pth".format(epoch))#保存每一轮训练的模型

    print("模型已保存")

2.model.py

import torch
from torch import nn
from torch.nn import Sequential, Flatten

#定义网络部分
class NetWork(nn.Module):
    def __init__(self) -> None:  # 定义初始化方法
        super().__init__()
        self.model = Sequential(
            nn.Conv2d(3, 32, 5, padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 32, 5, padding=2),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 5, padding=2),
            nn.MaxPool2d(2),
            Flatten(),
            nn.Linear(1024, 64),
            nn.Linear(64, 10)

        )

    def forward(self,x):#self类 是一个实例对象
        output = self.model(x)
        return output

#网络部分进行测试

if __name__ == '__main__':#使用这个判断语句可以对这个模块进行单独的测试，但是其他模块在调用这个模块的时候这个if判断语句会自动被忽略
    network = NetWork()
    input = torch.ones(64,3,32,32)#我认为第一个是batchsize,第二个是尺寸大小
    output = network(input)
    print(output)
    print(output.shape)#这个是64,10