卷积神经网络模型训练——入门理解

1. 对模型训练神经网络的理解：

（内容为b站“我是土堆”课程内容，观点仅代表个人理解，如果觉得有说的不对或者缺漏，麻烦在评论区批评指正，互相学习！）

    神经网络可以当成是个黑盒子（函数），里面有很多未知数（待训练的参数），通过输入端输入数据（图像便是以数组形式输入），经过随机计算得出预测结果，由预测结果与设定真实结果进行loss损失值计算（计算误差），由梯度返回对随机设定的参数进行调整，这也就是训练过程，直到误差符合训练标准。

2. 模型训练神经网络训练流程：

• 先通过dataset读取图片（或）其他open读取方法
• Dataloder将所读取图片进行封装batch处理
• 建立模型，选择loss计算方法及优化器
• 图片经过模型计算得出与分类target各分数
• 通过loss计算得出误差，并通过loss.backward得出梯度，便于优化模型中各层权重、偏置参数
• 优化器通过梯度进行梯度下降法（优化的方法不止这个）进行参数优化，可通过debug看出每轮训练各层weight、bias数据进行更新
• 随着多轮训练后，loss也会随着变小，达到最佳
• 建立验证数据集进行验证本次训练准确率如何，验证是否能够使用

1.数据集来源：Cifar-10   https://www.cs.toronto.edu/~kriz/cifar.html

2.建立网络模型

class cnnmodel(nn.Module):
    def __init__(self):
        super(cnnmodel, self).__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(64*4*4, 64),
            nn.Linear(64, 10)
        )

    def forward(self, x):
        x = self.model(x)
        return x

• 提取最大特征

3channel，32*32 image经过5*5卷积核进行卷积生成32channel图片，在经过最大池化提取特征，依次反复3次，最后形成64channel，4*4 image

• 计算分类相似值

经过flat层与线性层算出图片与10target的拟合分数，分数高的就是对应的target

3.选择损失函数

loss_fn = nn.CrossEntropyLoss()

4.选择SGD优化器

learning_rate = 1e-2

optimizer = torch.optim.SGD(tudui.parameters(), lr=learning_rate)

5.开始训练

# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练的轮数
epoch = 30

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

    # 训练步骤开始
    cmodel.train()
    for data in train_dataloader:
        imgs, targets = data
        if torch.cuda.is_available():
            imgs = imgs.cuda()
            targets = targets.cuda()
        outputs = cmodel(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()))

    # 测试步骤开始
    cmodel.eval()
    total_test_loss = 0
    total_accuracy = 0
    with torch.no_grad():
        for data in test_dataloader:
            imgs, targets = data
            if torch.cuda.is_available():
                imgs = imgs.cuda()
                targets = targets.cuda()
            outputs = cmodel(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("整体测试集上的Loss: {}".format(total_test_loss))
    print("整体测试集上的正确率: {}".format(total_accuracy/test_data_size))
   
    total_test_step = total_test_step + 1

    if(i==29):
        torch.save(cmodel, "cmodel_gpu_{}.pth".format(i))
        print("模型已保存")

完整源码：

import torch
import torchvision
from PIL import Image
from torch import nn

# 准备数据集
from torch import nn
from torch.utils.data import DataLoader

train_data = torchvision.datasets.CIFAR10(root="D:/VScode/pyproject/nueralnetwork/pytorch-tutorial-master/data", train=True, transform=torchvision.transforms.ToTensor(),
                                          download=True)
test_data = torchvision.datasets.CIFAR10(root="D:/VScode/pyproject/nueralnetwork/pytorch-tutorial-master/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))


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


class cnnmodel(nn.Module):
    def __init__(self):
        super(cnnmodel, self).__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(64*4*4, 64),
            nn.Linear(64, 10)
        )

    def forward(self, x):
        x = self.model(x)
        return x

cmodel = cnnmodel()
if torch.cuda.is_available():
    cmodel = cmodel.cuda()

# 损失函数
loss_fn = nn.CrossEntropyLoss()
if torch.cuda.is_available():
    loss_fn = loss_fn.cuda()

# 优化器
# learning_rate = 0.01
learning_rate = 1e-2
optimizer = torch.optim.SGD(cmodel.parameters(), lr=learning_rate)


# 记录训练的次数
total_train_step = 0
# 记录测试的次数
total_test_step = 0
# 训练的轮数
epoch = 30

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

    # 训练步骤开始
    cmodel.train()
    for data in train_dataloader:
        imgs, targets = data
        if torch.cuda.is_available():
            imgs = imgs.cuda()
            targets = targets.cuda()
        outputs = cmodel(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()))

    # 测试步骤开始
    cmodel.eval()
    total_test_loss = 0
    total_accuracy = 0
    with torch.no_grad():
        for data in test_dataloader:
            imgs, targets = data
            if torch.cuda.is_available():
                imgs = imgs.cuda()
                targets = targets.cuda()
            outputs = cmodel(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("整体测试集上的Loss: {}".format(total_test_loss))
    print("整体测试集上的正确率: {}".format(total_accuracy/test_data_size))
   
    total_test_step = total_test_step + 1

    if(i==29):
        torch.save(cmodel, "cmodel_gpu_{}.pth".format(i))
        print("模型已保存")