一、训练完整使用网络模型

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))

# 利用dataloade r加载数据集#加载数据集的参数设置
train_dataloader = DataLoader (train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)

# 创建网络模型
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

for i in range(epoch):
    print("-------第{}轮训练开始--------".format(i+1))
    # 训练网络模型,从训练的data中取数据
    # 训练步骤开始
    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
        print("训练次数:{}, Loss: {}".format(total_test_step, loss.item()))

二、调用的神经网络模型

import torch
from torch import nn
from torch.nn import Conv2d, MaxPool2d, Flatten, Linear, Sequential


class SUN(nn.Module):
    def __init__(self):
        super(SUN, 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(1024, 64),
            nn.Linear(64, 10)
        )

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



if __name__ == '__main__':
    sun = SUN()
    input = torch.ones((64, 3, 32,32))
    output = sun(input)
    print(output.shape)

三、调用python文件

在调用的python文件时，会出现一些问题：

from model1 import*

使用该语句调用，但是model1会画红色波浪线报错，并且，引用的神经网络也会出现报错，原因就是，未正确引用py文件。

尝试的解决办法：使用.model1，这种办法不可取后；

使用标记目录仍未成功；

最终，神经网络的py文件与训练的该文件在同一目录下，将被引用的Py文件，放在需引用文件的上一级目录下。也就是说，被引用文件在需引用文件的上一级。

# 接套路一代码：

# 如何知道数据训练好了没有
# 利用现有模型进行测试
# 在测试数据集上走一遍，以测试数据集的损失，来判定模型训练好了没有
# 测试过程中不需要在对模型进行调优
# 测试步骤开始

    total_test_loss = 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()

        print("整体测试集上的Loss:{}".format(total_test_loss))

        writer.add_scalar("test_loss",total_test_loss, total_train_step)
        total_test_step +=1

                # 对模型的保存

        torch.save(sun, "sun_{}.path".format(i))
        print("模型已保存")

writer.close()

在tensorboard上显示：

经过10轮的训练，测试集与训练集的损失值变化。

输出（outputs)与最终的预测(predicts)之间的转变，使用函数Argmax，就能够求出横向的最大值所在的位置。