模型训练套路（二）

接模型训练套路（一）http://t.csdnimg.cn/gZ4Fm

得到预测的值：preds=[1][1]，

输出目标：inputs target = [0][1]；

查看两者的正确率，就看：preds==inputs target

输出的结果：[false][true].sum = 1

一、计算正确率的代码：

import torch

output = torch.tensor([[0.1,0.2],
                       [0.3,0.4]])
# argmax(1)表示横向比较
print(output.argmax(1))
preds = output.argmax(1)

targets = torch.tensor([0, 1])

print((preds == targets).sum())

接训练一代码，计算整体的计算率：在测试步骤开始中写：

total_accuracy = 0

accuracy = (outputs.argmax(1)==targets).sum()
total_accuracy = total_accuracy + accuracy

writer.add_scalar("test_accuracy",total_accuracy/test_data_size,total_test_step)

模型训练套路（三）

模型包括：1、数据集——>2、加载数据集——>3、创建网络模型——>4、损失函数——>5、优化器——>6、设置训练参数——>7、设置训练epoch——>8、训练开始(优化器优化模型、展示数据)——>9、测试开始(设置梯度为0，从测试数据集中取数据，计算loss,计算误差，构建需要指标并显示，展示训练的网络在测试集上的效果)——>10、保存模型

完整代码：

能够使用gpu的语句：

网络模型；

数据（输入，标注）；imgs,targets

损失函数；

​
import torch
import torchvision
from torch import nn
from torch.utils.data import DataLoader
from model1 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)
# 查看数据集的长度
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, shuffle=True)
test_dataloader = DataLoader(test_data, batch_size=64, shuffle=True)

# 创建网络模型
sun = SUN()

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

# 优化器（SGD随机梯度下降）
learning_rate = 0.01
optimizer = torch.optim.SGD(sun.parameters(), lr = learning_rate)

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

# 添加tensorboard
writer = SummaryWriter("../train_logs")

for i in range(epoch):
    print("-------第{}轮训练开始--------".format(i+1))
    # 训练网络模型,从训练的data中取数据
    # 训练步骤开始
    sun.train()  # 该语句并不一定要写
    for data in train_dataloader:
        imgs, targets = data
        outputs = sun(imgs)
        # 将得到的输出与真实的target比较，得到误差
        loss =loss_fn(outputs, targets)

        # 优化器优化模型
        # 进行优化，首先是梯度清零
        optimizer.zero_grad()
        # 得到每个节点的梯度
        loss.backward()
        # 对其中的参数进行优化
        optimizer.step()

        total_test_step = total_test_step + 1
        if total_test_step % 100 == 0:
            print("训练次数:{}, Loss: {}".format(total_test_step, loss.item()))
            writer.add_scalar("train_loss",loss.item(),total_train_step)
     # 如何知道数据训练好了没有
     # 利用现有模型进行测试
     # 在测试数据集上走一遍，以测试数据集的损失，来判定模型训练好了没有
     # 测试过程中不需要在对模型进行调优
     # 测试步骤开始
    sun.eval() # 该语句也不一定要写
    total_test_loss = 0
    total_accuracy = 0
    with torch.no_grad():
        for data in test_dataloader:
            imgs, targets = data
            outputs = sun(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))

        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 +=1
        torch.save(sun, "sun_{}.path".format(i))
        print("模型已保存")

writer.close()

​

​