Learn_PyTorch_3_深度学习基础

1 激活函数

激活函数的作用是使神经网络具备分层的非线性映射学习能力。

常见的激活函数为Sigoid、tanh、Relu、LeakyRelu、elu等，它们皆位于torch.nn.functional包中。

1.1 Sigmoid函数

$$f(x)=\frac{1}{1+e^{-x}}$$
Sigmoid激活函数是最早采用的一类激活函数，具有指数函数的形状，它将实数映射到$[0,1]$范围内。
Sigmoid函数求导：$$f^{\prime }(x)=\frac{e^{-x}}{(1+e^{-x}{)}^2}=\frac{1}{1+e^{-x}}(1-\frac{1}{1+e^{-x}})=f(x)(1-f(x))$$
利用torch.nn.functional包中的sigmoid函数以及pytorch的自动求导机制可以绘制出Sigmoid函数及其导数图像如下：

%matplotlib inline
import torch
import torch.nn.functional as F
import matplotlib
import matplotlib.pyplot as plt

x = torch.linspace(-5, 5, 1000, requires_grad = True)
out = F.sigmoid(x)
out.backward(torch.ones(1, 1000)) # 函数值
gradient = x.grad # 导数值
'''
	display
'''

从图像可以看出，Sigmoid在定义域内处处可导，且两侧导数逐渐趋于0，即$$\underset{x\to \infty }{\lim }{f}^{\prime }(x)=0$$说明Sigmoid函数是一种软饱和函数（梯度渐近趋于零）。
缺点1： 当$x$的值较大或较小时，函数的导数趋于0，会导致梯度消失的现象。
缺点2： 输出非零均值，会导致模型训练收敛速度变慢。

1.2 tanh函数

$$f(x)=\frac{e^x-e^{-x}}{e^x+e^{-x}}=2\ast Sigmoid(2x)-1$$
tanh是Sigmoid函数的变体，它将实数映射到$[-1,1]$范围内，因此输出为零均值，模型收敛速度会更快。

同理，将上面的代码中的sigmoid改为tanh可以得到tanh以及导数图像如下：

缺点： tanh也存在梯度消失问题。

1.3 Relu（线性修正单元）

$$f(x)=\max (0,x)$$
特点： 导数简单，无指数或除法运算。
Relu导数：$$f(x)=\{\begin{array}{ll}0& x<0\\ 1& x\ge 0\end{array}$$
函数图像：

优点1： 缓解梯度消失问题（$x>0$）。
优点2： 计算速度快。
优点3： 收敛速度快。
优点4： Relu会使一部分神经元的输出为0，即网络变得稀疏，可以一定程度上缓解过拟合。

此外，Relu函数存在神经元死亡的问题：

随着训练的推进，部分输入会落入硬饱和区（负半轴），导致对应权重无法更新。这种现象称为神经元死亡。

权值更新过程：$$w=w-\alpha \frac{\partial L}{\partial w}$$当$\frac{\partial L}{\partial w}$很大时，更新权重后该神经元可能落入硬饱和区，此时该神经元的输出为0，梯度也为0，对应权值无法再更新，这个神经元就再也无法激活。
为了解决这个问题，提出了多个Relu的变体。

1.4 Leaky_Relu

$$f(x)=\max (\sigma x,x)$$其中，$\sigma$是一个很小的正常数。这样既修正了数据分布，又保留了负轴的一些值，使得负轴信息不全部丢失。

基于LeakyRelu，有Randomized Relu和Parameterized Relu两个变体，前者首先随机选择$\sigma$的值，然后在测试过程中进行修正；后者将$\sigma$作为神经元的参数进行训练；

1.5 ELU(指数线性单元)

$$f(x)=\{\begin{array}{ll}x& x<0\\ \alpha (e^x-1)& x\ge 0\end{array}$$
ELU及其导数图像如下：

ELU融合了Sigmoid和Relu的特点，左侧具有软饱和性，右侧无饱和性。
优点： 左侧软饱和使得ELU对输入变化或噪声更加鲁棒，右侧无饱和使得ELU能够有效缓解梯度消失问题。此外，ELU的零均值输出使得其收敛速度更快。

1.6 MAXOUT

$$f(x)=\max (w_1^{T}x+b1,w_2^{T}x+b2,...,w_k^{T}x+bk)$$
MAXOUT相当于在中间增加了含k个神经元的“隐隐含层”，输出为k个神经元中输出的最大值，如下图所示：

优点1： MAXOUT的拟合能力非常强，可以拟合任意的凸函数。（当$w_2=0,b_2=0,...,w_k=0,b_k=0$时，退化为Relu。）
优点2： MAXOUT能够缓解梯度消失问题；由于不会陷入硬饱和区，可以规避神经元死亡的缺点；
缺点： 增加了参数数量和计算量。

1.7 激活函数的选取

1. 通常来说，很少会把各种激活函数串在一个网络中使用
2. 如果使用Relu， 一定要小心设置学习率，预防出现过多的“神经元死亡”问题。
3. 可以选择LeakyRelu、PRelu或者maxout解决神经元死亡问题。
4. 最好不要使用Sigmoid、可以尝试使用tanh，但效果通常不会有Relu或maxout好。

2 梯度下降法

梯度下降法主要有三种变体：批量梯度下降法、随机梯度下降法、小批量梯度下降法

2.1 批量梯度下降法（BGD）

① 对于给定的迭代次数，基于在整个数据集上求出的损失函数对输入的参数向量$w$计算梯度向量。
②参数更新：$$\begin{gathered} \Delta w_{\ast }=-\eta \sum _{k=1}^{all}\frac{\partial J}{\partial w_{\ast }} \\ {w}_{\ast }^{t+1}=w_{\ast }^t+\Delta w_{\ast } \end{gathered}$$
缺点1： 每次更新需要在整个数据集上求出所有的偏导数，因此批量梯度下降法的速度比较慢。
缺点2： 不能以“在线”的形式更新模型，也就是不能在运行中试试加入新的样本进行运算。

2.2 随机梯度下降法（SGD）

相比批量梯度下降法，SGD的每次更新，是对数据集中的一个样本(x, y)求出损失函数，然后对其求响应偏导数，进行参数更新：$$\begin{gathered} \Delta w_{\ast }=-\eta \frac{\partial J}{\partial w_{\ast }} \\ {w}_{\ast }^{t+1}=w_{\ast }^t+\Delta w_{\ast } \end{gathered}$$
优点1： 对于批量梯度下降，在每次更新前，需要对所有样本求解梯度值，因此会对相似样本求算梯度值，在较大数据集上的计算会出现冗余。而随机梯度下降每次仅对一个样本求梯度，去除了这种冗余情况。
优点2： 随机梯度下降的运行速度快，且能够“在线”学习。
优点3： 随机梯度下降中会使得目标函数剧烈的波动，从而使得目标函数可能从一个局部极小值点跳入另一个更小的极小值点。。
缺点1： 随机梯度下降的持续波动使得训练的过程难以停止下来。
缺点2： 每次正反向传播只计算一个样本，串行条明显，硬件利用率不高。

2.3 小批量梯度下降法（Mini-Batch Gradient Descent）

Mini-batch集合了SGD和BGD的优点，在每次更新中，对n个样本构成的一批数据，计算损失函数，并对相应的参数求导，然后进行参数更新：$$\begin{gathered} \Delta w_{\ast }=-\eta \sum _{k=1}^n\frac{\partial J}{\partial w_{\ast }} \\ {w}_{\ast }^{t+1}=w_{\ast }^t+\Delta w_{\ast } \end{gathered}$$
优点1： 相比SGD，降低了更新参数的方差，收敛过程更为稳定。
优点2： 相比BGD，不用对整个数据集求损失函数，可减少计算冗余，加快收敛速度。

小批量梯度下降法通常是训练神经网络的首选算法。

2.4 梯度下降会遇到的问题

在进行梯度下降的过程中，会面临三种情况：
1. 平原问题： 在平原中，梯度变化非常的缓慢。
2. 鞍点： 梯度下降可能会停在鞍点位置。
3. 局部极值点： 梯度下降可能会停在局部极值点而非全局极值点。
下图展示了这三种情况：

上述三种情况的出现，使得选取不同初始点时，最终会收敛到不同的局部极值，得到不同的优化效果。

3 优化算法

3.1 学习率调整策略

学习率$\eta$是深度学习中一个重要的参量，如何调整学习率是训练出好模型的关键要素之一。

学习率过大
学习率过大，则梯度更新过快，容易出现超调现象：在极值点两端不断发散，或是剧烈震荡。此时，随着迭代次数增大，损失函数没有减小的趋势。

学习率过小
学习率过小，则梯度更新太慢，会导致无法快速地找到好的下降的方向。此时，随着迭代次数增大，损失函数几乎不变。

学习率设置规则

• 小梯度，设置大的学习率，加快梯度更新。
• 大梯度，设置小的学习率，减缓剧烈震荡。

学习率调整方法
1. 基于经验的手动调整
     \space\space\space\space     通过尝试不同的固定学习率，如0.1， 0.01， 0.001等，观察迭代次数和损失函数的变化关系，找到损失函数下降最快对应的学习率。
2. 基于策略的调整
（1）$$\eta =\frac{1}{1+decayrate\ast epochnum}{\eta }_0$$其中，$epochnum$表示遍历数据集的次数，$dacayrate$为衰减率。随着迭代次数的增多，学习率会逐渐下降。
（2）指数衰减（exponentially decay）$$\eta =0.95^{epochnum}{\eta }_0$$
（3）其他$$\eta =\frac{k}{\sqrt{epochnum}}{\eta }_0$$

3.2 梯度下降优化算法

在PyTorch中，优化算法被包含在torch.optim包中，optim中实现了大多数常用的优化算法如：Momenbum法（动量法）、Adagrad法（自适应梯度）、Nesterov加速梯度法（NAG）、Adadelta法、RMSprop法、适应性动量估计法（Adam）

3.2.1 Momenbum法（动量法）

动量法在利用梯度时，不仅仅利用当前次迭代所计算出的梯度值，还使用之前一段时间的梯度值。$$\begin{gathered} v_t=\gamma v_{t-1}+\eta \nabla J \\ {\theta }^t={\theta }^{t-1}-v_t \end{gathered}$$其中，$v_{t-1}$表示之前所有步骤所累积的动量和。$\gamma$为动量因子，通常取0.9，使得早期梯度对当前梯度的影响越来越小。$\gamma v_{t-1}$为动量项，当前后梯度方向一致时，能够加速学习，前后方向不一致时，能够抑制震荡。

动量法就是一种犹如小球自动滚动下山的方法，它使得损失函数能够根据惯性越过平原、鞍点或局部极值点的位置。而动量因子的作用就类似于摩擦力的作用，使得结果不至于发散。

下图是使用动量法之后的情况：

下降初期： 梯度方向相同，加快下降速度。
平原阶段： 当前梯度为零，但累积的动量会使其顺利越过平原。
鞍点位置： 同样的，累积的动量会使得其越过鞍点位置。
局部极值点位置： 同样的，如果累积的动量足够大，可以使得其越过局部极值点位置。
全局极值点位置： 如果没有动量项，在学习率较大的情况下会使得损失函数在极值点位置来回“震荡”，而动量项可以减少“震荡”的幅度，从而加速收敛到全局极值点。

3.2.2 加速梯度法（NAG）

加速梯度法是动量法的改进，是一种更加“聪明”的滚动下山的方式。动量法每一步需要将历史梯度和当前梯度进行合并，然后再进行梯度下降；而加速梯度法先按照历史梯度往前走一小步，然后与该位置的“超前”梯度进行合并，因此可以在这个超前的位置看到梯度，从而修正这一步的梯度。$$\begin{gathered} v_t=\gamma v_{t-1}+\eta \nabla J({\theta }_t-\gamma v_{t-1}) \\ {\theta }_t={\theta }_{t-1}-v_t \end{gathered}$$
其中，$\nabla J({\theta }_t-\gamma v_{t-1})$作用是“预测”下次参数位置近似值，也就是告诉我们参数大致会变为多少，这种预更新方法能防止大幅震荡，且不会错过最小值，并对参数更新更加敏感。

这种基于预测的更新方法，可避免过快地前进，提高了算法响应能力。

3.2.3 Adagrad法（自适应梯度）

AdaGrad算法利用之前计算的梯度来自动变更学习率$eta$, 学习率的修正方式如下：$${\theta }_t={\theta }_{t-1}-\frac{\eta }{\sqrt{{\sum }_{r=1}^{t-1}(\nabla J{)}_r+ϵ}}(\nabla J{)}_t$$
其中，$ϵ$是一个平滑项，用于避免分母为0， 它的数量级通常在$10^{-7}$。
优点
①每次迭代不需要手工调整学习率，能够实现学习率自动更新。
②大梯度对应小的学习率，小梯度对应大的学习率，从而加快收敛。
缺点
①学习率单调递减，训练后期学习率非常小，这使得网络更新能力越来越弱，最终梯度趋于零，使得训练提前结束。
②更新时，左右两边单位不一致。
③仍依赖于人工设置一个全局学习率$\eta$。

3.2.4 Adadelta法

Adadelta法是Adagrad法的一个延伸，它旨在于解决Adagrad的是三个问题。
①第一个问题：仅利用Adagrad分母中累计项离当前时间点比较近的项。
Adagrad会累加之前所有的梯度平方，而Adadelta只累加固定大小的项（累积窗口限制到固定的尺寸w，即只取最近的w个状态。）
②第二、三个问题：改进为$${\theta }_t={\theta }_{t-1}-\frac{RMS[\Delta \theta {]}_{t-1}}{RMS[g{]}_t}{g}_t$$其中，$$\begin{gathered} g_t=(\nabla J{)}_t \\ RMS[\Delta \theta {]}_t=\sqrt{E[\Delta {\theta }^2{]}_t+ϵ}，E[\Delta {\theta }^2{]}_t=\gamma E[\Delta {\theta }^2{]}_{t-1}+(1-\gamma )\Delta {\theta }_t^2, \\ RMS[g{]}_t=\sqrt{E[g^2{]}_t+ϵ}，E[g^2{]}_t=\gamma E[g^2{]}_{t-1}+(1-\gamma )g_t^2 \end{gathered}$$
从上式可以看出，Adadelta法并不依赖于全局学习率。

3.2.5 RMSprop法（均方根传播）

RMSprop法和Adadelta法类似，也是Adagrad法的改进，相比于Adagrad历史梯度，RMSprop算法增加了一个衰减系数来控制历史信息的权重。$$\begin{gathered} E[g^2{]}_t=0.9E[g^2{]}_{t-1}+0.1g_t^2 \\ {\theta }_{t+1}={\theta }_t-\frac{\eta }{\sqrt{E[g^2{]}_t+ϵ}}{g}_t \end{gathered}$$
从本质上看，可认为RMSprop将不同方向梯度的方差考虑进来，对于波动大的（方差大），梯度给小一点，对于波动小的，梯度给大一点，这样整个下降路径就缓和很多，提高计算效率。

square表示在梯度那里使用了平方项，mean表示梯度的加权平均，root表示分母梯度平方再开方。

特点
① 仍然依赖于全局学习率
② 很好的解决了训练过程过早结束的问题
③ RMSprop适合处理非平稳目标（将不同方向梯度的方差考虑进来），对RNN效果很好。

3.2.6 Adam法（自适应动量估计法）

Adam算法结合了momentum和RMSprop，包含梯度平均和梯度方差的信息，将momentum和RMSprop的权重更新方法结合在一起。

Adam法本质上是带有动量项RMSprop，它利用梯度的一阶估计和二阶估计动态调整每个参数的学习率。

梯度的一阶矩：$$m_t={\beta }_1{m}_{t-1}+(1-{\beta }_1)g_t$$梯度的二阶矩：$$v_t={\beta }_2{v}_{t-1}+(1-{\beta }_2)g_t^2$$其中，${\beta }_1$为momentum超参数，用来调试梯度平均方程；${\beta }_2$为RMSprop超参数，用来调试计算梯度方差过程。
偏差校正：$${\hat{m}}_t=\frac{m_t}{1-{\beta }_1^t}{\hat{v}}_t=\frac{v_t}{1-{\beta }_2^t}$$近似为对期望的无偏估计。
参数更新：$${\theta }_{t+1}={\theta }_t-\frac{\eta }{\sqrt{{\hat{v}}_t}+ϵ}{\hat{m}}_t$$

3.2.7 各种优化方法对比

下图给出了不同梯度下降法损失平面等高线对比：

可以看到，Adagrad、Adadelta、RMSprop能够快速找到正确前进方向并以相似的速度很快收敛。而动量法和NAG法则找错了方向，让小球沿着梯度下降的方向前进，但NAG法能够往前看并对前面的情况作出相应，所有可以很快改正方向，向正确方向前进。

下图给出了不同梯度下降法在鞍点处的表现：

可以看到，SGD法、动量法、NAG法都很难打破“对称性”带来的壁垒，尽管最后两者设法逃脱了鞍点；Adagrad、Adadelta、RMSprop能够快速的沿着负斜率的方向前进。

优化器选择
① SGD通常训练时间长，且容易陷入鞍点，但在好的初始化和学习率调整策略的情况下可以得到更可靠的结果。
② 在网络较为复杂，且对收敛速度有要求的情况下，通常使用学习率自适应的优化方法（Adagrad法、Adadleta法、RMSprop法以及Adam法等）。
③ Adadelta, RMSprop, Adam是比较相近的算法，在一般情况下表现差不多。

3.3 PyTorch中使用优化算法

下面举例说明在PyTorch中如何使用各种优化算法：

3.2.1 SGD

PyTorch中的SGD指的是小批量梯度下降法(Mini-batch)，并且通过传入参数可以实现momentum和NAG优化。SGD类原型如下：
CLASS：torch.optim.SGD(params, lr = <required parameters>, momentum = 0, dampening = 0, weight_decay = 0, nesterov = False)

• params：要优化的参数，需传入model.parameters()
• lr：学习率，由经验设置，通常可设置为0.1、0.01、0.001等
• momentum：动量因子，通常设置为0.9
• dampening：动量抑制系数
• weight_decay：权值衰减（L2正则项)，用于防止过拟合
• nesterov：是否使能NAG优化，默认为否

下面是一个简单的例子：

# 1. 实例化SGD类，得到优化器对象optimizer
optimizer = torch.optim.SGD(model.parameters(), lr = 0.1, momentum = 0.9)
# 2. 在计算梯度之前先将之前计算的梯度清零，因为反向传播时只需要当前次迭代的梯度
optimizer.zero_grad() 
# 3. 计算出损失函数，并利用backward()自动计算梯度
loss_fun(model(input), target).backward()
# 4. 最后利用optimizer.step()更新参数
optimizer.step()

上述过程总共经过了四步：创建优化器、历史梯度清零、重新计算梯度、更新参数。实际上第一步在整个模型训练中只需要执行一次，后三步需要在每次迭代过程中反复执行。

3.2.2 Adagrad

前面提到，AdaGrad算法利用之前计算的梯度来自动变更学习率$eta$, 学习率的修正方式如下：$${\theta }_t={\theta }_{t-1}-\frac{\eta }{\sqrt{{\sum }_{r=1}^{t-1}(\nabla J{)}_r+ϵ}}(\nabla J{)}_t$$
其中，$ϵ$是一个平滑项，用于避免分母为0， 它的数量级通常在$10^{-7}$。

Adagrad原型如下：
CLASS：torch.optim.Adagrad(params, lr = 0.01, lr_decay = 0, weight_decay = 0, initial_accumulator_value = 0)

• params：要优化的参数，可传入model.parameters()
• lr：初始学习率，由经验设置，通常可设置为0.1、0.01、0.001等
• lr_decay：学习率衰减项，根据源码可以看到貌似是计算出的学习率再乘lr_decay
• weight_decay：权值衰减（L2正则项)，用于防止过拟合
• initial_accumulator_value：初始梯度累计值，一般就默认为0

PyTorch中使用Adagrad等优化方法和SGD类似，就不举例了。

3.2.4 RMSprop

RMSprop是G.Hinton提出的一个优化算法，它是Adagrad的改进算法。原型如下：

CLASS：torch.optim.RMSprop(params, lr = 0.01, alpha = 0.99, eps = 1e-08, weight_decay = 0, momentum = 0, centered = False)

其中，params、lr、weight_decay, momentum的解释同上，eps的意义在前文也有解释，因此下面重点介绍其他两个参数：

• alpha：平滑系数，具体作用需要参看RMSprop算法的过程，默认为0.99
• centered：如果使能，则计算中心化的RMSprop，梯度会根据方差的估计进行归一化。

3.2.4 Adam

前面提到，Adam算法结合了momentum和RMSprop，包含梯度平均和梯度方差的信息，将momentum和RMSprop的权重更新方法结合在一起。

Adam原型如下：
CLASS：torch.optim.Adam(params, lr = 0.001, betas = (0.9, 0.999), eps = 1e-08, weight_decay = 0, amsgrad = False

其中，params、lr、weight_decay的解释同上，eps的意义在前文也有解释，因此下面重点介绍其他两个参数：

• betas：需要传入一个tupe：(${\beta }_1,{\beta }_2$)，它们分别是momentum和RMSprop的超参数
• amsgrad：是否使用Adam算法的变体AMSGrad，该算法详见On the Convergence of Adam and Beyond，默认不使用。

4 过拟合问题

过拟合是指一个算法在训练数据上表现很好，但在测试数据上或新的数据上的表现，与在训练数据上差别很大。

4.1 出现过拟合的原因

① 过拟合一个可能的原因是模型特征维度过高，模型假设过于复杂，参数过多。
② 数据中的噪声过多，如果完全拟合的话，与真实情景差异更大。
③ 数据量有限，使得模型无法真正了解整个数据的真实分布。
④ 权值学习迭代次数足够多的，拟合了训练数据中的噪声和训练样例中没有代表性的特征。

过拟合使得模型过度的拟合了训练数据，而没有考虑到泛化能力。

4.2防止过拟合的方法

4.2.1 Early stoppping （早停法）

     \space\space\space\space     早停法是一种用来避免模型在训练数据上过拟合的正则化方法：一旦训练过程中出现性能开始下降，可以停止训练与学习。

4.2.2 Weight Decay （权值衰减法）

     \space\space\space\space     权值衰减法是从我们大脑工作借鉴来的方法，我们的大脑会将一些无用的连接进行清除。

在机器学习中，引入L2范数正则化来衰减权重，在一定程度上减少模型过拟合的问题，因此权重衰减也叫L2正则化。

L2正则化的原理如下，在损失函数上增加L2范数惩罚项：$$L=L_0+\frac{\lambda }{2n}\sum w^2$$
对加入L2正则化的损失函数求导：$$\frac{\partial L}{\partial w}=\frac{\partial L_0}{\partial w}+\frac{\lambda }{n}w$$
权值更新过程：$$w=w-\eta (\frac{\partial L_0}{\partial w}+\frac{\lambda }{n}w)=(1-\frac{\eta \lambda }{n})w-\eta \frac{\partial L_0}{\partial w}$$其中，$\lambda$为正则项系数，也叫权重衰减系数; $w$的系数$1-\frac{\eta \lambda }{n}<0$，即对权重进行了衰减。

4.2.3 Dropout

2012年，Hinton在其论文《improving neural networks by preventing co-adaptation of feature detectors》提出Dropout，并在同年应用于Alexnet网络。

Dropout的基本思想在于减少部分神经元之间的联合适应性，从而提高神经网络的性能。因为神经元之间的协同作用（某些神经元必须依赖其他神经元才能发挥作用）造成了过拟合现象。大致做法为：在训练的时候，将部分神经元失活（在前向传播的时候，让某个神经元的激活值以一定的概率p停止工作，输出为零），阻断部分神经元之间的协同作用。

如上图所示，失活一定的神经元之后，网络的结构发生了变化，从而减少了冗余连接，防止过拟合。

Dropout的工作流程如下：
① 前向传播
通常的前向传播计算公式：$$\begin{gathered} z_i^{l+1}={\mathbf{w}}_i^{l+1}{\mathbf{y}}^l+b_i^{l+1} \\ {y}_i^{l+1}=f(z_i^{(l+1)} \end{gathered}$$采用Dropout后：
$$\begin{gathered} r_j^{(}l)\sim Bernoulli(p) \\ {\tilde{y}}^{(l)}={\mathbf{r}}^{(l)}\ast {\mathbf{y}}^{(l)} \end{gathered}$$

4.2.4 数据集增广

当训练样本过少，但模型特征维度过高时，网络很容易拟合一些噪声特征，从而发生过拟合现象，因此将数据集进行增广可以有效的防止过拟合。

数据增广的基本方法由：①采集更多的训练样本；②对当前训练样本通过一定规则扩充数据，如图像数据进行平移、旋转、缩放等。

数据增广操作通常在数据集预处理时进行，torchvision中的transforms包提供了一些的常用数据增广和变换操作，详见torchvision.transforms。

其中支持的变换如下：

1. torchvison.transforms.CenterCrop(size)
中心裁剪，当size为int时，裁剪为(size * size)大小；当size = (h, w)时，裁剪为(h, w)大小。
2. torchvision.transforms.ColorJitter(brightness = 0, contrast = 0, saturation = 0, hue = 0)
随机改变图像的亮度、对比度、饱和度和色度。
3. torchvision.transforms.FiveCrop(size)
将一张图根据四个角和中心裁剪出5张，如下图：

4. torchvision.transforms.Grayscale(num_output_channel = 1)
转换为灰度图，如果num_output_channel = 1则输出总的灰度图，如果 = 3，则输出三个通道的灰度图。
5. torchvision.transforms.Pad(padding, fill = 0, padding_mode = 'constant')
对图像进行padding操作
6. torchvision.transforms.RandomAffine(degrees, translate = None, scale = None, shear = None, resample = False, fillcolor = 0)
对图像进行仿射变换，保持中心不变。degrees旋转、translate平移、scale缩放

7. torchvision.transforms.RandomApply(transforms, p = 0.5)
随机是否应用变换
8. torchvision.transforms.RandomChoice(transforms)
随机应用transforms列表中的一种变换
9. torchvision.transforms.RandomCrop(size, padding = None, pad_if_needed = False, fill = 0, padding_mode = 'constant)
随机位置裁剪
10. torchvision.transfoms.RandomGrayscale(p = 0.1)
以概率 p 进行随机灰度转换
11. torchvision.transforms.RandomHorizontalFlip(p = 0.5)
以概率 p 进行随机水平翻转
12. torchvision.transforms.RandomOrder(transforms)
以随机的顺序应用一系列变换
13. torchvision.transforms.RandomPerspective(distortion_scale = 0.5, p = 0.5, interpolation = 3)
以概率 p 进行随机透视变换
14. torchvision.transforms.RandomResizedCrop(size, scale = (0.08, 1.0), ratio = (0.75, 1.3333333333333), interpolation = 2)
对图像进行随机缩放和裁剪
15. torchvision.transforms.RandomRotation(degrees, resample = False, expand = False, center = None)
随机旋转图像
16. torchvision.transforms.RandomVerticalFlip(p = 0.5)
以概率 p 进行随机垂直翻转
17. torchvision.transforms.Resize(size, interpolation = 2
对图像进行resize操作
18. torchvision.transforms.TenCrop(size, vertical_filp = False)
类似FiveCrop，将图像裁剪出10张图。

此外，torchvision.transforms还提供了一个类将上述变换进行组合：

19. torchvision.transforms.Compose(transforms)

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

总结

本文总结了一些深度学习的基础知识，包括激活函数、梯度下降法及优化、过拟合问题等，同时总结了如何在PyTorch中使用激活函数、优化算法以及利用torchvision中的变换进行数据集增广等。