【深度学习】Pytorch框架的入门简易代码模板及解析

  记录本人学习深度学习的过程，采用的是Pytorch框架，代码中间会有自己的理解，可能会有错误，希望各位大佬批评指正，也与各位在AI路上的学习者共勉！

一、前期操作

  这是在命令行或者终端中输入的代码，可以用于查询自己GPU的显存、利用率和CUDA的版本，仅对NVIDIA英伟达独立显卡有用，集成显卡是不能用的。一般来说，显卡的种类决定了CUDA的版本，CUDA的版本跟要安装的Pytorch版本有关系，而GPU的利用率越高，比如100%，说明了处于满负荷的状态，能够较大的发挥显卡的性能，可以实时查看一下，如果利用率很低就要检查一下自己的代码了。

!nvidia-smi

  正常会输出类似的东西，可以看到CUDA的Version是11.2，，显存是15109MiB，相当于是15G了，右边显示0%，说明目前的显卡利用率是0%，并且下面的Processes显示没有进程。

+-----------------------------------------------------------------------------+
| NVIDIA-SMI 460.32.03    Driver Version: 460.32.03    CUDA Version: 11.2     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|                               |                      |               MIG M. |
|===============================+======================+======================|
|   0  Tesla T4            Off  | 00000000:00:04.0 Off |                    0 |
| N/A   59C    P0    28W /  70W |      0MiB / 15109MiB |      0%      Default |
|                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+
                                                                               
+-----------------------------------------------------------------------------+
| Processes:                                                                  |
|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |
|        ID   ID                                                   Usage      |
|=============================================================================|
|  No running processes found                                                 |
+-----------------------------------------------------------------------------+

二、导入函数库

  导入一些需要用到的函数库，比如torch、torch.nn、DataLoader等等，这里导入time函数库是为了记录一下训练网络的时间。

import torch
import torch.nn as nn
import torchvision
from torch.utils.data import DataLoader
import time
import torch.nn.functional as F

三、定义随机种子

  如果只是自己学习，这一步应该是不需要的，固定随机种子的目的是为了保证自己的模型结果是可以复现的，这在科研工作中十分重要，如果你的实验只有你自己能做出最好的结果，别人都做不出来，那你的研究就没有什么意义了。
  说到固定随机种子，就想到一篇很有意思的论文《Torch.manual_seed(3407) is all you need: On the influence of random seeds in deep learning architectures for computer vision》，中文译名是Torch.manual_seed(3407) is all you need：论随机种子对计算机视觉深度学习架构的影响，作者探究了随机种子选择对准确性的影响，用了10000个种子进行搜索，最终发现3407这个种子相较于平均值特别好，所以如果不知道设置什么种子，不如就设置它哈哈哈。
  随机种子固定后，随机梯度下降的方向就会一样的，不带有随机性了（避免深度炼丹），而且用到Dataloader的时候也会让它加载的数据序列是一样的。

import os
import random
import numpy as np
def my_seed(seed=3407):
	random.seed(seed)
	np.random.seed(seed)
	torch.manual_seed(seed)
	torch.cuda.manual_seed(seed)
# 调用一下
my_seed(seed=3407)

四、定义网络结构Network

  个人的写代码顺序比较喜欢先写网络结构，毕竟它是我们之后学习和“魔改”的主要对象。下面写一个自己设计的简单网络，考虑到我们等会用的数据集是CIFAR10，是一个10分类的数据集，所以out_channels是10，而我们用的数据集图片是3个RGB通道的，所以in_channels是3。
  我们自己定义网络结构的时候，要首先继承nn.Module，并且重写构造函数__init__和forward方法。
  （1）__init__构造函数中包含了网络中可学习参数的层，比如全连接、池化层、卷积层等，不含可学习参数的层其实也可以放在里面，比如各种激活函数，但是个人更推荐直接放在forward方法里面，用nn.functional as F来方便调用，形式就像F.relu()。
  （2）forward方法是必须要重写的，它是实现网络模型具体功能的方法，用于数据流通、连接各个层的。一定要按照顺序来写。

class DeepNet(nn.Module):
  def __init__(self, in_channels, out_channels):
    super(DeepNet, self).__init__()
    self.conv1 = nn.Conv2d(in_channels, 64, 3)
    self.conv2 = nn.Conv2d(64, 64, 3, stride=1, padding=1) 
    self.max_pooling = nn.MaxPool2d(2, stride=2, padding=1)
    self.bn = nn.BatchNorm2d(64)
    self.fc1 = nn.Linear(112*112*64, 64)
    self.fc2 = nn.Linear(64, out_channels)

  def forward(self, x):
    x = self.conv1(x)
    x = self.bn(x)
    x = F.relu(x)
    
    x = self.conv2(x)
    x = self.bn(x)
    x = F.relu(x)
    
    x = self.max_pooling(x)
    x = x.view(x.shape[0],-1)
    x = self.fc1(x)
    x = F.relu(x)
    x = self.fc2(x)

    return x

  这里输入的图像大小是224ｘ224（写到这里，突然觉应该先写数据处理和数据集，因为网络结构跟数据有关系┭┮﹏┭┮，之后一定要注意），解释一下nn.Conv2d(in_channels, 64, 3)，这里说明图像进入的通道数是in_channels=3，这很合理，然后出去的通道数是64，升维度了，然后卷积核Kernel_size是3，其他都是默认，比如padding默认是0，stride默认是1，经过这第一个卷积，图像的大小发生改变了，具体的变化跟kernel_size、padding、stride有关系，总之这里的输出的特征图大小由原本的224ｘ224变为了222ｘ222。

图像的输出长宽 = （图像输入的长宽-卷积核kernel_size+2*padding）/步长stride+1
222 = （224-3+0）/ 1+1

  这里先定义一个网络，然后把它打印出来看看：

net=DeepNet(3,10)
print(net)

DeepNet(
(conv1): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1))
(conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(max_pooling): MaxPool2d(kernel_size=2, stride=2, padding=1, dilation=1, ceil_mode=False)
(bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
(fc1): Linear(in_features=802816, out_features=64, bias=True)
(fc2): Linear(in_features=64, out_features=10, bias=True)
)

四、定义Transform数据处理

  定义transform的相关操作，会在datasets中得到使用，这里定义了转换数据为tensor、规定图像的大小、均值化和随机水平翻转的操作。

transform = torchvision.transforms.Compose(
    [
        torchvision.transforms.ToTensor(),  # 将数据转换为pytorch的tensor
        torchvision.transforms.Resize(size=([224, 224])),
        torchvision.transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]),  # 均值、方差
        torchvision.transforms.RandomHorizontalFlip()  # 随机水平翻转
    ]
)
train_data=torchvision.datasets.CIFAR10(root="dataset",train=True,transform=transform,download=True)
test_data=torchvision.datasets.CIFAR10(root="dataset",train=False,transform=transform,download=True)

train_data_size=len(train_data)
test_data_size=len(test_data)
print("训练集的长度为{}".format(train_data_size))
print("测试集的长度为{}".format(test_data_size))

训练集的长度为50000
测试集的长度为10000

五、定义Dataloader

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

六、创建网络、损失函数和优化器，定义相关的超参数

  这里.cuda()是将网络和损失函数放到显卡里面去计算，如果没有显卡的话这里可以删除.cuda()

model=DeepNet(3,10).cuda()
loss_fn=nn.CrossEntropyLoss()
loss_fn=loss_fn.cuda()
lr_rate=1e-4
optimizer=torch.optim.Adam(model.parameters(),lr=lr_rate)

total_train_step=0
total_test_step=0
epoch=10
start_time=time.time()
min_loss=100

七、开始训练、测试并保存模型

  本质上其实是两层循环，首先第一层训练是训练次数i的循环，在这一层循环中，如果模型中有BN层(Batch Normalization)和Dropout，需要在训练时添加model.train()，将模型调整为训练状态，从而启用BN层和Dropout，我们这里有用BN层，所以要用。同时，在测试时添加model.eval()，作用是不启用BN和Dropout层。
  我们都知道，在训练模式中，BN层作用是去计算数据的方差和均值，对不同样本的同一个通道直接做归一化处理；Dropout会按照设置的参数决定保留激活单元的概率。那么在model.eval()下，Dropout层会让所有的激活单元都通过，而BN层会停止计算和更新数据的方差和均值。同时的话，模型在测试模式下不会更新权重（不可能在测试集上进行训练），但是不会影响各层的梯度计算行为，会像训练模式一样梯度计算和存储，只是不进行反向传播，因此才能在测试模型下计算损失。
  第二层训练就是数据在dataloader中的迭代。当一个完整的数据集通过了神经网络一次并且返回了一次，这个过程称为一轮epoch，而一轮epoch训练中包含了多次的迭代过程，这就有了batch的概念，也就是批次。当不能将数据一次性通过神经网络的时候（因此显卡的显存是有限的），就需要将数据集分成几个batch，比如设置batch=100，训练集的总量是1000，那么一轮epoch训练就有1000/100=10次迭代（iteration）。
  在每轮epoch中，我们都要获得数据和标签，这里的数据形式是图像，也就是imgs，标签是targets，把它们存到显卡中计算，然后去计算图像在模型中训练获得的结果，对应了outputs=model(imgs)，outputs就是获得的模型预测标签，既然是训练就可能有误差，从而我们计算损失，对应了loss=loss_fn(outputs, targets)，注意这里的targets是指数据集中给出的正确标签，去计算它们之间的差距。
  optimizer.zero_grad()、loss.backward()和optimizer.step()分别是说，先将梯度归零，然后反向传播计算每个参数的梯度值，最后通过梯度下降进行参数更新，也就完成了一次迭代过程。
  测试过程是类似的，只不过多了计算accuracy的过程，accuracy=(outputs.argmax(1)==targets).sum()是指判断模型返回向量中值最大的那个标签，是否跟真实标签一致，如果是那么就求和算进accuracy。

for i in range(epoch):
  print("==========================第{}轮训练开始==========================".format(i+1))
  model.train()
  for data in train_dataloader:
    imgs, targets = data
    imgs=imgs.cuda()
    targets=targets.cuda()
    outputs=model(imgs)
    loss=loss_fn(outputs,targets)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    total_train_step+=1

    if total_train_step%100==0:
      end_time=time.time()
      print("训练时间:{}".format(end_time-start_time))
      print("训练次数:{},Loss:{}".format(total_train_step, loss))

  model.eval()
  total_test_loss = 0
  total_accuracy = 0
  with torch.no_grad():
    for data in test_dataloader:
      imgs, targets = data
      imgs=imgs.cuda()
      targets=targets.cuda()
      outputs=model(imgs)
      loss=loss_fn(outputs,targets)
      total_test_loss=total_test_loss+loss
      accuracy=(outputs.argmax(1)==targets).sum()
      total_accuracy+=accuracy
  print("整体测试集上的loss:{}".format(total_test_loss))
  print("整体测试集上的accuracy:{}".format(total_accuracy/test_data_size))
  total_test_step+=1
  
  if total_test_loss<min_loss:
    min_loss=total_test_loss
    torch.save(model,"model_{}".format(i))
    print("最好的模型已经保存，在第{}轮".format(i))
      

  后续会尝试用tqdm函数库来显示训练的进度条，以提升炼丹过程中的愉悦感，这套代码将网络结构换一下就可以接着用，不过整个框架还不是非常完善，还缺少单独的predict等可视化操作，还有待进一步改进！

完整的代码（有英伟达显卡的可以直接跑，没有的话要删掉.cuda()就行）

import torch
import torch.nn as nn
import torchvision
from torch.utils.data import DataLoader
import time
import torch.nn.functional as F

class DeepNet(nn.Module):
  def __init__(self, in_channels, out_channels):
    super(DeepNet, self).__init__()
    self.conv1 = nn.Conv2d(in_channels, 64, 3)
    self.conv2 = nn.Conv2d(64, 64, 3, stride=1, padding=1) 
    self.max_pooling = nn.MaxPool2d(2, stride=2, padding=1)
    self.bn = nn.BatchNorm2d(64)
    self.fc1 = nn.Linear(112*112*64, 64)
    self.fc2 = nn.Linear(64, 10)

  def forward(self, x):
    x = self.conv1(x)
    x = self.bn(x)
    x = F.relu(x)
    
    x = self.conv2(x)
    x = self.bn(x)
    x = F.relu(x)
    
    x = self.max_pooling(x)
    x = x.view(x.shape[0],-1)
    x = self.fc1(x)
    x = F.relu(x)
    x = self.fc2(x)

    return x

transform = torchvision.transforms.Compose(
    [
        torchvision.transforms.ToTensor(),  # 将数据转换为pytorch的tensor
        torchvision.transforms.Resize(size=([224, 224])), # 将图像的大小设置为224*224
        torchvision.transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]),  # 均值、方差
        torchvision.transforms.RandomHorizontalFlip()  # 随机水平翻转
    ]
)
train_data=torchvision.datasets.CIFAR10(root="dataset",train=True,transform=transform,download=True)
test_data=torchvision.datasets.CIFAR10(root="dataset",train=False,transform=transform,download=True)

train_data_size=len(train_data)
test_data_size=len(test_data)
print("训练集的长度为{}".format(train_data_size))
print("测试集的长度为{}".format(test_data_size))

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

model=DeepNet(3,10).cuda()
loss_fn=nn.CrossEntropyLoss()
loss_fn=loss_fn.cuda()

lr_rate=1e-4
optimizer=torch.optim.Adam(model.parameters(),lr=lr_rate)
total_train_step=0
total_test_step=0
epoch=10
start_time=time.time()
min_loss=100

for i in range(epoch):
  print("==========================第{}轮训练开始==========================".format(i+1))
  model.train()
  for data in train_dataloader:
    imgs, targets = data
    imgs=imgs.cuda()
    targets=targets.cuda()
    outputs=model(imgs)
    loss=loss_fn(outputs,targets)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    total_train_step+=1

    if total_train_step%100==0:
      end_time=time.time()
      print("训练时间:{}".format(end_time-start_time))
      print("训练次数:{},Loss:{}".format(total_train_step, loss))

  model.eval()
  total_test_loss = 0
  total_accuracy = 0
  with torch.no_grad():
    for data in test_dataloader:
      imgs, targets = data
      imgs=imgs.cuda()
      targets=targets.cuda()
      outputs=model(imgs)
      loss=loss_fn(outputs,targets)
      total_test_loss=total_test_loss+loss
      accuracy=(outputs.argmax(1)==targets).sum()
      total_accuracy+=accuracy
  print("整体测试集上的loss:{}".format(total_test_loss))
  print("整体测试集上的accuracy:{}".format(total_accuracy/test_data_size))
  total_test_step+=1
  
  if total_test_loss<min_loss:
    min_loss=total_test_loss
    torch.save(model,"model_{}".format(i))
    print("最好的模型已经保存，在第{}轮".format(i))