[toc]

基本流程

完成一项深度学习任务的基本流程大致如下：

1. 数据预处理
2. 模型构建
3. 模型训练
4. 模型导出及应用

模型构建则是关键，选择适当的模型，并设定损失函数和优化函数，以及对应的超参数（当然可以使用sklearn这样的机器学习库中模型自带的损失函数和优化器）；再进行模型训练，用模型去拟合训练集数据，并在验证集/测试集上计算模型表现；最后将训练好的模型进行导出，进行下一步应用。

数据预处理

数据预处理主要包括数据读入、数据集划分及相关任务的预处理，该过程中需要重点关注数据格式的统一和必要的数据变换。

PyTorch数据读入是通过Dataset+Dataloader的方式完成的，Dataset定义好数据的格式和数据变换形式，Dataloader用iterative的方式不断读入批次数据。

我们可以定义自己的Dataset类来实现灵活的数据读取，定义的类需要继承PyTorch自身的Dataset类。主要包含三个函数：

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

构建好Dataset后，就可以使用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：对于样本最后一部分没有达到批次数的样本，使其不再参与训练

模型构建

模型构建则是关键，选择适当的模型，构建出神经网络中相应的层，并设定损失函数和优化函数，以及对应的超参数（当然可以使用sklearn这样的机器学习库中模型自带的损失函数和优化器）

超参数

常见的超参数有，如下：

• batch size
• 初始学习率（初始）
• 训练次数（max_epochs）
• GPU配置

神经网络的层

深度学习的一个魅力在于神经网络中各式各样的层，以卷积神经网络(CNN)为例，其主要涵盖如下层：

• 卷积层
• 池化层
• 激活函数层
• 归一化层
• 全连接层

卷积层

卷积层由参数可学习的卷积核组成。卷积核的宽度和长度可改变，深度必须与输入层的通道数一致。

比如说输入32x32x3的图片，一个卷积核的大小为5x5x3，一个卷积核在padding=0情况下划窗生成一个二维的激活图（28x28x1）。

image

如果我们有6个5x5x3的卷积核，就可以生成28286的激活图。输出层的通道数与卷积核个数一致。

image

三维卷积的Pytorch操作如下：

import torch
import torch.nn as nn


x=torch.randn(5,3,10,224,224)
conv = nn.Conv3d(3, 64, kernel_size=(5,5,3), stride=1, padding=1)
print(conv.weight.size())# torch.Size([64, 3, 5, 5, 3])
out=conv(x)
print(out.size())#torch.Size([5, 64, 8, 222, 224])

池化层

池化层用来控制图片的空间尺寸，相当于一个降采样的过程。同时，池化层也有着控制过拟合的作用。有maxpooling，averagepooling等类型。

image

激活函数层

所谓激活，实际上是对卷积层的输出结果做一次非线性映射。激活函数可以引入非线性因素，解决线性模型所不能解决的问题。

常用的激活函数有sigmoid，ReLU，tanh,leakyReLU等等

image

归一化层

最常用的归一化层是Batch Normalization。能使训练速度大大加快。

image

全连接层

全连接层（fully connected layers，FC）指的是神经元完全与输入的变量连接，在整个卷积神经网络中起到“分类器”的作用。

image

损失函数

在PyTorch中，损失函数是必不可少的。它是数据输入到模型当中，产生的结果与真实标签的评价指标，我们的模型可以按照损失函数的目标来做出改进。常见的损失函数主要有：

• 二分类交叉熵损失函数
• 交叉熵损失函数
• L1损失函数
• MSE损失函数
• ...

以二分类交叉熵损失函数为例，在pytorch代码如下：

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的返回是标量。

优化器

深度学习的目标是通过不断改变网络参数，使得参数能够对输入做各种非线性变换拟合输出，本质上就是一个函数去寻找最优解，只不过这个最优解使一个矩阵，而如何快速求得这个最优解是深度学习研究的一个重点，以经典的resnet-50为例，它大约有2000万个系数需要进行计算，那么我们如何计算出来这么多的系数，有以下两种方法：

1. 第一种是最直接的暴力穷举一遍参数，这种方法的实施可能性基本为0，堪比愚公移山plus的难度。
2. 为了使求解参数过程更加快，人们提出了第二种办法，即就是是BP+优化器逼近求解。

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

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

模型训练

训练和评估

完成了上述设定后就可以加载数据开始训练模型了。首先应该设置模型的状态：如果是训练状态，那么模型的参数应该支持反向传播的修改；如果是验证/测试状态，则不应该修改模型参数。在PyTorch中，模型的状态设置非常简便，如下的两个操作二选一即可：

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

我们前面在DataLoader构建完成后介绍了如何从中读取数据，在训练过程中使用类似的操作即可，区别在于此时要用for循环读取DataLoader中的全部数据。

for data, label in train_loader:

之后将数据放到GPU上用于后续计算，此处以.cuda()为例

data, label = data.cuda(), label.cuda()

开始用当前批次数据做训练时，应当先将优化器的梯度置零：

optimizer.zero_grad()

之后将data送入模型中训练：

output = model(data)

根据预先定义的criterion计算损失函数：

loss = criterion(output, label)

将loss反向传播回网络：

loss.backward()

使用优化器更新模型参数：

optimizer.step()

这样一个训练过程就完成了，后续还可以计算模型准确率等指标，这部分会在下一节的图像分类实战中加以介绍。

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

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

一个完整的训练过程如下所示：

def train(epoch):
    model.train()
    train_loss = 0
    for data, label in train_loader:
        data, label = data.cuda(), label.cuda()
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(label, output)
        loss.backward()
        optimizer.step()
        train_loss += loss.item()*data.size(0)
    train_loss = train_loss/len(train_loader.dataset)
        print('Epoch: {} \tTraining Loss: {:.6f}'.format(epoch, train_loss))

对应的，一个完整的验证过程如下所示：

def val(epoch):       
    model.eval()
    val_loss = 0
    with torch.no_grad():
        for data, label in val_loader:
            data, label = data.cuda(), label.cuda()
            output = model(data)
            preds = torch.argmax(output, 1)
            loss = criterion(output, label)
            val_loss += loss.item()*data.size(0)
            running_accu += torch.sum(preds == label.data)
    val_loss = val_loss/len(val_loader.dataset)
    print('Epoch: {} \tTraining Loss: {:.6f}'.format(epoch, val_loss))

模型导出及应用

简单的保存与加载方法：

# 保存整个网络
torch.save(net, PATH) 
# 保存网络中的参数, 速度快，占空间少
torch.save(net.state_dict(),PATH)
#--------------------------------------------------
#针对上面一般的保存方法，加载的方法分别是：
model_dict=torch.load(PATH)
model_dict=model.load_state_dict(torch.load(PATH))