卷积神经网络理解（3）

1、定义

LeNet是深度学习领域的一个经典卷积神经网络模型，由Yann LeCun等人于1998年提出，被广泛应用于手写数字识别和其他图像识别任务。

LeNet的网络结构相对简单，包含两个卷积层和三个全连接层，是卷积神经网络的基础。

LeNet对于现代的图像识别任务来说可能过于简单，但其对于深度学习的发展有着重要的贡献，是深度学习领域不可或缺的一部分。

总体来看，LeNet（LeNet-5）由两个部分组成：

卷积编码器：由两个卷积层组成;

全连接层密集块：由三个全连接层组成。

输入层：接收输入的图像数据，一般为灰度图或者RGB彩色图像。

第一个卷积层：对输入进行卷积操作，使用的卷积核的大小为5x5，输出通道数为6，不使用填充，步幅为1。

第一个池化层：对第一个卷积层的输出进行下采样，使用的窗口大小为2x2，步幅为2，池化方式为平均池化或最大池化。

第二个卷积层：对第一个池化层的输出进行卷积操作，使用的卷积核的大小为5x5，输出通道数为16，不使用填充，步幅为1。

第二个池化层：对第二个卷积层的输出进行下采样，使用的窗口大小为2x2，步幅为2，池化方式为平均池化或最大池化。

全连接层1：将第二个池化层的输出展开成向量，并经过一个全连接层，输出大小为120。

全连接层2：对第一层全连接层的输出进行处理，输出大小为84。

输出层：对第二层全连接层的输出进行处理，输出大小为分类任务的类别数目。

手写数字识别的架构如图所示。

             

 在此图示中，输入图片的尺寸为32*32，图示有误

C1层（卷积层）：6@28×28
该层使用了6个卷积核，每个卷积核的大小为5×5，这样就得到了6个feature map（特征图）。
每个卷积核（5×5）与原始的输入图像（32×32）进行卷积，这样得到的feature map（特征图）大小为（32-5+1）×（32-5+1）= 28×28

S2层（下采样层，也称池化层）：6@14×14
这一层主要是做池化或者特征映射（特征降维），池化单元为2×2，因此，6个特征图的大小经池化后即变为14×14。
回顾本文刚开始讲到的池化操作，池化单元之间没有重叠，在池化区域内进行聚合统计后得到新的特征值，因此经2×2池化后，每两行两列重新算出一个特征值出来，相当于图像大小减半，
因此卷积后的28×28图像经2×2池化后就变为14×14。

C3层（卷积层）：16@10×10
C3层有16个卷积核，卷积模板大小为5×5。每个卷积核都与S2的6@14*14进行互关系运算，得到16个通道
与C1层的分析类似，C3层的特征图大小为（14-5+1）×（14-5+1）= 10×10

S4（下采样层，也称池化层）：16@5×5
与S2的分析类似，池化单元大小为2×2，因此，该层与C3一样共有16个特征图，每个特征图的大小为5×5。

C5层（卷积层/全连接层）：120
该层有120个卷积核，每个卷积核的大小仍为5×5，因此有120个特征图。由于S4层的大小为5×5，而该层的卷积核大小也是5×5，
因此特征图大小为（5-5+1）×（5-5+1）= 1×1。这样该层就刚好变成了全连接，这只是巧合，如果原始输入的图像比较大，则该层就不是全连接了。

F6层（全连接层）：84
F6层有84个单元，之所以选这个数字的原因是来自于输出层的设计，对应于一个7×12的比特图。

OUTPUT层（输出层）：10
Output层也是全连接层，共有10个节点，分别代表数字0到9。如果第i个节点的值为0，则表示网络识别的结果是数字i。

2、实现　　

模型

import torch
from torch import nn
from d2l import torch as d2l

net = nn.Sequential(
    nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Conv2d(6, 16, kernel_size=5), nn.Sigmoid(),
    nn.AvgPool2d(kernel_size=2, stride=2),
    nn.Flatten(),
    nn.Linear(16 * 5 * 5, 120), nn.Sigmoid(),
    nn.Linear(120, 84), nn.Sigmoid(),
    nn.Linear(84, 10))

或者是

import torch.nn as nn
import torch.nn.functional as F

class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
        self.conv1 = nn.Conv2d(3, 16, 5) # in_channels=3 out_channels=16 kernel=5
        self.pool1 = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(16, 32, 5)
        self.pool2 = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(32*5*5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)
    # 调用上面定义的函数
    def forward(self, x):
        x = F.relu(self.conv1(x))    # input(3, 32, 32) output(16, 28, 28)
        x = self.pool1(x)            # output(16, 14, 14)
        x = F.relu(self.conv2(x))    # output(32, 10, 10)
        x = self.pool2(x)            # output(32, 5, 5)
        x = x.view(-1, 32*5*5)       # output(32*5*5)
        x = F.relu(self.fc1(x))      # output(120)
        x = F.relu(self.fc2(x))      # output(84)
        x = self.fc3(x)              # output(10)
        return x

训练

import torch
import torchvision
import torch.nn as nn

from model import LeNet
import torch.optim as optim
import torchvision.transforms as transforms
from torch.utils.data import DataLoader

def main():
    transform = transforms.Compose(
        [transforms.ToTensor(),
         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

    # 50000张训练图片
    # 第一次使用时要将download设置为True才会自动去下载数据集
    train_set = torchvision.datasets.CIFAR10(root='./data', train=True,
                                             download=False, transform=transform)
    train_loader = DataLoader(train_set, batch_size=36,
                                               shuffle=True, num_workers=0)

    # 10000张验证图片
    # 第一次使用时要将download设置为True才会自动去下载数据集
    val_set = torchvision.datasets.CIFAR10(root='./data', train=False,
                                           download=False, transform=transform)
    val_loader = DataLoader(val_set, batch_size=5000,
                                             shuffle=False, num_workers=0)
    val_data_iter = iter(val_loader)
    val_image, val_label = val_data_iter.next()

    # classes = ('plane', 'car', 'bird', 'cat',
    #            'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

    # 定义模型和损失函数
    net = LeNet()
    loss_function = nn.CrossEntropyLoss()

    # 定义优化器
    optimizer = optim.Adam(net.parameters(),lr=0.001)

    # 对训练集迭代5次
    epochs = 5
    for epoch in range(epochs):
        running_loss = 0
        for step,data in enumerate(train_loader,start=0): # step从start开始
            inputs,labels = data
            # 梯度清零
            optimizer.zero_grad()

            outputs = net(inputs)
            # 计算损失函数
            loss = loss_function(outputs,labels)
            # 反向传播并更新参数
            loss.backward()
            optimizer.step()

            running_loss += loss.item()
            if step%500 == 499:
                with torch.no_grad():
                    outputs = net(val_image)
                    predict_y = torch.max(outputs,dim=1)[1]
                    accuracy = (predict_y==val_label).sum().item() / val_label.size(0)
                    print('[%d  %3d] train_loss: %.3f test_accuracy: %.3f' %
                          (epoch+1,step+1,running_loss/500,accuracy))
                    running_loss = 0

    print('Finished Training')
    save_path = './Lenet.pth'
    torch.save(net.state_dict(),save_path)
if __name__ == '__main__':
    main()

这段代码是一个基于LeNet网络结构进行CIFAR10分类的训练代码，主要步骤如下：

导入必要的Python包，包括PyTorch中的torch、torchvision、torch.nn等模块，以及用于数据加载的DataLoader。
定义数据预处理，包括将图像转换为Tensor格式、标准化处理等操作。
加载训练集和验证集，使用DataLoader将数据分批次读取。
定义LeNet网络结构和损失函数，此处使用交叉熵损失函数。
定义Adam优化器。
进行训练，共进行5个epoch，每个epoch对训练集进行一次完整的遍历，每次遍历对数据分批次读取并进行网络的前向计算、反向传播、参数更新等操作。
每500个batch输出一次训练损失和测试精度。
保存训练好的模型参数。

测试

import torch
import torchvision.transforms as transforms
from PIL import Image

from model import LeNet


def main():
    transform = transforms.Compose(
        [transforms.Resize((32, 32)), # 对输入的图片尺寸进行调整
         transforms.ToTensor(), # Convert a ``PIL Image`` or ``numpy.ndarray`` to tensor. (H x W x C)->(C x H x W)
         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

    classes = ('plane', 'car', 'bird', 'cat',
               'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
    
    net = LeNet()
    net.load_state_dict(torch.load('Lenet.pth')) # 加载模型

    im = Image.open('data/plane.jpg')
    im = transform(im)  # [C, H, W]
    # 增加一个维度，batch
    im = torch.unsqueeze(im, dim=0)  # [N, C, H, W] 增加一个batch维度

    with torch.no_grad():
        outputs = net(im)
        predict = torch.max(outputs, dim=1)[1].numpy()
    print(classes[int(predict)])

if __name__ == '__main__':
    main()