人工智能学习06--pytorch07--完整的模型训练、测试套路（CIFAR10）

【训练套路】：

建立模型

1. 卷积
   Inputs → Feature maps
   

3,32,5,1(默认),(输入3232，输入3232，经计算此处padding为2)

2. 最大池化
   
   nn.MaxPool2d(2)

3. 卷积
   

4. 最大池化
   

5. 卷积
   
   inchannel32，outchannel64，大小没有变所以padding2

6. 最大池化
   

7. 展平
   
   把64个4*4的展平

8. 线性层
   

9. 线性层
   
   完成模型初始化

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

# 准备训练数据集、测试数据集

train_data = torchvision.datasets.CIFAR10(root="./datasetCIFAR10",train=True,transform=torchvision.transforms.ToTensor(),
                                          download=True)
test_data = torchvision.datasets.CIFAR10(root="./datasetCIFAR10",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))

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

# 搭建神经网络
# 一共10个类别（10分类）
class cifar10Net(nn.Module):
    def __init__(self):
        super(cifar10Net,self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3,32,5,1,2), # 卷积
            nn.MaxPool2d(2), # 最大池化 kernel_size=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

测试网络正确性

# 把上面 ↑ 搭建的网络模型创造出来
# 考察：一般是给一个输入的尺寸，看输出的尺寸是不是我们想要的
# 64 batch_size ; 3 通道 ; 32*32

if __name__ == '__main__':
    cifar10net = cifar10Net()
    input = torch.ones((64,3,32,32)) # 输入64张图片
    output = cifar10net(input)
    print(output.shape) # torch.Size([64, 10]) 返回64张图，每一行上10个数据，表示属于这十个类别的概率

在训练文件中引入网络

这两个文件要在同一个文件夹底下
但是这里报错了，上网查了一下：
https://www.cnblogs.com/xiaohuamao/p/6903030.html
但是也不行
原来文件开头不能用数字打头，重新建了一个文件就好了

创建网络模型、训练

# 创建网络模型
cifar10net = cifar10Net()

# 损失函数
# 因为分类问题，可以用到“损失函数”课中讲的交叉熵
loss_fn = nn.CrossEntropyLoss()

# 优化器
# learning_rate = 0.01
learning_rate = 1e-2 # 1e-2 = 1x(10)^(-2) = 1/100 = 0.01
# parameters填建立的网络模型
optimizer = torch.optim.SGD(cifar10net.parameters(),lr=learning_rate)

# 设置训练网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练的轮数
epoch = 10
# 把for循环里的东西循环了10次
for i in range(epoch):
    print("--------第{}轮训练开始--------".format(i+1))
    # --------------训练步骤开始（优化器调优）--------------- 梯度清零、反向传播、参数优化、变量加一
    # 从训练的 dataloader 中取数据
    for data in train_dataloader:
        imgs,targets = data
        outputs = cifar10net(imgs) # 把训练数据送到网络中,获得相应输出
    # 获得输出后与真实的target进行对比，得到误差
        loss = loss_fn(outputs,targets)
    # 进行优化 【先把梯度清零】
        optimizer.zero_grad()
    # 反向传播，得到每个参数的梯度
        loss.backward()
    # 对参数优化
        optimizer.step()
    # --------------完成了一次优化---------------
        total_train_step = total_train_step + 1
        print("训练次数：{}，loss：{}".format(total_train_step,loss)) # 或者loss.item()   .item():把tensor数据类型转化为真实数字

如何知道这个模型是否训练好、是否达到需求
可以在每一轮训练后进行测试，在测试集上跑一边，利用在测试集输出的正确率来衡量。

这里就不调优了，就利用现有的模型来

import torchvision
from torch import nn
from torch.utils.data import DataLoader
from cifar10NetModel import *

# 准备训练数据集、测试数据集

train_data = torchvision.datasets.CIFAR10(root="./datasetCIFAR10",train=True,transform=torchvision.transforms.ToTensor(),
                                          download=True)
test_data = torchvision.datasets.CIFAR10(root="./datasetCIFAR10",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))

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

# 创建网络模型
cifar10net = cifar10Net()

# 损失函数
# 因为分类问题，可以用到“损失函数”课中讲的交叉熵
loss_fn = nn.CrossEntropyLoss()

# 优化器
# learning_rate = 0.01
learning_rate = 1e-2 # 1e-2 = 1x(10)^(-2) = 1/100 = 0.01
# parameters填建立的网络模型
optimizer = torch.optim.SGD(cifar10net.parameters(),lr=learning_rate)

# 设置训练网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练的轮数
epoch = 10
# 把for循环里的东西循环了10次
for i in range(epoch):
    print("--------第{}轮训练开始--------".format(i+1))
    # --------------训练步骤开始（优化器调优）--------------- 梯度清零、反向传播、参数优化、变量加一
    # 从训练的 dataloader 中取数据
    for data in train_dataloader:
        imgs,targets = data
        outputs = cifar10net(imgs) # 把训练数据送到网络中,获得相应输出
    # 获得输出后与真实的target进行对比，得到误差
        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)) # 或者loss.item()   .item():把tensor数据类型转化为真实数字

# 如何知道这个模型是否训练好、是否达到需求
# 可以在每一轮训练后进行测试，在测试集上跑一边，利用在测试集输出的正确率来衡量。
    # --------------测试步骤开始---------------
# 这里就不调优了，就利用现有的模型来 （with torch.no_grad()）
    total_test_loss = 0
    with torch.no_grad():
        for data in test_dataloader:
            imgs,targets = data
            outputs = cifar10net(imgs)
            loss = loss_fn(outputs,targets) # 一部分数据（data），not测试集整体数据的损失
# 把每次求出的loss加上去，最后得到整体loss
            total_test_loss = total_test_loss + loss.item()
    print("整体测试集上的loss：{}".format(total_test_loss))

添加tensorboard

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

from cifar10NetModel import *

# 准备训练数据集、测试数据集

train_data = torchvision.datasets.CIFAR10(root="./datasetCIFAR10",train=True,transform=torchvision.transforms.ToTensor(),
                                          download=True)
test_data = torchvision.datasets.CIFAR10(root="./datasetCIFAR10",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))

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

# 创建网络模型
cifar10net = cifar10Net()

# 损失函数
# 因为分类问题，可以用到“损失函数”课中讲的交叉熵
loss_fn = nn.CrossEntropyLoss()

# 优化器
# learning_rate = 0.01
learning_rate = 1e-2 # 1e-2 = 1x(10)^(-2) = 1/100 = 0.01
# parameters填建立的网络模型
optimizer = torch.optim.SGD(cifar10net.parameters(),lr=learning_rate)

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

# 添加tensorboard
writer = SummaryWriter("logs_train_cifar10")

# 把for循环里的东西循环了5次
for i in range(epoch):
    print("--------第{}轮训练开始--------".format(i+1))
    # --------------训练步骤开始（优化器调优）--------------- 梯度清零、反向传播、参数优化、变量加一
    # 从训练的 dataloader 中取数据
    for data in train_dataloader:
        imgs,targets = data
        outputs = cifar10net(imgs) # 把训练数据送到网络中,获得相应输出
    # 获得输出后与真实的target进行对比，得到误差
        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())) # 或者loss.item()   .item():把tensor数据类型转化为真实数字
            # 逢百记录
            writer.add_scalar("train_loss",loss.item(),total_train_step)

# 如何知道这个模型是否训练好、是否达到需求
# 可以在每一轮训练后进行测试，在测试集上跑一边，利用在测试集输出的正确率来衡量。
    # --------------测试步骤开始---------------
# 这里就不调优了，就利用现有的模型来 （with torch.no_grad()）
    total_test_loss = 0
    with torch.no_grad():
        for data in test_dataloader:
            imgs,targets = data
            outputs = cifar10net(imgs)
            loss = loss_fn(outputs,targets) # 一部分数据（data），not测试集整体数据的损失
# 把每次求出的loss加上去，最后得到整体loss
            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 = total_test_step + 1

writer.close()
#  tensorboard --logdir=logs_train_cifar10 --port=6007

可看到test_loss、train_loss不断下降

保存每一次训练后的模型

计算整体正确率

1，横着看

0，竖着看

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

from cifar10NetModel import *

# 准备训练数据集、测试数据集

train_data = torchvision.datasets.CIFAR10(root="./datasetCIFAR10",train=True,transform=torchvision.transforms.ToTensor(),
                                          download=True)
test_data = torchvision.datasets.CIFAR10(root="./datasetCIFAR10",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))

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

# 创建网络模型
cifar10net = cifar10Net()

# 损失函数
# 因为分类问题，可以用到“损失函数”课中讲的交叉熵
loss_fn = nn.CrossEntropyLoss()

# 优化器
# learning_rate = 0.01
learning_rate = 1e-2 # 1e-2 = 1x(10)^(-2) = 1/100 = 0.01
# parameters填建立的网络模型
optimizer = torch.optim.SGD(cifar10net.parameters(),lr=learning_rate)

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

# 添加tensorboard
writer = SummaryWriter("logs_train_cifar10")

# 把for循环里的东西循环了5次
for i in range(epoch):
    print("--------第{}轮训练开始--------".format(i+1))
    # --------------训练步骤开始（优化器调优）--------------- 梯度清零、反向传播、参数优化、变量加一
    # 从训练的 dataloader 中取数据
    for data in train_dataloader:
        imgs,targets = data
        outputs = cifar10net(imgs) # 把训练数据送到网络中,获得相应输出
    # 获得输出后与真实的target进行对比，得到误差
        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())) # 或者loss.item()   .item():把tensor数据类型转化为真实数字
            # 逢百记录
            writer.add_scalar("train_loss",loss.item(),total_train_step)

# 如何知道这个模型是否训练好、是否达到需求
# 可以在每一轮训练后进行测试，在测试集上跑一边，利用在测试集输出的正确率来衡量。
    # --------------测试步骤开始---------------
# 这里就不调优了，就利用现有的模型来 （with torch.no_grad()）
    total_test_loss = 0
    total_accuracy = 0
    with torch.no_grad():
        for data in test_dataloader:
            imgs,targets = data
            outputs = cifar10net(imgs)
            loss = loss_fn(outputs,targets) # 一部分数据（data），not测试集整体数据的损失
# 把每次求出的loss加上去，最后得到整体loss
            total_test_loss = total_test_loss + loss.item()
            accuracy = (outputs.argmax(1) == targets).sum() # 添加每次这一小部分的正确率
            total_accuracy = total_accuracy + accuracy

    print("整体测试集上的loss：{}".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 = total_test_step + 1
    # 保存每一轮训练后的结果
    # torch.save(cifar10net,"cifar10net_{}.pth".format(i))
    # print("模型已保存")

writer.close()
#  tensorboard --logdir=logs_train_cifar10 --port=6007

模型.train() 模型.eval()

分别是把模型设置成训练模式、测试模式

但是前面写的代码都没用这种模式，依旧可以训练、测试


前面写过的代码里并没有这两个层
现在加上，更完整

没改什么，但是加了一些注释

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

from cifar10NetModel import *

# 【1】准备训练数据集、测试数据集

train_data = torchvision.datasets.CIFAR10(root="./datasetCIFAR10",train=True,transform=torchvision.transforms.ToTensor(),
                                          download=True)
test_data = torchvision.datasets.CIFAR10(root="./datasetCIFAR10",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))

# 【2】利用DataLoader加载数据集
train_dataloader = DataLoader(train_data,batch_size=64)
test_dataloader = DataLoader(test_data,batch_size=64)

# 【3】创建网络模型
cifar10net = cifar10Net()

# 【4】损失函数
# 因为分类问题，可以用到“损失函数”课中讲的交叉熵
loss_fn = nn.CrossEntropyLoss()

# 【5】优化器
# learning_rate = 0.01
learning_rate = 1e-2 # 1e-2 = 1x(10)^(-2) = 1/100 = 0.01
# parameters填建立的网络模型
optimizer = torch.optim.SGD(cifar10net.parameters(),lr=learning_rate)

# 【6】设置训练网络的一些参数
# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练的轮数，使之能够多次训练
epoch = 5

# 添加tensorboard
writer = SummaryWriter("logs_train_cifar10")

# 把for循环里的东西循环了5次
for i in range(epoch):
    print("--------第{}轮训练开始--------".format(i+1))
    # --------------训练步骤开始（优化器调优）--------------- 梯度清零、反向传播、参数优化、变量加一
    # 【7】网络进入训练状态
    cifar10net.train()
    # 从训练的 dataloader 中【取数据】
    for data in train_dataloader:
        imgs,targets = data
        outputs = cifar10net(imgs) # 把训练数据送到网络中,获得相应输出
    # 获得输出后与真实的target进行对比，得到【误差】
        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())) # 或者loss.item()   .item():把tensor数据类型转化为真实数字
            # 逢百记录
            writer.add_scalar("train_loss",loss.item(),total_train_step)

# 如何知道这个模型是否训练好、是否达到需求
# 可以在每一轮训练后进行测试，在测试集上跑一边，利用在测试集输出的正确率来衡量。
    # --------------测试步骤开始---------------
    # 【8】测试
    cifar10net.eval()
    # 这里就不调优了，就利用现有的模型来 （with torch.no_grad()）
    total_test_loss = 0
    total_accuracy = 0
    # 【with torch.no_grad()】此时只需要测试，不需要对梯度进行调整！重要！
    with torch.no_grad():
        for data in test_dataloader: #【取数据】
            imgs,targets = data
            outputs = cifar10net(imgs)
            loss = loss_fn(outputs,targets) # 一部分数据（data），not测试集整体数据的损失 【误差】
            # 把每次求出的loss加上去，最后得到整体loss
            total_test_loss = total_test_loss + loss.item()
            # 【显示误差】
            accuracy = (outputs.argmax(1) == targets).sum() # 添加每次这一小部分的正确率
            total_accuracy = total_accuracy + accuracy

    # 展示训练的网络在测试集上的效果
    print("整体测试集上的loss：{}".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 = total_test_step + 1
    # 【保存】每一轮训练后的结果
    # （方式一）
    # torch.save(cifar10net,"cifar10net_{}.pth".format(i))
    # （方式二）
    # torch.save(cifar10net.state_dict(),"cifar10net_{}.pth".format(i))
    # print("模型已保存")

writer.close()
#  tensorboard --logdir=logs_train_cifar10 --port=6007

用GPU训练

【测试套路】：

输入图片与尺寸

相对路径：两个点是上一目录


……

发现这个图片的大小是 261210，而上面模型的输入是3232

import torch
import torchvision.transforms
from PIL import Image
from torch import nn

image_path = "D:\Projects\PycharmProjects\pythonProject\images\dog.png"
image = Image.open(image_path)
print(image) # <PIL.PngImagePlugin.PngImageFile image mode=RGB size=261x210 at 0x1686FAAE310>
# 因为png是四通道，除了RGB三通道外还有一个透明通道。所以调用这段代码保留颜色通道
# 如果图片本来就是三个通道，调用此操作后不变。
# 加上这一步后可以适应png、jpg各种格式的图片
# 不同截图软件保留的通道数不一样
# image = image.convert('RGB')

transform = torchvision.transforms.Compose([torchvision.transforms.Resize((32,32)),
                                            torchvision.transforms.ToTensor()])

image = transform(image)
print(image.shape)

# 拷贝的网络模型
# 粘贴的是参数，需要把参数放入到网络模型中去，没有模型只放参数是不可能运行的
class cifar10Net(nn.Module):
    def __init__(self):
        super(cifar10Net,self).__init__()
        self.model = nn.Sequential(
            nn.Conv2d(3,32,5,1,2), # 卷积
            nn.MaxPool2d(2), # 最大池化 kernel_size=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
# 加载模型
model = torch.load("cifar10net_9.pth")
print(model)
# 模型网络的输入要求张量的阶数为4，
# 即(batch_size, Channel,Hight,weight)，一般的图片输入为3阶张量，
# 即(Channel：3, Hight：32, Weight：32)。
image = torch.reshape(image,(1,3,32,32))
model.eval()
with torch.no_grad(): # 节约内存、性能
    output = model(image)
print(output)

# 预测输出：tensor([[ 2.2722, -1.4881, -0.8504,  1.8632,  0.8308,  1.0495,  0.6538, -1.5160,
#          -0.6486, -1.6084]])
# 第0类最大 tensor([0]) 不准确，dog是类5
print(output.argmax(1))

预测错了，哈哈哈哈，但是总体思路就是这样。