深度学习笔记（四）——pytorch实现神经网络案例

神经网络核心组件及其关系图

神经网络的核心组件

（1）层：神经网络的基本结构，将输入张量转换为输出张量。
（2）模型：层构成的网络。
（3）损失函数：参数学习的目标函数，通过最小化损失函数来学习各种参数。
（4）优化器：如何使损失函数最小。

神经网络关键组件相互关系图

神经网络实例

构建网络层可以基于Module类或函数（nn.functional）。nn中的大多数层在functional中都有与之对应的函数。nn.functional中函数与nn.Module中的Layer的主要区别是后者继承Module类，会自动提取可学习参数。而nn.functional更像是纯函数。两者功能相同，且性能没有很大区别。那如何选择呢？像卷积层、全连接层、Dropout层等因含有可学习的参数，一般使用nn.Module，而激活函数、池化层不含可学习参数，可以使用nn.functional中对应的函数。

背景说明

利用神经网络完成对手写数字进行识别的实例。
主要步骤：
（1）利用pytorch内置函数mnist下载数据。
（2）利用torchvision对数据进行预处理，调用torch.utils建立一个数据迭代器。
（3）可视化源数据。
（4）利用nn工具箱构建神经网络模型。
（5）实例化模型，并定义损失函数及优化器。
（6）训练模型。
（7）可视化结果

神经网络结构

使用两个隐含层，每层激活函数为ReLU，最后使用torch.max(out, 1)找出张量out最大值对应索引作为预测值。

代码示例

导入必要的模块

import numpy as np
import torch
# 导入pytorch内置的mnist数据
from torchvision.datasets import mnist
# 导入预处理模块
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
# 导入nn及优化器
import torch.nn.functional as F
import torch.optim as optim
from torch import nn

定义一些超参数

# 定义一些超参数
train_batch_size = 64
test_batch_size = 128
learning_rate = 0.01
num_epoches = 20
lr = 0.01
momentum = 0.5

下载数据并对数据进行预处理

# 定义与处理函数，这些预处理依次放在compose函数中
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize([0.5], [0.5])])
# 下载数据，并对数据进行预处理
train_dataset = mnist.MNIST('./data', train=True, transform=transform)
test_dataset = mnist.MNIST('./data', train=False, transform=transform)
# dataloader是一个可迭代对象，可以使用迭代器一样使用
train_loader = DataLoader(train_dataset, batch_size=train_batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=test_batch_size, shuffle=False)

说明：

（1）transforms.Compose可以把一些转换函数组合在一起；
（2）Normalize([0.5], [0.5])对张量进行归一化，这里两个0.5分别表示对张量进行归一化的全局平均值和方差。因图像是灰色的只有一个通道，如果有多个通道，需要有多个数字，如3个通道，应该是Normalize([m1, m2, m3], [n1, n2, n3])；
（3）download参数控制是否需要下载，如果./data目录下已有MNIST，可选择False；
（4）DataLoader得到生成器，这可节省内存；

可视化源数据

# 可视化源数据
examples = enumerate(test_loader)
batch_idx, (example_data, example_targets) = next(examples)
fig = plt.figure()
for i in range(6):
    plt.subplot(2, 3, i+1)
    plt.tight_layout()
    plt.imshow(example_data[i][0], cmap='gray', interpolation='none')
    plt.title("Ground Truth {}".format(example_targets[i]))
    plt.xticks([])
    plt.yticks([])
plt.show()

构建模型

# 构建网络
class Net(nn.Module):
    '''
    使用sequential构建网络，sequential（）函数的功能是将网络的层组合到一起
    '''
    def __init__(self, in_dim, n_hidden_1, n_hidden_2, out_dim):
        super(Net, self).__init__()
        self.layer1 = nn.Sequential(nn.Linear(in_dim, n_hidden_1), nn.BatchNorm1d(n_hidden_1))
        self.layer2 = nn.Sequential(nn.Linear(n_hidden_1, n_hidden_2), nn.BatchNorm1d(n_hidden_2))
        self.layer3 = nn.Sequential(nn.Linear(n_hidden_2, out_dim))

    def forward(self, x):
        x = F.relu(self.layer1(x))
        x = F.relu(self.layer2(x))
        x = self.layer3(x)
        return x
"""实例化网络"""
# 检测是否有可用的GPU，有则使用，否则使用CPU
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# 实例化网络
model = Net(28 * 28, 300, 100, 10)
model.to(device)
# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=lr, momentum=momentum)

训练模型

# 开始训练
losses = []
acces = []
eval_losses = []
eval_acces = []
for epoch in range(num_epoches):
    train_loss = 0
    train_acc = 0
    model.train()
# 动态修改参数学习率
    if epoch % 5 == 0:
        optimizer.param_groups[0]['lr'] *= 0.1
    for img, label in train_loader:
        img = img.to(device)
        label = label.to(device)
        img = img.view(img.size(0), -1)
        # 前向传播
        out = model(img)
        loss = criterion(out, label)
        # 反向传播
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        # 记录误差
        train_loss += loss.item()
        # 计算分类的准确率
        _, pred = out.max(1)
        num_correct = (pred == label).sum().item()
        acc = num_correct / img.shape[0]
        train_acc += acc

    losses.append(train_loss / len(train_loader))
    acces.append(train_acc / len(train_loader))
    # 在测试集上检测效果
    eval_loss = 0
    eval_acc = 0
# 将模型改为预测模式
    model.eval()
    for img, label in test_loader:
        img = img.to(device)
        label = label.to(device)
        img = img.view(img.size(0), -1)
        out = model(img)
        loss = criterion(out, label)
        # 记录误差
        eval_loss += loss.item()
        # 记录准确率
        _, pred = out.max(1)
        num_correct = (pred == label).sum().item()
        acc = num_correct / img.shape[0]
        eval_acc += acc

    eval_losses.append(eval_loss / len(test_loader))
    eval_acces.append(eval_acc / len(test_loader))
    print('epoch: {}, Train Loss: {:.4f}, Train Acc: {:.4f}, Test Loss: {:.4f}, Test Acc: {:.4f}'.format(
        epoch, train_loss / len(train_loader), train_acc / len(train_loader), eval_loss / len(test_loader), eval_acc / len(test_loader)
    ))

可视化训练及测试损失值

plt.title('trainloss')
plt.plot(np.arange(len(losses)), losses)
plt.legend(['Train Loss'], loc='upper right')
plt.show()

如何构建神经网络

在nn工具箱中，可以直接引用的网络有很多，有全连接层、卷积层、循环层、正则化层、激活层等。那么如何组织或构建这些层显得很关键。

构建网络层

pytorch中采用torch.nn.Sequential()来构建网络层，这个有点类似Keras的models.Sequential()。不过这种方法每层的编码是默认的数字，不易区分。
如果要对每层定义一个名称，我们可以采用Sequential的一种改进方法，在Sequential的基础上，通过add_module()¹添加每一层，并且为每一层增加一个单独的名字。
此外，还可以在Sequential基础上，通过字典的形式添加每一层，并且设置单独的层名称。
以下是采用字典方式构建网络的一个示例代码：

class Net(torch.nn.Module):
    def __init(self):
        super(Net, self).__init()
        self.conv = torch.nn.Sequential(
            OrderedDict(
            [
                ("conv1", torch.nn.Conv2d(3, 32, 3, 1, 1)),
                ("relu1", torch.nn.ReLU()),
                ("pool", torch.nn.MaxPool2d(2))
            ]
        ))
        self.dense = torch.nn.Sequential(
            OrderedDict([
                ("dense1", torch.nn.Linear(32 * 3 * 3, 128)),
                ("relu2", torch.nn.ReLU()),
                ("dense2", torch.nn.Linear(128, 10))
            ])
        )

这里不要忘了在导入库的时候添加如下语句：

from collections import OrderedDict

前向传播

定义好每层后，最后还需要通过前向传播的方式把这些串起来。这就是设计如何定义forward函数的问题。forward函数的任务需要把输入层、网络层、输出层链接起来，实现信息的前向传导。该函数的参数一般为输入数据，返回值为输出数据。
在forward函数中，有些层来自nn.Module，也可以使用nn.functional定义。来自nn.Module的需要实例化，而使用nn.functional定义的可以直接使用。

反向传播

直接让损失函数loss调用backward()即可，后续文章会介绍pytorch的自动反向传播功能。

训练模型

训练模型要注意使模型处于训练模式，即调用model.train()。调用model.train()会把所有的module设置为训练模式。如果是测试或验证阶段，需要使模型处于验证阶段，即调用model.eval()，调用model.eval()会把所有的training属性设置为False。
缺省情况下，梯度是累加的，需要手工把梯度初始化或清零，调用optimizer.zero_grad()即可。训练过程中，正向传播生成网络的输出，计算输出和实际值之间的损失值。调用loss.backward()自动生成梯度，然后使用optimizer.step()执行优化器，把梯度传播回每个网络。
如果希望用GPU训练，需要把模型、训练数据、测试数据发送到GPU上，即调用.to(device)。如果需要使用多GPU进行处理，可使模型或相关数据引用nn.DataParallel。

参考文献

吴茂贵,郁明敏,杨本法,李涛,张粤磊. Python深度学习（基于Pytorch）. 北京:机械工业出版社,2019.

---

1. def add_module(self,
   name: str,
   module: Optional[Module]) -> None
   Adds a child module to the current module.
   The module can be accessed as an attribute using the given name.
   Params:
   name – name of the child module. The child module can be accessed from this module using the given name
   module – child module to be added to the module.
   这里module可以是torch.nn中的任何一个网络层模型，例如：conv。
   add_module()方法需要通过torch.nn.Sequential实例化才可以使用。 ↩︎