一、模型的训练

        Step1.准备数据集

import torchvision

train_data = torchvision.dataset.CIFAR10("../data",train=True,
        transform=torchvision.ToTensor，download=True)    --载入训练集
test_data = torchvision.dataset.CIFAR10("../data",train=False,
        transform=torchvision.ToTensor，download=True)    --载入测试集

                        Tips.获取数据集长度

train_data_size = len(train_data)

        Step2.加载数据集

train_dataloader = DataLoader(train_data,batch_size=64)
test_dataloader = DataLoader(test_data,batch_size=64)

        Step3.搭建网络

class MyNerNet(nn.Moduel):
    def __init__(self):
        super(MyNerNet,self).__init__()    --基类初始化
        self.model = nn.Sequential(                  --网络序列器
                            nn.Cov2d(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):    --传递函数
        return self,model(x)

                可将网络相关代码放置在一个单独的文件中，但是在主文件中需要使用引用

from model import *    --将model文件中所有的内容引用

        Step4.创建损失函数和优化器

loss_fn = nn.CrossEntropyLoss()    --交叉损失函数

learing_rate=0.01    --学习速率，外置方便修改
optimizer = torch.optim.SGD(MyNerNet.parameters(),lr=learing_rate)    --随机梯度下降

        Step5.训练+测试

--设置一些计数器
    total_train_step = 0    --记录训练次数
    total_test_step = 0    --记录训练次数
    epoch = 10    --训练轮数

--开始训练
    for i in range(epoch):
        print("---第{}轮训练---".format(i+1))
        for data in train_dataloader
            imgs,targets = data    --拆包
            outputs = mynet(imgs)    --使用网络
            loss = loss_fn(outputs,targets)    --计算损失函数

            optimizer.zero_grad()    --梯度清零
            loss.backforward()    --前向传递
            optimizer.step()    --逐步优化

            total_train_step += 1    --计数
            print("训练次数：{}，Loss：{}".format(total_train_step,loss.item()))    
                --展示//也可以使用TensorBorad进行展示

    --开始测试
        total_test_loss = 0    --总损失函数计数
        with torch.no_grad():    --不设置梯度（保证不进行调优）
            for data in test_dataloader:
                imgs,targets = data    --拆包
                outputs = mynet(imgs)    --使用网络
                loss = loss_fn(outputs,targets)    --计算损失函数
                total_test_loss = total_test_loss + loss  --添加此次部分损失函数
        print("整个测试集上的Loss：{}".format(total_test_loss))
        total_test_step = total_test_step + 1

    --保存每轮的模型
        torch.save(mynet,"MyNerNet_Ver{}.pth".format(total_train_step))

                Tips.正确率展示（用于分类问题）

outputs = torch.Tensor([[0.1,0.2],
                        [0.3,0.4]])

preds = outputs.argmax(1)    --最大延展
targets = Torch.Tensor([0,1])    --真实输入

print(preds == targets)    --检验(对应位置是否相等),输出正确的个数

二、模型训练需要注意的事项

        1.网络训练/测试模式

                当网络中含有Dropout、BatchNorm时，必须调用

                但是如果没有对应的内容不是必须的，使用无效

mynet.train()    --训练模式
mynet.test()    --测试模型

        2.测试时关闭梯度

                测试之前需要调用这行代码，关闭网络的梯度

with torch.no_grad():    

三、使用GPU进行训练加速

        1.方式一：在原有的网络模型、数据(输入、标注)、损失函数中调用.cuda()函数即可

mynet = mynet.cuda()    --对网络调用

loss_fn = loss_fn.cuda()    --对损失函数调用

imgs = imgs.cuda()    --仅对部分数据生效（数据集的输入数据）

                但如果电脑没有N卡就会报错，最好在代码前部加上验证函数

if torch.cuda.is_available()
    mynet = mynet.cuda()    --有GPU再将网络进行转移

        2.方式二：在原有的网络模型、数据(输入、标注)、损失函数中调用.to(device)函数--流转到其他设备

Device = torch.device("cpu")    --调用CPU
Device = torch.device("cuda")    --调用GPU
Device = torch.device("cuda:0")    --调用第一块GPU（当存在多块GPU时）

mynet.to(device)    --流转到设备