10.PyTorch深度学习实践——卷积神经网络（基础）

本节开始学习卷积神经网络

卷积神经网络(Convolutional Neural Networks, CNN)最早由Alexander Waibel于1987年提出，起初被称作时间延迟网络(Time Delay Neural Network, TDNN)，在Yann LeCun于1989年论述网络结构时提到了“卷积”一词，因此得名。同年Yann LeCun及其合作者的LetNet-5项目为CNN引入了池化层，该项目及其变体不断发展完善CNN，最终定义了现代CNN的基本结构。

还记得上一节中我们使用全连接神经网络训练图像分类，本节我们会使用卷积神经网络进行，我们会先从基本原理与结构介绍，然后上代码。

卷积神经网络由1.输入层，2.卷积层，3.池化层，4.全连接层和5.输出层组成，其中卷积层和池化层可以多次使用并且顺序不固定。在这里我们可以将其看作一个空间变换的过程，中间的众多层最后可以把输出层的维度和形状变换为输出层，实际上这也是一个自动特征提取的过程。

1.卷积层

卷积层对上一层的信息进行处理，主要依靠的是卷积核

由卷积核在输入图像上平滑移动做计算从而得到输出。这里也可以看到卷积神经网络的一大特点即权重共享，这一张图共享了一个卷积核，这就大大地减少了权重数量。
同时我们应该知道对于卷积核的形状是没有限制的，他可以是一个长方形当然我们一般使用正方形。

对于彩色图像，因为其通道数一般是3，而每一个像素矩阵需要一个卷积核，所以我们的卷积核也需要是三维的。多个通道视作一条输入，对应一条输出，如非必要，勿将n条输入视作多个通道的一条输入。

同理，当输入为n通道时

由此可以看出，卷积核维度由输入输出通道数共同决定，所以我们推广到输入n通道，输出m通道时

此时的卷积核是四维张量(m, n, w, h)，可以理解为m个特征提取器，每个提取器是三维张量（n, w, h）

想到一个很好的比喻，把卷积核看作面包，输入通道数使面包变厚，输出通道数使面包数增加。每个面包都会被压成面包片（通过相加），输出通道也决定了有多少面包片。

卷积层代码如下：

import torch

in_channels, out_channels= 5, 10
width, height = 100, 100
kernel_size = 3
batch = 1
input = torch.randn(batch,
in_channels,
width, 
height)
conv_layer = torch.nn.Conv2d(in_channels, 
out_channels,
kernel_size=kernel_size)
output = conv_layer(input)
print(input.shape)
print(output.shape)
print(conv_layer.weight.shape)

另外卷积核还可以设置的参数有stride（步长），padding（填充）

2.池化层

池化层主要的工作是下采样降维度，起到了压缩特征减少计算量的作用。
池化层有多种，拿常用的最大池化层举一个例子。

maxpooling尺寸为n时，其默认步长也为n
关于池化层更详细的介绍如下
传送门

3.全连接层

全连接层做了一个很普通的工作，把特征排成一维张量。
本质上就是一个线性模型。

在张量前向流动时，卷积核池化层不在意尺寸，但是本层需要得知尺寸，我们可以手动计算，也可以在上一层输出一下维度得知尺寸。

4.上代码

先看一下整个网络变换过程，然后我们围观代码。例子就还用上一节的多分类数据集。

本次我们还会更进一步，使用GPU进行训练。目前是只有N卡才支持GPU训练（需要安装CUDA），做法也很简单总共需要三步：

1. 定义GPU
2. 把模型放入GPU
3. 把样本和标签放入GPU

对应

1. device = torch.device(“cuda:0” if torch.cuda.is_available() else “cpu”)
   model.to(device)
2. model.to(device)
3. inputs, target = inputs.to(device), target.to(device)

这里的cuda:0是指第一块显卡，同理还可能cuda:1，大佬还会有cuda:n😂，需要注意把模型和对应训练集放入同一块GPU

import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim

batch_size = 64
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307, ), (0.3081, ))
])
train_dataset = datasets.MNIST(root='data/MNIST/',
                               train=True,
                               download=True,
                               transform=transform)
train_loader = DataLoader(train_dataset,
                          shuffle=True,
                          batch_size=batch_size)
test_dataset = datasets.MNIST(root='data/MNIST/',
                              train=False,
                              download=True,
                              transform=transform)
test_loader = DataLoader(test_dataset,
                         shuffle=False,
                         batch_size=batch_size)


class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = torch.nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = torch.nn.Conv2d(10, 20, kernel_size=5)
        self.pooling = torch.nn.MaxPool2d(2)
        self.fc = torch.nn.Linear(320, 10)

    def forward(self, x):
        # Flatten data from (n, 1, 28, 28) to (n, 784)
        batch_size = x.size(0)
        x = F.relu(self.pooling(self.conv1(x)))
        x = F.relu(self.pooling(self.conv2(x)))
        x = x.view(batch_size, -1) # flatten 2维需要扁平
        x = self.fc(x)
        return x


model = Net()
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model.to(device)

criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)


def train(epoch):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, target = data
        inputs, target = inputs.to(device), target.to(device)
        optimizer.zero_grad()
        # forward + backward + update
        outputs = model(inputs)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        if batch_idx % 300 == 299:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
            running_loss = 0.0


def test():
    correct = 0
    total = 0
    #测试无需BP，无需计算梯度
    with torch.no_grad():
        for data in test_loader:
            inputs, target = data
            inputs, target = inputs.to(device), target.to(device)
            outputs = model(inputs)
            _, predicted = torch.max(outputs.data, dim=1)
            total += target.size(0)
            correct += (predicted == target).sum().item()
    print('Accuracy on test set: %d %%' % (100 * correct / total))


if __name__ == '__main__':
    for epoch in range(10):
        train(epoch)
        test()