11.27学习日志

（十四）完整的模型训练套路（以CIFAR10数据集为例）

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

from model import *

#准备数据集
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("训练数据集的长度为{}".format(train_data_size))
print("测试数据集的长度为{}".format(test_data_size))

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

#搭建神经网络，存入另一个python文件中
tudui = Tudui()

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

#优化器
learning_rate = 0.001
#learning_rate = 1e-3
optimizer = torch.optim.SGD(tudui.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("-------第{}轮训练开始-------".format(i+1))

    #训练步骤开始
    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:#不是每一次训练都打印每一百次打印一下
            print("训练次数：{}，Loss：{}".format(total_train_step,loss.item()))
            writer.add_scalar("train_loss",loss.item(),total_train_step)

    #每一轮训练完测试测试集代码
    total_test_loss = 0
    with torch.no_grad():     #代表with里的不会对梯度有影响
        for data in test_dataloader:
            imgs,targets = data
            outputs = tudui(imgs)
            loss = loss_fn(outputs,targets)
            total_test_loss = total_test_loss +loss.item()
    print("整体测试集上的loss：{}".format(total_test_loss))
    writer.add_scalar("test_loss",total_test_loss,total_test_step)
    total_test_step += 1 #要加上1，否则最后step会一直处于0
    
    torch.save(tudui,"tudui_{}.pth.format(i)")

writer.close()

'''-------第1轮训练开始-------
训练次数：100，Loss：2.303330183029175
训练次数：200，Loss：2.3075129985809326
训练次数：300，Loss：2.297590732574463
训练次数：400，Loss：2.304055690765381
训练次数：500，Loss：2.2999885082244873
训练次数：600，Loss：2.294182062149048
训练次数：700，Loss：2.293867826461792
整体测试集上的loss：361.075660943985'''

model文件：

import torch
from torch import nn

class Tudui(nn.Module):
    def __init__(self):
        super(Tudui,self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3,32,5,1,padding=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

if __name__ == '__main__':
    tudui = Tudui()
    input = torch.ones((64,3,32,32))
    output = tudui(input)
    print(output.shape)
#torch.Size([64, 10]) 代表返回64行数据，每行数据有10个数据，代表图片对应每个类别的概率

 测试分类预测类别正确率

import torch
outputs = torch.tensor([[0.1,0.2],
                       [0.3,0.4]])
print(outputs.argmax(1))
#argmax(1)是进行横向的比较返回较大的tensor([1, 1])
#argmax（0）是进行纵向的比较
preds = outputs.argmax(1)
targets = torch.tensor([0,1])
print(preds==targets)
#将预测值与实际值比较返回是否一致，tensor([False,  True])

将这个用于完整模型训练：

    total_accuracy = 0
    with torch.no_grad():     #代表with里的不会对梯度有影响
        for data in test_dataloader:
            imgs,targets = data
            outputs = tudui(imgs)
            loss = loss_fn(outputs,targets)
            total_test_loss = total_test_loss +loss.item()
            accuracy = (outputs.argmax(1)==targets).sum()
            total_accuracy = total_accuracy + 1
            
    print("整体测试集上的loss：{}".format(total_test_loss))
    print("整体测试集上的正确率：{}".format(total_accuracy/test_data_size))