Pytorch学习笔记

学习视频:[B站up主:我是土堆]

一、help和dir指令

$pytorch$可以看作一个工作箱，里面有很多的小格子装有不同的工具。
可以使用$dir()$指令来查看这个工作箱里面有哪些分格区：

想要继续探索这个工具箱第一个分格区装了哪些工具，继续使用$dir()$指令：

想知道这个分格区的第二个工具的作用，使用$help()$指令：

二、Pytorch加载数据

• $Dataset类$：
  提供一种方式去获取数据及其label

• $Dataloader类$：
  为网络提供不同的数据形式

以图片数据为例子：

• 仅读取一张图片可以使用$PIL.Image$：

from PIL import Image
#图片路径
img_path = 'data\\train\\ants\\0013035.jpg'
#读取图片
img = Image.open(img_path)
#打印图片尺寸
print('尺寸:',img.size)
#展示图片
img.show()

• 获取多个文件，需要使用$os$：

import os
#数据所处文件夹
dir_path = 'data\\train\\ants'
#获取文件夹下文件的名字存于list数组中
img_path_list = os.listdir(dir_path)# 第一个列表元素指向文件夹第一个文件的名字

一、接下来读取一些数据(图片)，文件名为数据集的$label$：
这里有很多蚂蚁和蜜蜂的图片，蚂蚁图片的路径是$data/train/ants$,蜜蜂图片的路径是$data/train/bee$；图片上一层就是该图片集的$label$。

获取蚂蚁数据集

from PIL import Image
import os
from torch.utils.data import Dataset


class MyData(Dataset):
    '''
    需要重写Dataset的函数
    '''
    def __init__(self,root_dir,label_dir):
        '''
        初始化函数
        root_dir：根路径 如：data\\train
        label_dir：label 如：ants
        '''
        self.root_dir = root_dir
        self.label_dir = label_dir
        self.path = os.path.join(self.root_dir,self.label_dir)#文件路径:data\\train\\ants 这个函数会自动加 /
        self.img_path = os.listdir(self.path)#文件下的图片名：['img_1.jpg',img_2.jpg,……]
        
    def __getitem__(self, index):
        '''
        根据索引读取文件
        index:索引值
        '''
        img_name = self.img_path[index]#获取图片名字
        img_item_path = os.path.join(self.root_dir,self.label_dir,img_name)#拼接成指向一个图片的详细地址
        img = Image.open(img_item_path)#获取这一张图片
        label = self.label_dir#获取图片的标签
        return img,label
    
    def __len__(self):
        '''
        数据长度
        '''
        return len(self.img_path)

读取数据：

root_dir = 'data/train'
ants_label_dir = 'ants'
ants_data = MyData(root_dir,ants_label_dir)

#获取第2个数据
img,label = ants_data[1]
img.show()
print(label)#ants

展示的图片

获取蜜蜂数据集：

bees_label_dir = 'bees'
bees_data = MyData(root_dir,bees_label_dir)

#获取第2个数据
img,label = bees_data[1]
img.show()

获取训练集数据(train文件夹下的ants数据集+bees数据集)：

train_data = ants_data + bees_data#将两个数据拼接在一起
#len(ants_data)=124 ,len(bees_data)=121, len(train_data)=245

img1,label1 = train_data[1]
img1.show()
img2,label2 = train_data[124]
img2.show()

img1展示：

img2展示：

即按顺序拼接

二、读取$label$和图片分开放的数据集：
这里有很多蚂蚁和蜜蜂的图片，蚂蚁图片的路径是$data/train/ant{s}_{i}mge$,蜜蜂图片的路径是$data/train/bees\_imge$；$data/train/$下还存在两个文件夹：$ants\_label$和$bees\_label$，这两个文件夹里面放的是txt文档，文档与图片一一对应，保存图片的label。

train文件夹：

ants_image文件夹下：

ants_label文件夹下：

txt文档

在原先的MyData类上进行修改即可

from PIL import Image
import os
from torch.utils.data import Dataset

class MyData(Dataset):
    '''
    需要重写Dataset的函数
    '''
    def __init__(self,root_dir,target_dir,label_dir):
        '''
        初始化函数
        root_dir：根路径 如：data\\train
        target_dir：数据所在文件名 如：ants_image
        label_dir:标签所在文件名 如：ants_label
        '''
        self.root_dir = root_dir
        self.target_dir = target_dir
        
        self.img_path = os.path.join(self.root_dir,self.target_dir)#目标数据所在路径:data\\train\\ants_image
        self.img_name_list = os.listdir(self.img_path)#文件下的图片名：['img_1.jpg',img_2.jpg,……]
        
        self.label_path = os.path.join(self.root_dir,label_dir)#标签所在路径：data\\train\\ants_label
        #标签文件名与图片文件名只有后缀不一样，不用读取
    def __getitem__(self, index):
        '''
        根据索引读取文件
        index:索引值
        '''
        img_name = self.img_name_list[index]#获取图片名字
        img_item_path = os.path.join(self.root_dir,self.target_dir,img_name)#拼接成指向一个图片的详细地址
        img = Image.open(img_item_path)#获取这一张图片
        
        label_name = img_name.split('.')[0] + '.txt' #获取图片的标签文件名
        label_item_path = os.path.join(self.root_dir,label_dir,label_name)#拼接成指向一个图片label的详细地址
        with open(label_item_path,'r') as f:
            label = f.read()
        return img,label
    
    def __len__(self):
        '''
        数据长度
        '''
        return len(self.img_path)

读取文件：

root_dir='data\\train'
target_dir='ants_image'
label_dir='ants_label'

ants_data = MyData(root_dir,target_dir,label_dir)
img,label = ants_data[0]

三、TensorBoard的使用

$TensorBoard$作用：
记录日志信息并通过$tensorboard$可视化

1. add_scalar()的使用

from torch.utils.tensorboard import SummaryWriter

writer = SummaryWriter('logs')#写到logs文件夹下

for i in range(100):
    writer.add_scalar(tag='y=x',scalar_value=i,global_step=i)

writer.close()
'''
add_scalar(self, tag, scalar_value, global_step=None, walltime=None):
-tag:可视化图像标题
scalar_value：y轴
global_step：x轴
'''

改用端口：
在pytorch环境下输入：
tensorboard --logdir=日志文件所在绝对路径

可以看到端口号是6006
输入tensorboard --logdir=日志文件所在绝对路径 --port=6007

端口号变成6007

进入http://localhost:6007/后，可以看到绘制的图像：

2. add_image()的使用

from torch.utils.tensorboard import SummaryWriter
import numpy as np
from PIL import Image

writer = SummaryWriter('log')
#图片路径地址
image_path = './image.jpg'
#读取图片
img_PIL = Image.open(image_path)
#转换为numpy.array类型
img_array = np.array(img_PIL)
#绘制
writer.add_image('test',img_array,1,dataformats='HWC')
writer.close()

$add\_image(self,tag,img\_tensor,global\_step=None,walltime=None,dataformats{=}^{\prime }CH{W}^{\prime })$

• $img\_tensor$：$image$ $data$
  格式要求为$torch.Tensor,numpy.array,orstring/blobname$

• 默认的图片数据格式是$HWC$

进入http://localhost:6007/后，可以看到绘制的图片：

四、Transforms的使用

$torchvision$是$pytorch$的一个图形库，主要用于构建计算机视觉模型。
$torchvision.transforms$用于图形的变换。

1. Transforms中的Compose类

$Compose()$类主要作用是串联多个图片变换的操作。
如下面代码，将图片先进行中心裁剪再转为$Tensor$。

transforms.Compose([
    transforms.CenterCrop(10),
    transforms.ToTensor(),
    ])

$Compose()$内放的是一个列表，列表里的元素是想要执行的$transforms$操作。

2. Transforms中的ToTensor类

作用是将类型为$PILImage$ 或 $numpy.ndarray$ 的数据转变成 $tensor$类型。

$ToTensor$的使用：

from torchvision import transforms
from PIL import Image
from torch.utils.tensorboard import SummaryWriter

#创建tensorboard和读取PIL image
writer = SummaryWriter('logs')
img_path = './Zoro.png'
img = Image.open(img_path)

#实例化ToTensor类并进行调用
trans_totensor = transforms.ToTensor()、
#PIL格式转为tensor格式
img_tensor = trans_totensor(img)

#在tensorboard进行显示
writer.add_image('ToTensor',img_tensor)
writer.close()

结果：

转换前的$PILImage$ 或者 $numpy.ndarray$是$(H\times W\times C)$且范围在$[0,255]$，转换后的$tensor$是$(C\times H\times W)$且范围在$[0.0,1.0]$。

$Transforms$中的$ToPILImage$：
将$(C\times H\times W)$的tensor或者$(H\times W\times C)$的$numpy.ndarray$转换为$PILImage$。

3. Transforms中的Normalize类

使用均值和方差对$tensor$图片进行归一化。

对于$n$个通道，需要提供均值$mean$：$(M1,...,Mn)$和标准差$std$：$(S1,..,Sn)$，然后对每个通道进行归一化：
$output[channel]=(input[channel]-mean[channel])/std[channel]$

#归一化前
print(img_tensor[0][0][0])
trans_norm = transforms.Normalize([0.5,0.5,0.5],[0.5,0.5,0.5])
#归一化后
img_norm = trans_norm(img_tensor)
print(img_norm[0][0][0])

writer.add_image('Normalize',img_norm)

writer.close()

输出：

tensor(0.9647)
tensor(0.9294)
#(0.9647-0.5)/0.5 = 0.9294

展示结果：

4. Transforms中的Resize类

作用：将输入的$PILImage$转换为所提供的尺寸$size$。

输入和输出都是$PIL$

$size$可以是一个序列$(h,w)$；也可以是一个$int$，当只有一个数字，使用最小的边进行匹配(整体缩放，缩放后最小边的尺寸就是这个$int$)

#转换前
print(img.size)
trans_reszie = transforms.Resize((512,512))
img_resize = trans_reszie(img)
#转换后
print(img_resize.size)

输出：

#转换前
(1092, 712)
#转换后
(512, 512)

4.1 结合前面的compose

#定义transforms操作
trans_totensor = transforms.ToTensor()
trans_reszie = transforms.Resize(512)

#组合
trans_compose = transforms.Compose([trans_reszie,trans_totensor])

#上面的transforms列表中的第一个是trans_reszie，所以需要传入的类型是PIL；最后返回的结果是resize后的tensor

img_resize_totensor = trans_compose(img)

注意：
当$Compose$中的参数顺序是$[tran{s}_{t}otensor，tran{s}_{r}eszie]$，会报错。因为$trans\_reszie$的输入需要的是PIL类型，$trans\_totensor$输出是$tensor$类型

5. Transforms中的RandomCrop类

作用：对输入$PIL$图片进行随机裁剪

初始化参数：

• $size$：裁剪后的尺寸。可以是数字序列:$(h,w)$；或者是一个数字$int$，只有一个数字裁剪后是正方形的。
• pad_if_needed:是否需要进行填充
• $padding$：对图像边界进行填充的像素值。可以是数字序列:$(h,w)$、$(left,top,right,bottom)$；或者是一个数字$int$。
• $pad\_if\_needed$：是否进行填充
• $fill$：填充的数值
• $paddin{g}_{m}ode$：填充的模式。“$constant$”:利用常值进行填充；“$edge$”:利用图像边缘像素点进行填充；“$reflect$”；“$symmetric$”

tans_rcrop = transforms.RandomCrop(512)

trans_compose = transforms.Compose([tans_rcrop,trans_totensor])

img_rcrop = trans_compose(img)

writer.add_image('RandomCrop',img_rcrop,global_step=1)
writer.close()

展示结果：

6. python知识点： _ _ call_ _函数

若A类中有$\_\_call\_\_$函数，可以使用$A(参数)$调用$\_\_call\_\_$函数。

class Person:
    def __call__(self, name):
        print('call_',name)

    def hello(self,name):
        print('hello_',name)

person = Person()

#调用的是call函数，call函数的调用十分简便
person('张三')

#其他函数需要加 . 来进行调用
person.hello('李四')

输出结果:

call_ 张三
hello_ 李四

7. 总结知识点

• 关注某个$class$时，要先了解这个$class$的输入和输出。
• 多看官方文档
• 关注方法需要什么参数；如$\_\_init\_\_$函数，在初始化时可以传入什么参数
• 不知道返回值的时候，多用$print()$、$type()$、$debug$

五、torchvision中的数据集使用

1. 数据集的下载

在官方网站可以找到很多的数据集和相关模型。
下图的$PyTorch$是一个核心模块；$torchaudio$是处理语言的一个模块；$torchtext$是处理文本的一个模块；$torchvision$是处理图像的一个模块。

点击进入$torchvision$可以下载数据集或者训练好的模型和，如下图：

2. CIFAR-10 dataset的下载

可以通过$torchvision$中的$dataset$类对数据集进行下载。如我们要下载$CIFAR-10$数据集，先在官方文档查看这个类方法的解释：

• $root(string)$:数据集存放在文件夹；当$download$设置为$True$会自动下载到这个文件夹下
• $train(bool)$:是$True$则创建训练集数据，否则创建测试集。
• $transform $:对图片的操作
• $download $:是否进行下载。$True$则下载。

下载代码如下，下载到$./dataset$文件夹下，并将数据集每张($PIL$)图片转成$tensor$类型

import torchvision

dataset_transform = torchvision.transforms.Compose([
    torchvision.transforms.ToTensor()
])

#训练集
train_set = torchvision.datasets.CIFAR10(root='./dataset',transform=dataset_transform,train=True,download=True)
#测试集
test_set = torchvision.datasets.CIFAR10(root='./dataset',transform=dataset_transform,train=False,download=True)

运行结果如下，会有一个链接。这样下载速度很慢，所以建议复制链接到迅雷去下载。若运行没有出现链接，可以去到$CIFAR10$类里去$url$属性。

打印类别并获取第一个数据：

#打印数据集类别，上面返回的target就是指classes的下标，即属于那一类
print(test_set.classes)  #['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']

img,target = test_set[0]
print(test_set.classes[target])  #cat

使用tensorboard进行展示
显示前$10$张图片

from torch.utils.tensorboard import SummaryWriter

writer = SummaryWriter('p10')
for i in range(10):
    img,target = train_set[i]
    writer.add_image('CIFAR10',img,i)
writer.close()

展示结果：

2.1 CIFAR-10数据集介绍

官方介绍
这个数据集有$60000$万张$32\times 32$的彩色图片；总共有$10$个类别，每个类别都有$6000$张图片；数据集的$50000$张作为训练集，$10000$张作为测试集。

六、DataLoader的使用

1. dataset类和datalodar的关系

$dataset$负责获取数据，如获得一副扑克牌；$dataloader$负责从$dataset$中抽取数据，如怎么从一副扑克牌中抽取几张扑克。
如下图，$dataloader$负责抽取数据放入神经网络中，抓住牌的手可以看出需要获取数据的神经网络。

2.Dataloader官方介绍

官方介绍链接

参数：

• $dataset(Dataset)$:之前定义的$Dataset$，作用是提供数据集的位置、长度等信息。
• $batch\_size(int)$:每次抽取数据的大小
• $shuffle(bool)$：每个$epoch$是否打乱数据
• $num\_workers(int)$:线程数量。但在$window$环境下不太好使
• $drop\_last(bool)$:最后抽取的数据抽不成一个完整的$batch\_size$，$False$的时候会保留这些数据，$True$舍弃。

3.代码实例

import torchvision
from torch.utils.data import  DataLoader

#获取数据
import torchvision
from torch.utils.data import  DataLoader
from torch.utils.tensorboard import SummaryWriter

#获取数据
test_data = torchvision.datasets.CIFAR10(root='./dataset',transform=torchvision.transforms.ToTensor(),train=False,download=True)

#dataloder的使用
test_loader = DataLoader(dataset=test_data,batch_size=64,shuffle=True,num_workers=0,drop_last=False)

writer = SummaryWriter('dataloder')
step = 0

for data in test_loader:
    imgs,targets = data
    
	#注意是images
    writer.add_images('dataloder',imgs,step)
    step+=1

writer.close()

因为这里$batc{h}_{s}ize$=64，所以data都是$torch.Size([64,3,32,32])$。

$dataset$取出数据，$dataloader$将$dataset$中的数据每64个打包成一组。

展示结果：

七、神经网络的基本骨架-nn.Module的使用

7.1 官方文档介绍

官方nn.Module文档

$torch.nn$包含了很多的神经网络模块，其中的$Containers$(容器)表示的是神经网络的基本骨架。

如其中的$Module$，官方解释：$Baseclassforallneuralnetworkmodules.$
当我们使用$Module$时，创建的类都要继承这个类，如下面的代码：

import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module):
    def __init__(self):
    	#调用父类的初始化，必须有
        super().__init__()
        self.conv1 = nn.Conv2d(1, 20, 5)
        self.conv2 = nn.Conv2d(20, 20, 5)

	#前向传播
    def forward(self, x):
    	#x-->conv1-->relu-->conv2-->relu-->output
        x = F.relu(self.conv1(x))
        return F.relu(self.conv2(x))

7.2 代码实例

尝试一个$+1$功能的神经网络：

import torch
from torch import  nn
class Model(nn.Module):
    def __index__(self):
        super().__init__()

    def forward(self,input):
        output = input+1
        return output

model = Model()
x = torch.tensor(1.0)
output = model(x)
print(output) #tensor(2.)

八、卷积层(Convolution Layers)

$torch.nn$是$torch.nn.function$的封装。即一个现成的工具($torch.nn$)和零件($torch.nn.function$)的关系。

8.1 torch.nn.function.conv2d官方介绍

本小节讨论$2D$的卷积，即函数$conv2d$

torch.nn.functional.conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1)

参数:

• $input$:输入的维度 $(minibatch,in\_channels,iH,iW)$
• $weight$:卷积核维度 $(\text{out\_channels},\frac{\text{in\_channels}}{\text{groups}},kH,kW)$
• $stride$:滑动的步数。一个数字或者一个数字序列$(sH,sW)$
• $padding$:填充。可以是字符串{$‘valid’$, $‘same’$},或者是一个数字，或者是数字序列$(padH,padW)$

8.2 代码实例

本小节将实现下面的卷积操作

代码：

import torch
import torch.nn.functional  as F

input = torch.tensor([[1,2,0,3,1],
                      [0,1,2,3,1],
                      [1,2,1,0,0],
                      [5,2,3,1,1],
                      [2,1,0,1,1]])

kernel = torch.tensor([[1,2,1],
                       [0,1,0],
                       [2,1,0]])

input = torch.reshape(input,(1,1,5,5))#(1,1,5,5) -- (样本数，通道数，w，h)
kernel = torch.reshape(kernel,(1,1,3,3))#(1,1,3,3) -- (卷积核数目，通道数，w，h)

output = F.conv2d(input,kernel,stride=1)
print(output)

输出结果：

tensor([[[[10, 12, 12],
          [18, 16, 16],
          [13,  9,  3]]]])

8.3 torch.nn.Conv2d官方介绍

官方介绍

参数：

• $in\_channels(int)$：输入图像的通道数
• $out\_channels(int)$：输出图像的通道数
• $kernel\_size(intortuple)$：卷积核尺寸
• $stride(intortuple)$：滑动步数
• $padding(int,tupleorstr)$：填充方式
• $bias(bool)$：是否为输出结果添加偏置
• $dilation(intortuple)$:间隔空隙。如下图中的卷积核覆盖是间隔着距离的
  

输入维度与输出维度：

• $Input:(N,C_{in},H_{in},W_{in})or(C_{in},H_{in},W_{in})$
• $Output:(N,C_{out},H_{out},W_{out})or(C_{out},H_{out},W_{out})$

8.4 代码实例

import torch
from torch import nn
from torch.utils.tensorboard import SummaryWriter
from torch.utils.data import DataLoader
import torchvision

#获取数据
dataset = torchvision.datasets.CIFAR10('.\dataset',transform=torchvision.transforms.ToTensor(),train=False,download=True)

#抽取数据
dataloder = DataLoader(dataset=dataset,batch_size=64)

#定义卷积模型  x-->conv2d-->output
class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv2d = nn.Conv2d(in_channels=3,out_channels=6,kernel_size=3,stride=1,padding=0)

    def forward(self,x):
        output = self.conv2d(x)
        return output

#模型实例化
model = Model()

#使用tensorboard进行可视化
writer = SummaryWriter('./logs')
step = 0

#遍历数据集
for data in dataloder:
    
    imgs,targets = data

    #输入前[64,3,32,32]
    writer.add_images('input',imgs,step)
    
    #放入模型
    outputs = model(imgs)

    #输入后[64,6,30,30]  转换成[……,3,30,30]才能可视化
    outputs = torch.reshape(outputs,(-1,3,30,30))
    writer.add_images('output', outputs, step)

    step += 1

writer.close()

展示结果：

九、最大池化的使用

最大池化目的：
保留最大特征同时减小输入维度。

9.1 MaxPool2d官方介绍

参数：

• $kernel\_size$：窗口大小
• $stride$：窗口移动步幅。默认值是$kernel\_size$
• $padding$:填充数值
• $ceil\_mode$：如下图所示，区别在于池化核移动到边缘时，不能完全覆盖输入，是否依然要输出其最大值。$True$则输出，$False$不输出。
  

9.2 代码实例

我们要尝试下图的池化计算(注意$kernel\_size=3$，$stride$也默认为$3$)

import torch
from torch import nn

input = torch.tensor([[1,2,0,3,1],
                      [0,1,2,3,1],
                      [1,2,1,0,0],
                      [5,2,3,1,1],
                      [2,1,0,1,1]],dtype=torch.float32)

input = torch.reshape(input,(1,1,5,5))#(1,1,5,5) -- (样本数，通道数，w，h)

class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.maxpool1 = nn.MaxPool2d(kernel_size=3,ceil_mode=True)

    def forward(self,x):
        output = self.maxpool1(x)
        return output

model = Model()
output = model(input)
print(output)
'''tensor([[[[2., 3.],
          [5., 1.]]]])'''

9.3 最大池化的直观感受

我们对CIFAR10数据集的测试集进行最大池化并可视化结果：

import torchvision
from torch import nn
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter

dataset = torchvision.datasets.CIFAR10('./dataset',train=False,transform=torchvision.transforms.ToTensor(),download=True)

dataloder = DataLoader(dataset,batch_size=64)

class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.maxpool1 = nn.MaxPool2d(kernel_size=3,ceil_mode=True)

    def forward(self,x):
        output = self.maxpool1(x)
        return output

model = Model()

writer = SummaryWriter('logs')
step = 0

for data in dataloder:
    imgs,targets = data

    writer.add_images('input',imgs,step)
    output = model(imgs)
    writer.add_images('output',output,step)

    step+=1

writer.close()

展示结果：
原始输入

池化后输出：

输出的结果变模糊了，有点类似视频的画质。保留图像的大部分特征并缩小图像维度。

十、非线性激活

非线性函数的目的是为了给网络引入一些非线性特折，非线性特征足够多才能够拟合出符合各种曲线线(各种特征)的模型。

10.1 线性激活官方介绍

官方文档
以$ReLU$为例子

class
torch.nn.ReLU(inplace=False)

参数：

• $inplace$：是否替换输入。
  如$ReLU(input,inplace=True)$，这里的$input$的值会随着函数的使用而改变，可以不用变量接收返回值。

数学公式：
$ReLU(x)=(x)+=max(0,x)$

输入输出维度：

图像：

10.2 代码实例

import torch
from torch import nn

input = torch.tensor([[1,-0.5],
                      [-3,2]])

input = torch.reshape(input,(1,1,2,2))#(1,1,2,2) -- (样本数，通道数，w，h)

class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.relu1 = nn.ReLU()

    def forward(self,x):
        output = self.relu1(x)
        return output

model = Model()
output = model(input)
print(output)
'''
tensor([[[[1., 0.],
          [0., 2.]]]])
'''

十一、线性层介绍

官方链接
$LINEAR$为例子

class
torch.nn.Linear(in_features, out_features, bias=True, device=None, dtype=None)

参数：

• $in\_features$：输入特征数(前一层节点数)
• $out\_features$：输出特征数(当前层节点数)
• $bias$：是否添加偏置

$linear$就是计算$y=x{A}^T+b$

经典的$LR$算法的结构就是：$x->linnear->Softmax->output$，即线性层的输出一般作为激活函数的输入。

十二、搭建CIFAR-10网络模型

神经网络结构示意图如下：

12.1 不使用Sequential

import torch
from torch import nn
from torch.nn import Conv2d,MaxPool2d,Linear
from torch.nn.modules.flatten import Flatten


class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = Conv2d(3,32,5,padding=2)
        self.maxpool1 = MaxPool2d(2)
        self.conv2 = Conv2d(32, 32, 5, padding=2)
        self.maxpool2 = MaxPool2d(2)
        self.conv3 = Conv2d(32, 64, 5, padding=2)
        self.maxpool3 = MaxPool2d(2)
        self.faltten = Flatten()
        self.linear1 = Linear(1024,64)
        self.linear2 = Linear(64,10)

    def forward(self,x):
        x = self.conv1(x)
        x = self.maxpool1(x)
        x = self.conv2(x)
        x = self.maxpool2(x)
        x = self.conv3(x)
        x = self.maxpool3(x)
        x= self.faltten(x)
        x = self.linear1(x)
        x = self.linear2(x)
        return x

model = Model()

#检测网络输出
input = torch.ones([64,3,32,32])
output = model(input)
print(output.shape)#torch.Size([64, 10])

要点：

• 对于$padding、stride$的确定可以使用公式进行计算
• $Flatten()$的引用在$torch.nn.modules.flatten$。【本人是$\mathrm{1.4.1}$版本的$pytorch$】
• 如果不知道下一层的应该使用什么维度的卷积层，可以在$forward$里面截断输出上一层的维度。
  例如：不知道第一层$FC$输入是多少，可以在$forward$里面就前向传播到$faltten$，查看它的输出维度就知道第一层$FC$输入应该是$1024$了。

12.2 使用Sequential

$Sequential$使代码更简洁和有序，代码如下：

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


class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.model1 = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )


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

model = Model()

#检测网络输出
input = torch.ones([64,3,32,32])
output = model(input)
print(output.shape)##torch.Size([64, 10])

12.3 模型的可视化

from torch.utils.tensorboard import SummaryWriter

writer = SummaryWriter('./logs')
writer.add_graph(model,input)
writer.close()

展示结构如下，双击查看详细结构

十三、损失函数与反向传播

$Loss$的作用：

1. 计算实际输出与目标之间的差距
2. 为更新输出提供一定的依据(反向传播)

13.1 官方文档介绍

文档链接

13.1.1 L1Loss

torch.nn.L1Loss(size_average=None, reduce=None, reduction='mean')

$\ell (x,y)=L=\{l_1,\dots ,l_N\}{}^{\top },l_n=\mid x_n-y_n\mid$

13.1.2 MSELoss

平方差

class
torch.nn.MSELoss(size_average=None, reduce=None, reduction='mean')

$\ell (x,y)=L=\{l_1,\dots ,l_N\}{}^{\top },l_n=(x_n-y_n{)}^2$

13.1.3 CrossEntropyLoss

一般用于多分类问题，$C$表示分类个数

class
torch.nn.CrossEntropyLoss(weight=None, size_average=None, ignore_index=-100, reduce=None, reduction='mean')

• $x$表示预测结果(多分类问题预测结果是数组)
• $class$表示真实的分类
• $j$的范围为$[0,(C-1)]$

13.2 为CIFAR-10网络模型添加损失函数

#获取数据
dataset = torchvision.datasets.CIFAR10('.\dataset',transform=torchvision.transforms.ToTensor(),train=False,download=True)

#抽取数据
dataloder = DataLoader(dataset=dataset,batch_size=64)

#定义模型
model = Model()
#定义损失函数
loss = nn.CrossEntropyLoss()

#一个mini_batch计算一次损失函数
for data in dataloder:
    imgs,targets = data
    output = model(imgs)
    res_loss = loss(output,targets)#损失函数值=loss(预测值,真实值)
    print(res_loss)

输出结果：

Files already downloaded and verified
tensor(2.3027, grad_fn=<NllLossBackward>)
tensor(2.3200, grad_fn=<NllLossBackward>)
tensor(2.2939, grad_fn=<NllLossBackward>)
tensor(2.3089, grad_fn=<NllLossBackward>)
tensor(2.3268, grad_fn=<NllLossBackward>)
…………不展示全部输出

添加反向传播：

#一个mini_batch计算一次损失函数
for data in dataloder:
    imgs,targets = data
    output = model(imgs)
    res_loss = loss(output,targets)#损失函数值=loss(预测值,真实值)
    #反向传播
    res_loss.backward()

在运行$res\_loss.backward()$之前，$model$里面的梯度$grad$是$None$的，如下图：

在运行之后，梯度$gard$就被附上了值，如下图：

之后采取优化算法使用这些值来优化模型。

十四、优化器

14.1 官方文档介绍

官方介绍
使用流程：

1. $Constructingit$(构建它)：

optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

参数：
$model.parameters()$：模型参数
$lr$:学习率

2. $Takinganoptimizationstep$(进行优化步骤)：

for input, target in dataset:
    optimizer.zero_grad()#梯度归0
    output = model(input)
    loss = loss_fn(output, target)
    loss.backward()#计算梯度
    optimizer.step()#优化

14.2 为CIFAR-10网络模型添加优化器

如下面代码，在之前的基础上添加了外层$epoch$迭代，一次迭代遍历一数据集。

优化器的添加要保证这三个的前后次序：
$(1)grad清零-->(2)反向传播计算grad-->(3)优化算法根据grad执行梯度下降$

#获取数据
dataset = torchvision.datasets.CIFAR10('.\dataset',transform=torchvision.transforms.ToTensor(),train=False,download=True)

#抽取数据
dataloder = DataLoader(dataset=dataset,batch_size=64)

#定义模型
model = Model()
#定义损失函数
loss = nn.CrossEntropyLoss()

#优化器
optim = torch.optim.SGD(model.parameters(),lr=0.01)
for epoch in range(20):
    running_loss = 0.0
    for data in dataloder:
        optim.zero_grad()  # grad清零
        imgs, targets = data
        output = model(imgs)
        res_loss = loss(output, targets)  # 损失函数值=loss(预测值,真实值)
        res_loss.backward()  # 反向传播计算grad
        optim.step()  # 优化算法进行梯度下降
        running_loss += res_loss

十五、官网模型的加载(浅谈)

15.1 官网介绍

以$VGG16$为例子：

vgg = torchvision.models.vgg16(pretrained=False, progress=True, **kwargs)

• $pretrained$:是否下载权重进行预训练
  当为$True$时，加载模型过程中会下载官网训练好的权重
• $progress$:是否显示进度条

这个模型使用的$ImageNet$数据集很大，官网不提供下载，可以去浏览器搜索资源下载。

在官网查看模型函数介绍时，要选择正确的$torchvision$版本，不同版本函数之间存在一定的差异。

15.2 模型的使用与修改

下图是$VGG16$的结构图，最后一层的输出维度是$1000$，是一个多分类问题。

如何修改$VGG16$应用到$CIFAR-10$这个数据集上呢？

• 添加新的输出层，可以添加一个输出维度为$10$的$FC$层

import torchvision
from torch.nn import Linear

vgg16 = torchvision.models.vgg16(pretrained=False,progress=True)

vgg16.add_module('add_linear',Linear(1000,10))

print(vgg16)

输出结果：
看下图红框，网络结构的最后一层成功的添加了一层全连接层。

若想把这个$FC$层添加到$classifier$中去，将

vgg16.add_module('add_linear',Linear(1000,10))

• 对原有输出层进行替换

vgg16.classifier[6]=Linear(4096,10)

十六、网络模型的保存与读取

第一种方式：
保存模型结构和参数

vgg16 = torchvision.models.vgg16(pretrained=False,progress=True)

#保存方式一
torch.save(vgg16,'vgg16_method1.pth')#(模型,文件名)
#会在文件夹下生成一个vgg16_method1.pth文件，包含模型结构和参数权重

#读取方式一
model = torch.load('vgg16_method1.pth')

第一种方式在保存和读取自己定义的模型时，会有陷阱：
在读取模型时会报错，所以需要把模型$class$定义复制到读取的那个$.py$文件中。也可以从定义模型$class$的那个类$import$进来。

第二种方式：
保存模型参数(官方推荐)

#保存方式二
torch.save(vgg16.state_dict(),'vgg16_method2.pth')#(模型的状态字典,文件名)
#状态字典中保存了模型的参数权重，不包含网络结构

#读取方式二
vgg16 = torchvision.models.vgg16(pretrained=False,progress=True)#重建网络结构
vgg16.load_state_dict(torch.load('vgg16_method2.pth'))#加载参数字典

十七、完整的模型训练套路

一、加载数据集

#加载数据集
train_data = torchvision.datasets.CIFAR10('./dataset',train=True,transform=torchvision.transforms.ToTensor(),download=True)
test_data = torchvision.datasets.CIFAR10('./dataset',train=False,transform=torchvision.transforms.ToTensor(),download=True)

train_data_len = len(train_data)
test_data_len = len(test_data)

#打印数据长度
print("训练集数据长度{}".format(train_data_len))
print("训练集数据长度{}".format(test_data_len))

#抽取数据
train_loader = DataLoader(train_data,batch_size=64)
test_loader = DataLoader(test_data,batch_size=64)

二、搭建网络模型与测试

这个网络模型的搭建可以在一个新py文件中定义，需要时从这个$py$文件$import$即可

#搭建模型
class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

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

#测试模型输出维度
if __name__ == '__main__':
    model = Model()
    input = torch.ones((64,3,32,32))
    output = model(input)
    print(output.shape)

三、定义网络模型、损失函数、优化器与tensorboard的可视化

#创建网络模型
model = Model()

#添加tensorboard
writer = SummaryWriter('./logs')

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

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

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

for epoch in range(epochs):
    print("----第{}轮训练开始----".format(epoch+1))
    for data in train_loader:
        imgs,targets = data
        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:
            print("训练次数{},Loss:{}".format(total_train_step,loss.item()))
            writer.add_scalar("train_loss",loss,total_train_step)

    #测试集步骤开始
    total_test_loss = 0
    total_accuracy = 0
    
    with torch.no_grad():#确保不进行优化，仅测试
        for data in test_loader:
            imgs,targets = data
            outputs = model(imgs)
            loss = loss_fn(outputs,targets)
            total_test_loss += loss.item()
            #正确率计算
            accuracy = (outputs.argmax(1)==targets).sum()
            total_accuracy += accuracy
    print("测试集整体上的正确率:{}".format(total_accuracy/test_data_len))
    print("测试集整体上的Loss:{}".format(total_test_loss))
    writer.add_scalar("test_loss", total_test_loss, total_test_step)
    writer.add_scalar("test_accuracy", total_accuracy/test_data_len, total_test_step)
    total_test_step +=1
    
    #模型保存
    #torch.save(model,"model_{}.pth".format(epoch))
writer.close()

完整代码
$train.py$:

from torch.utils.data import DataLoader
import torchvision
from torch.utils.tensorboard import SummaryWriter

from model import *

#加载数据集
train_data = torchvision.datasets.CIFAR10('./dataset',train=True,transform=torchvision.transforms.ToTensor(),download=True)
test_data = torchvision.datasets.CIFAR10('./dataset',train=False,transform=torchvision.transforms.ToTensor(),download=True)

train_data_len = len(train_data)
test_data_len = len(test_data)

#打印数据长度
print("训练集数据长度{}".format(train_data_len))
print("训练集数据长度{}".format(test_data_len))

#抽取数据
train_loader = DataLoader(train_data,batch_size=64)
test_loader = DataLoader(test_data,batch_size=64)

#创建网络模型
model = Model()

#添加tensorboard
writer = SummaryWriter('./logs')

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

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

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

for epoch in range(epochs):
    print("----第{}轮训练开始----".format(epoch+1))
    for data in train_loader:
        imgs,targets = data
        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:
            print("训练次数{},Loss:{}".format(total_train_step,loss.item()))
            writer.add_scalar("train_loss",loss,total_train_step)

    #测试集步骤开始
    total_test_loss = 0
    total_accuracy = 0
    #确保不进行优化，仅测试
    with torch.no_grad():
        for data in test_loader:
            imgs,targets = data
            outputs = model(imgs)
            loss = loss_fn(outputs,targets)
            total_test_loss += loss.item()
            accuracy = (outputs.argmax(1)==targets).sum()
            total_accuracy += accuracy.item()
    print("测试集整体上的正确率:{}".format(total_accuracy/test_data_len))
    print("测试集整体上的Loss:{}".format(total_test_loss))
    writer.add_scalar("test_loss", total_test_loss, total_test_step)
    writer.add_scalar("test_accuracy", total_accuracy/test_data_len, total_test_step)
    total_test_step +=1

    #模型保存
    #torch.save(model,"model_{}.pth".format(epoch))
writer.close()

$model.py$

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

#搭建模型
class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.model = Sequential(
            Conv2d(3, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10)
        )

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

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

展示结果(没有训练完，太耗时间了，下节使用GPU加速会快很多)：

注意：

• 关于$train(mode=True)$和$eval()$:
  $train()$表示开启训练，后续代码是进行训练集训练的。
  $eval()$表示开启测试，后续代码是进行验证集训练的。
  但大部分情况下可以不用添加这两行代码，除非使用了$Dropout,BatchNorm$

• 当数字和$tensor$进行计算时，要使用$tensor.item$进行计算

十八、使用CPU训练

18.1 第一种方式

在网络模型、数据(输入、标注)、损失函数处加上$.cuda()$

if torch.cuda.is_available()是为了在gpu和cpu环境下都能跑。

• 第一处：网络模型
  

• 第二处：数据(输入、标注)
  
  

• 第三处：损失函数处
  

使用GPU训练速度快了好多。
10个轮次的训练，测试集正确率能达到53%

如果电脑上没有不能使用GPU加速，可以使用国外的$Googlecolab$或者国内的天池实验室来代跑我们的代码。

18.2 第二种方式

使用$.to(divice)$

• 先在开头定义训练的设备：
  
  为了确保不能$GPU$加速的情况下代码也能使用，可以替换成下面的代码：

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

• 第一处：网络模型
  可以不用赋值
  

• 第二处：数据(输入、标注)
  可以不用赋值
  
  

• 第三处：损失函数处
  

18.3 测试时注意事项

• 使用GPU加速训练的模型，在预测新数据时，要将数据进行转换,如$img=img.cuda()$。

• $png$格式是四个通道，除了RGB三通道外，还有一个透明的通道。因此应该使用$image=image.convert{(}^{\prime }RG{B}^{\prime })$保留颜色通道。

• 加载训练好的模型时，若$map\_location$报错，应添加$map\_location=torch.device{(}^{\prime }cp{u}^{\prime })$【cpu或cuda】

model = torch.load("model_gpu.pth",map_location=torch.device('cpu'))