目录
# 利用datasets准备数据集（训练数据集和测试数据集）
#P26 神经网络-完整的模型训练套路
'''
模型的保存和加载
完整的模型训练套路（以CIFAR10数据集为例，完成对这个数据集的分类问题，这个数据集共有10个类别，因此对于网络来说，是一个10分类问题）
GPU训练
完整的模型验证(测试，demo)套路-利用已经训练好的模型，然后给它提供输入
再来看一下GitHub，优秀代码和优秀项目是怎么写的
'''
#train.py
import torchvision
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear
from torch.utils.tensorboard import SummaryWriter
from model_West import *#model_West.py文件要与现在文件在同一个文件夹中
from torch import nn
from torch.utils.data import DataLoader
# 准备数据集（训练数据集和测试数据集）
# 训练数据集
train_data = torchvision.datasets.CIFAR10(root="./data_nn", train=True, transform=torchvision.transforms.ToTensor(),
download=True)
# 测试数据集
test_data = torchvision.datasets.CIFAR10(root="./data_nn", train=False, transform=torchvision.transforms.ToTensor(),
download=True)
# length 长度 获得数据集长度
train_data_size = len(train_data)#获得数据集长度，可以看数据集中有多少张图
test_data_size = len(test_data)#获得数据集长度，可以看数据集中有多少张图
# 如果train_data_size=10, 训练数据集的长度为：10
print("训练数据集的长度为：{}".format(train_data_size))
print(f"训练数据集的长度为：{train_data_size}")
print("测试数据集的长度为：{}".format(test_data_size))
print(f"测试数据集的长度为：{test_data_size}")
# 利用 DataLoader 来加载数据集
train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)
# 创建网络模型
# class West(nn.Module):
# def __init__(self):#子类初始化
# super(West, self).__init__()#父类初始化
# self.model1 = Sequential(
# Conv2d(3, 32, 5, padding=2),#dination默认为1表示没有空洞。#padding=2通过官网公式计算
# MaxPool2d(2),
# Conv2d(32, 32, 5, padding=2),
# MaxPool2d(2),
# Conv2d(32, 64, 5, padding=2),
# MaxPool2d(2),
# Flatten(),
# Linear(in_features=64*4*4, out_features=64),
# Linear(64, 10)
# )
#
# def forward(self, x):
# return self.model1(x)
west = West()
# 损失函数
loss_fn = nn.CrossEntropyLoss()
# 优化器
# learning_rate = 0.01#便于修改
# 1e-2=1 x (10)^(-2) = 1 /100 = 0.01
learning_rate = 1e-2#便于修改
optimizer = torch.optim.SGD(west.parameters(), lr=learning_rate)#SGD是随机梯度下降
# 设置训练网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练的轮数
epoch = 10
# 添加tensorboard
writer = SummaryWriter("./logs_train")
for i in range(epoch):
print(f"-------第 {i+1} 轮训练开始-------")
# 训练步骤开始
west.train()#将网络设置为训练模式。这句代码可以没有。#只对特定层有影响，如Dropout, BatchNorm等
for data in train_dataloader:
imgs, targets = data
outputs = west(imgs)
loss = loss_fn(outputs, targets)
# 优化器优化模型
optimizer.zero_grad()#梯度清零
loss.backward()#反向传播，得到梯度值
optimizer.step()#进行优化
total_train_step = total_train_step + 1#训练（优化）次数+1
if total_train_step % 100 == 0:#逢100运行一次 #%是取余数的意思
print(f"训练次数：{total_train_step}, Loss: {loss.item()}")#变量.item可以将数据类型转换为真实的数字
writer.add_scalar("train_loss", loss.item(), total_train_step)#记录到tensorboard日志中
'''
#临时测试 变量.item的区别
import torch
a = torch.tensor(5)
print(a)
print(a.item())
'''
# 在每次训练完一轮后，在测试数据集上跑一遍，以测试数据集上的损失loss（或者说正确率），来评估模型是否训练好了
# 在测试过程中就不用进行调优了，利用现有模型进行测试即可
# 测试步骤开始
west.eval()#将网络设置成评估（验证）模式。这句代码可以没有。#只对特定层有影响，如Dropout, BatchNorm等
total_test_loss = 0
total_accuracy = 0
with torch.no_grad():#让with下的代码没有梯度了，确保不会进行调优
for data in test_dataloader:
imgs, targets = data
outputs = west(imgs)
loss = loss_fn(outputs, targets)
total_test_loss = total_test_loss + loss.item()
accuracy = (outputs.argmax(1) == targets).sum()#1表示横向看，0表示竖向看，输出 值更大的 索引，预测成功次数求和。
total_accuracy = total_accuracy + accuracy#每一份imgs的成功次数累加起来，成为一轮的总成功次数。
print(f"整体测试集上的Loss: {total_test_loss}")
print(f"整体测试集上的正确率: {total_accuracy/test_data_size}")#正确率是分类问题中特有的衡量指标。正确率 = 一轮的预测成功次数总和/测试集长度。
writer.add_scalar("test_loss", total_test_loss, total_test_step)#记录到tensorboard日志中
writer.add_scalar("test_accuracy", total_accuracy/test_data_size, total_test_step)
total_test_step = total_test_step + 1#测试次数+1
#保存每一轮训练的模型
torch.save(west, f"west_{i+1}_method1.pth")#west_{i+1}.pth 后缀可以自己取，但是一般习惯用pth。i是前面设置的轮数。
print(f"第{i+1}轮模型已保存")
#第2种保存方式。官方推荐的方式。
# torch.save(west.state_dict(), f"west_{i+1}_method2.pth")
writer.close()
'''
#临时测试 #正确率是分类问题中特有的衡量指标
import torch
outputs = torch.tensor([[0.1, 0.2],
[0.3, 0.4]])#假设一个输出，也就是假设一个测试结果
print(outputs.argmax(1))#1表示横向看，0表示竖向看，输出 值更大的 索引 #tensor([1, 1])
preds = outputs.argmax(1)#预测结果
targets = torch.tensor([0, 1])#目标值
print(preds == targets)#tensor([False, True])#看预测值是否等于目标值
print((preds == targets).sum())#tensor(1) #将False=0，True=1，求和，求得预测成功的次数
'''
#model_West.py
import torch
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear
from nn_module import output
class West(nn.Module):
def __init__(self):#子类初始化
super(West, self).__init__()#父类初始化
self.model1 = Sequential(
Conv2d(3, 32, 5, padding=2),#dination默认为1表示没有空洞。#padding=2通过官网公式计算
MaxPool2d(2),
Conv2d(32, 32, 5, padding=2),
MaxPool2d(2),
Conv2d(32, 64, 5, padding=2),
MaxPool2d(2),
Flatten(),
Linear(in_features=64*4*4, out_features=64),
Linear(64, 10)
)
def forward(self, x):
return self.model1(x)
if __name__ == '__main__':#验证网络正确性,用main语句
west = West()
input = torch.ones((64, 3, 32, 32))#创建一个输入的尺寸，看输出的尺寸是否为我们想要的
# torch可以便于创建数据类型，ones表示全是1。简单创建一个输入，这一步对代码结构进行简单检验。#之前在nn_seq.py中使用过
output = west(input)
print(output.shape)#torch.Size([64, 10]) #表示64张图片在每一个类别中的概率是多大
'''
#部分运行结果
训练数据集的长度为：50000
训练数据集的长度为：50000
测试数据集的长度为：10000
测试数据集的长度为：10000
-------第 1 轮训练开始-------
训练次数：100, Loss: 2.2948031425476074
训练次数：200, Loss: 2.2773358821868896
训练次数：300, Loss: 2.2693488597869873
训练次数：400, Loss: 2.175339460372925
训练次数：500, Loss: 2.0797555446624756
训练次数：600, Loss: 2.094938278198242
训练次数：700, Loss: 1.956000566482544
整体测试集上的Loss: 306.2772616147995
整体测试集上的正确率: 0.30079999566078186
第1轮模型已保存
-------第 2 轮训练开始-------
训练次数：800, Loss: 1.8498843908309937
训练次数：900, Loss: 1.8110010623931885
训练次数：1000, Loss: 1.9528685808181763
...
'''