第三章 pytorch的主要组成模块

深度学习的必要部分

回顾机器学习任务的步骤：首先需要对数据进行预处理，其中重要的步骤包括数据格式的统一和必要的数据变换，同时划分训练集和测试集。接下来选择模型，并设定损失函数和优化方法，以及对应的超参数（当然可以使用sklearn这样的机器学习库中模型自带的损失函数和优化器）。最后用模型去拟合训练集数据，并在验证集/测试集上计算模型表现。

• 深度学习和机器学习在流程上类似，但在代码实现上有较大的差异。首先，由于深度学习所需的样本量很大，一次加载全部数据运行可能会超出内存容量而无法实现；同时还有批（batch）训练等提高模型表现的策略，需要每次训练读取固定数量的样本送入模型中训练，因此深度学习在数据加载上需要有专门的设计。
• 在模型方面，由于深度学习网络层数往往较多，同时会有一些用于实现特定功能的层（比如卷积层池化层等，因此深度神经网络往往需要“逐层”搭建，或者预先定义好可以实现特定功能的模块，再把这些模块组装起来。这种“定制化”的模型构建方式能够充分保证模型的灵活性，也对代码实现提出了新的要求。接下里就是设定损失函数和优化器，要保证反向传播能够在用户自行定义的模型结构上实现。经过了上述的步骤后，就可以开始训练了，GPU训练还是CPU训练。
• 深度学习中训练和验证过程最大的特点在于读入数据是按批的，每次读入一个批次的数据，放入GPU中训练，然后将损失函数反向传播回网络最前面的层，同时使用优化器调整网络参数。这里会涉及到各个模块配合的问题。训练/验证后还需要根据设定好的指标计算模型表现。

一个pytorch项目的基本配置

• 首先导入包，比如一些常见的包，os、numpy等；但可以设置几个超参数，比如batch size，初始学习率，训练次数（max_epochs),GPU配置。

数据的读入

PyTorch数据读入是通过Dataset+DataLoader的方式完成的，Dataset定义好数据的格式和数据变换形式，DataLoader用iterative的方式不断读入批次数据。
我们可以定义自己的Dataset类来实现灵活的数据读取，定义的类需要继承PyTorch自身的Dataset类。主要包含三个函数：

• init: 用于向类中传入外部参数，同时定义样本集
• getitem: 用于逐个读取样本集合中的元素，可以进行一定的变换，并将返回训练/验证所需的数据
• len: 用于返回数据集的样本数

以cifar10数据集为例给出构建Dataset类的方式：

import torch
from torchvision import datasets
train_data = datasets.ImageFolder(train_path, transform=data_transform)
val_data = datasets.ImageFolder(val_path, transform=data_transform)

这里使用了PyTorch自带的ImageFolder类的用于读取按一定结构存储的图片数据（path对应图片存放的目录，目录下包含若干子目录，每个子目录对应属于同一个类的图片。其中“data_transform”可以对图像进行一定的变换，如翻转、裁剪等操作，可自己定义。
另一个例子，其中图片存放在一个文件夹，另外有一个csv文件给出了图片名称对应的标签。这种情况下需要自己来定义Dataset类：

class MyDataset(Dataset): # 继承pytorch自身的Dataset类
    def __init__(self, data_dir, info_csv, image_list, transform=None):
        """
        Args:
            data_dir: path to image directory.
            info_csv: path to the csv file containing image indexes
                with corresponding labels.
            image_list: path to the txt file contains image names to training/validation set
            transform: optional transform to be applied on a sample.
        """
        label_info = pd.read_csv(info_csv)
        image_file = open(image_list).readlines()
        self.data_dir = data_dir
        self.image_file = image_file
        self.label_info = label_info
        self.transform = transform

    def __getitem__(self, index):
        """
        Args:
            index: the index of item
        Returns:
            image and its labels
        """
        image_name = self.image_file[index].strip('\n')
        raw_label = self.label_info.loc[self.label_info['Image_index'] == image_name]
        label = raw_label.iloc[:,0]
        image_name = os.path.join(self.data_dir, image_name)
        image = Image.open(image_name).convert('RGB')
        if self.transform is not None:
            image = self.transform(image)
        return image, label

    def __len__(self):
        return len(self.image_file)

构建好Dataset后，可以使用DataLoader来按批次读入数据了，实现如下：

rom torch.utils.data import DataLoader

train_loader = torch.utils.data.DataLoader(train_data, batch_size=batch_size, num_workers=4, shuffle=True, drop_last=True)
val_loader = torch.utils.data.DataLoader(val_data, batch_size=batch_size, num_workers=4, shuffle=False)

其中，

• batch_size：样本是按“批”读入的，batch_size就是每次读入的样本数
• num_workers：有多少个进程用于读取数据
• shuffle：是否将读入的数据打乱
• drop_last：对于样本最后一部分没有达到批次数的样本，使其不再参与训练。

模型的构建

PyTorch中神经网络构造一般是基于 Module 类的模型来完成的，它让模型构造更加灵活。

神经网络的构造

Module 类是 nn 模块里提供的一个模型构造类，是所有神经⽹网络模块的基类，我们可以继承它来定义我们想要的模型。下面继承 Module 类构造多层感知机。这里定义的 MLP 类重载了 Module 类的 init 函数和 forward 函数。它们分别用于创建模型参数和定义前向计算。前向计算也即正向传播。

import torch
from torch import nn

class MLP(nn.Module):
  # 声明带有模型参数的层，这里声明了两个全连接层
  def __init__(self, **kwargs):
    # 调用MLP父类Block的构造函数来进行必要的初始化。这样在构造实例时还可以指定其他函数
    super(MLP, self).__init__(**kwargs)
    self.hidden = nn.Linear(784, 256)
    self.act = nn.ReLU()
    self.output = nn.Linear(256,10)
    
   # 定义模型的前向计算，即如何根据输入x计算返回所需要的模型输出
  def forward(self, x):
    o = self.act(self.hidden(x))在这里插入代码片
    return self.output(o)

看不懂

神经网络中常见的层

1. 不含模型参数的层
   我们先介绍如何定义一个不含模型参数的自定义层。下⾯构造的 MyLayer 类通过继承 Module 类自定义了一个将输入减掉均值后输出的层，并将层的计算定义在了 forward 函数里。这个层里不含模型参数。

import torch
from torch import nn

class MyLayer(nn.Module):
    def __init__(self, **kwargs):
        super(MyLayer, self).__init__(**kwargs)
    def forward(self, x):
        return x - x.mean() 

测试，实例化该层，然后做前向计算

layer = MyLayer()
layer(torch.tensor([1, 2, 3, 4, 5], dtype=torch.float))

tensor([-2., -1.,  0.,  1.,  2.])

2. 含模型参数的层

常见的神经网络的一些层：

1. 二维卷积层
   二维卷积层将输入和卷积核做互相关运算，并加上一个标量偏差来得到输出。卷积层的模型参数包括了卷积核和标量偏差。在训练模型的时候，通常我们先对卷积核随机初始化，然后不断迭代卷积核和偏差。

import torch
from torch import nn

# 卷积运算（二维互相关）
def corr2d(X, K): 
    h, w = K.shape
    X, K = X.float(), K.float()
    Y = torch.zeros((X.shape[0] - h + 1, X.shape[1] - w + 1))
    for i in range(Y.shape[0]):
        for j in range(Y.shape[1]):
            Y[i, j] = (X[i: i + h, j: j + w] * K).sum()
    return Y

# 二维卷积层
class Conv2D(nn.Module):
    def __init__(self, kernel_size):
        super(Conv2D, self).__init__()
        self.weight = nn.Parameter(torch.randn(kernel_size))
        self.bias = nn.Parameter(torch.randn(1))

    def forward(self, x):
        return corr2d(x, self.weight) + self.bias

池化层：
池化层每次对输入数据的一个固定形状窗口(⼜称池化窗口)中的元素计算输出。不同于卷积层里计算输⼊和核的互相关性，池化层直接计算池化窗口内元素的最大值或者平均值。该运算也 分别叫做最大池化或平均池化。在二维最⼤池化中，池化窗口从输入数组的最左上方开始，按从左往右、从上往下的顺序，依次在输⼊数组上滑动。当池化窗口滑动到某⼀位置时，窗口中的输入子数组的最大值即输出数组中相应位置的元素。
下面把池化层的前向计算实现在pool2d函数里。

import torch
from torch import nn

def pool2d(X, pool_size, mode='max'):
    p_h, p_w = pool_size # 分别是池化层窗口的高和宽
    Y = torch.zeros((X.shape[0] - p_h + 1, X.shape[1] - p_w + 1)) # 输出Y的维度为（X.shape[0] - p_h + 1, X.shape[1] - p_w + 1)
    for i in range(Y.shape[0]):
        for j in range(Y.shape[1]):
            if mode == 'max':
                Y[i, j] = X[i: i + p_h, j: j + p_w].max()
            elif mode == 'avg':
                Y[i, j] = X[i: i + p_h, j: j + p_w].mean()
    return Y
X = torch.tensor([[0, 1, 2], [3, 4, 5], [6, 7, 8]], dtype=torch.float)
pool2d(X, (2, 2))

tensor([[4., 5.],
	[7., 8.]])  # 按照默认的最大池化计算

pool2d(X, (2, 2), 'avg')

tensor([[2., 3.],
	[5., 6.]])

模型示例

一个神经网络的典型训练过程如下：

1. 定义包含一些可学习参数(或者叫权重）的神经网络
2. 在输入数据集上迭代
3. 通过网络处理输出
4. 计算 loss (输出和正确答案的距离）
5. 将梯度反向传播给网络的参数
6. 更新网络的权重，一般使用一个简单的规则：weight = weight - learning_rate * gradient

模型初始化

在深度学习模型的训练中，权重的初始值极为重要。一个好的权重值，会使模型收敛速度提高，使模型准确率更精确。为了利于训练和减少收敛时间，我们需要对模型进行合理的初始化。PyTorch也在torch.nn.init中为我们提供了常用的初始化方法。

通过访问torch.nn.init的官方文档链接，torch.nn.init提供了以下初始化方法：

1. torch.nn.init.uniform_(tensor, a=0.0, b=1.0)
2. torch.nn.init.normal_(tensor, mean=0.0, std=1.0)
3. torch.nn.init.constant_(tensor, val)
4. torch.nn.init.ones_(tensor)
5. torch.nn.init.zeros_(tensor)
6. torch.nn.init.eye_(tensor)
7. torch.nn.init.dirac_(tensor, groups=1)
8. torch.nn.init.xavier_uniform_(tensor, gain=1.0)
9. torch.nn.init.xavier_normal_(tensor, gain=1.0)
10. torch.nn.init.kaiming_uniform_(tensor, a=0, mode=‘fan__in’, nonlinearity=‘leaky_relu’)
11. torch.nn.init.kaiming_normal_(tensor, a=0, mode=‘fan_in’, nonlinearity=‘leaky_relu’)
12. torch.nn.init.orthogonal_(tensor, gain=1)
13. torch.nn.init.sparse_(tensor, sparsity, std=0.01)
14. torch.nn.init.calculate_gain(nonlinearity, param=None)
    我们可以发现这些函数除了calculate_gain，所有函数的后缀都带有下划线，意味着这些函数将会直接原地更改输入张量的值。
    怎么使用torch.nn.init:
15. 我们通常会根据实际模型来使用torch.nn.init进行初始化，通常使用isinstance来进行判断模块（回顾3.4模型构建）属于什么类型。
16. 对于不同的类型层，我们就可以设置不同的权值初始化的方法。

初始化函数的封装

人们常常将各种初始化方法定义为一个initialize_weights()的函数并在模型初始后进行使用。
通过判断模型的每一层属于什么样的类型，给不同的类型层设定不同的权重初始化方法。

损失函数

1. 损失函数：它是数据输入到模型当中，产生的结果与真实标签的评价指标，我们的模型可以按照损失函数的目标来做出改进。
2. 通过torch.nn来调用pytorch中 常用的损失函数。

pytorch中常见的损失函数

1. 二分类交叉熵损失函数

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

功能：计算二分类任务时的交叉熵（Cross Entropy）函数。在二分类中，label是{0,1}。对于进入交叉熵函数的input为概率分布的形式。一般来说，input为sigmoid激活层的输出，或者softmax的输出。
主要参数：

weight:每个类别的loss设置权值

size_average:数据为bool，为True时，返回的loss为平均值；为False时，返回的各样本的loss之和。

reduce:数据类型为bool，为True时，loss的返回是标量。

2. 交叉熵损失函数

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

weight:每个类别的loss设置权值。

size_average:数据为bool，为True时，返回的loss为平均值；为False时，返回的各样本的loss之和。

ignore_index:忽略某个类的损失函数。

reduce:数据类型为bool，为True时，loss的返回是标量。

3. L1损失函数

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

功能： 计算输出y和真实标签target之间的差值的绝对值。
我们需要知道的是，reduction参数决定了计算模式。有三种计算模式可选：none：逐个元素计算。 sum：所有元素求和，返回标量。 mean：加权平均，返回标量。 如果选择none，那么返回的结果是和输入元素相同尺寸的。默认计算方式是求平均。

4. MSE损失函数

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

功能： 计算输出y和真实标签target之差的平方。
和L1Loss一样，MSELoss损失函数中，reduction参数决定了计算模式。有三种计算模式可选：none：逐个元素计算。 sum：所有元素求和，返回标量。默认计算方式是求平均。

5. 平滑L1 (Smooth L1)损失函数

torch.nn.SmoothL1Loss(size_average=None, reduce=None, reduction='mean', beta=1.0)

功能： L1的平滑输出，其功能是减轻离群点带来的影响。

6. 目标泊松分布的负对数似然损失

torch.nn.PoissonNLLLoss(log_input=True, full=False, size_average=None, eps=1e-08, reduce=None, reduction='mean')

功能： 泊松分布的负对数似然损失函数。
log_input：输入是否为对数形式，决定计算公式。

full：计算所有 loss，默认为 False。

eps：修正项，避免 input 为 0 时，log(input) 为 nan 的情况。

7. KL散度

torch.nn.KLDivLoss(size_average=None, reduce=None, reduction='mean', log_target=False)

功能： 计算KL散度，也就是计算相对熵。用于连续分布的距离度量，并且对离散采用的连续输出空间分布进行回归通常很有用。

8. MarginRankingLoss：功能： 计算两个向量之间的相似度，用于排序任务。该方法用于计算两组数据之间的差异。
9. 多标签边界损失函数：功能： 对于多标签分类问题计算损失函数。
10. 二分类损失函数： 计算二分类的 logistic 损失
11. 多分类的折页损失：功能： 计算多分类的折页损失
12. 三元组损失：功能： 计算三元组损失
13. HingEmbeddingLoss: 功能： 对输出的embedding结果做Hing损失计算
14. 余弦相似度: 功能： 对两个向量做余弦相似度
15. CTC损失函数: 功能： 用于解决时序类数据的分类

训练和评估

经过基本配置、数据的读入、模型的构建、模型的初始化、损失函数的设定等这些步骤完成后，我们就可以加载数据开始训练模型了，首先应该设置模型的状态：如果是训练状态，那么模型的参数应该支持反向传播的修改；如果是验证/测试状态，则不应该修改模型参数。
在PyTorch中，模型的状态设置非常简便，如下的两个操作二选一即可：

model.train()   # 训练状态
model.eval()   # 验证/测试状态

验证/测试的流程基本与训练过程一致，不同点在于：

• 需要预先设置torch.no_grad，以及将model调至eval模式
• 不需要将优化器的梯度置零
• 不需要将loss反向回传到网络
• 不需要更新optimizer

可视化

在PyTorch深度学习中，可视化是一个可选项，指的是某些任务在训练完成后，需要对一些必要的内容进行可视化，比如分类的ROC曲线，卷积网络中的卷积核，以及训练/验证过程的损失函数曲线等等。

pytorch优化器

优化器是根据网络反向传播的梯度信息来更新网络的参数，以起到降低loss函数计算值，使得模型输出更加接近真实标签。

Pytorch提供的优化器

Pytorch很人性化的给我们提供了一个优化器的库torch.optim，在这里面提供了十种优化器。
torch.optim.ASGD

• torch.optim.Adadelta
• torch.optim.Adagrad
• torch.optim.Adam
• torch.optim.AdamW
• torch.optim.Adamax
• torch.optim.LBFGS
• torch.optim.RMSprop
• torch.optim.Rprop
• torch.optim.SGD
• torch.optim.SparseAdam
  而以上这些优化算法均继承于Optimizer，下面我们先来看下所有优化器的基类Optimizer。定义如下：

class Optimizer(object):
    def __init__(self, params, defaults):        
        self.defaults = defaults
        self.state = defaultdict(dict)
        self.param_groups = []

Optimizer有三个属性：

• defaults：存储的是优化器的超参数，例子如下：

{'lr': 0.1, 'momentum': 0.9, 'dampening': 0, 'weight_decay': 0, 'nesterov': False}

• state：参数的缓存，例子如下：

defaultdict(<class 'dict'>, {tensor([[ 0.3864, -0.0131],
        [-0.1911, -0.4511]], requires_grad=True): {'momentum_buffer': tensor([[0.0052, 0.0052],
        [0.0052, 0.0052]])}})

• param_groups：管理的参数组，是一个list，其中每个元素是一个字典，顺序是params，lr，momentum，dampening，weight_decay，nesterov，例子如下：

[{'params': [tensor([[-0.1022, -1.6890],[-1.5116, -1.7846]], requires_grad=True)], 'lr': 1, 'momentum': 0, 'dampening': 0, 'weight_decay': 0, 'nesterov': False}]

Optimizer还有以下的方法：

• zero_grad()：清空所管理参数的梯度，PyTorch的特性是张量的梯度不自动清零，因此每次反向传播后都需要清空梯度。
• step()：执行一步梯度更新，参数更新
• add_param_group()：添加参数组
• load_state_dict() ：加载状态参数字典，可以用来进行模型的断点续训练，继续上次的参数进行训练
• state_dict()：获取优化器当前状态信息字典
  注意：
• 每个优化器都是一个类，我们一定要进行实例化才能使用
• optimizer在一个神经网络的epoch中需要实现下面两个步骤：梯度置零，梯度更新。