CNN经典网络（1）---LeNet（模型搭建+训练+预测+可视化）

写在前面：根据b站博主霹雳吧啦Wz 学习CNN，作为个人的学习记录。

目录

模型参数：

模型搭建：

应用：

训练：

训练结果：

预测： 

预测结果：

数据可视化：

---

模型参数：

LeNet是上个世纪出现的典型卷积神经网络，最早用于数字识别的CNN。

输入层为32*32大小，除了输入共有7层。详细内容如下图所示

模型搭建：

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, 6, 5)   # 输入通道大小，输出通道大小，卷积核大小
        self.pool1 = nn.MaxPool2d(2, 2)    # 卷积核大小，步距stride
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.pool2 = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(16*5*5, 120)   # 上一层的输出，节点个数（输出大小）
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)        # 这里的10，是最后要分为10个类别。

    def forward(self, x):
        x = F.relu(self.conv1(x))    # input(3, 32, 32) output(6, 28, 28)
        x = self.pool1(x)            # output(6, 14, 14)
        x = F.relu(self.conv2(x))    # output(16, 10, 10)
        x = self.pool2(x)            # output(16, 5, 5)
        x = x.view(-1, 16*5*5)       # output(16*5*5)   # 使用view函数展平成一维向量
        x = F.relu(self.fc1(x))      # output(120)
        x = F.relu(self.fc2(x))      # output(84)
        x = self.fc3(x)              # output(10)
        return x

应用：

使用torchvision.datasets下面的CIFAR10数据集进行分类，该数据集有飞机、汽车、鸟、猫等3*32*32大小的十种类别图像。

训练：

import torch
import torchvision
import torch.nn as nn
from model import LeNet
import torch.optim as optim
import torchvision.transforms as transforms

def main():
    ### 1.图像预处理
    # transform：对图像进行预处理的函数
    transform = transforms.Compose(
        [transforms.ToTensor(),
         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
    
    ### 2.下载且划分训练集和验证集
    # 50000张训练图片
    # 第一次使用时要将download设置为True才会自动去下载数据集
    train_set = torchvision.datasets.CIFAR10(root='./data', train=True,
                                             download=False, transform=transform)
    train_loader = torch.utils.data.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 = torch.utils.data.DataLoader(val_set, batch_size=5000,
                                             shuffle=False, num_workers=0)
    val_data_iter = iter(val_loader)    # 将val_loader转化为一个可迭代的迭代器
    val_image, val_label = next(val_data_iter)   # 获取迭代器中的这批数据。在这里的标签已经变成0-9这些数字标签了

    classes = ('plane', 'car', 'bird', 'cat',
               'deer', 'dog', 'frog', 'horse', 'ship', 'truck')  # 类别
    
    ### 3.定义网络、损失函数、优化器
    net = LeNet()   # 网络
    loss_function = nn.CrossEntropyLoss()  # 定义损失函数
    optimizer = optim.Adam(net.parameters(), lr=0.001)    # 定义优化器
    
    ### 4.训练
    # 迭代5次
    for epoch in range(5):  # loop over the dataset multiple times

        running_loss = 0.0  
        for step, data in enumerate(train_loader, start=0):
            # get the inputs; data is a list of [inputs, labels]
            inputs, labels = data

            # zero the parameter gradients
            optimizer.zero_grad()     # 清零历史梯度
            # forward + backward + optimize
            outputs = net(inputs)     # 进入网络，通过正向传播获得输出
            loss = loss_function(outputs, labels)   # 计算损失。outputs是网络预测值，labels是真实标签
            loss.backward()   # 反向传播
            optimizer.step()  # 通过优化器进行参数更新

            # print statistics
            running_loss += loss.item()   # 计算出损失就加到running_loss里
            if step % 500 == 499:    # print every 500 mini-batches   # 每隔500步打印一次数据信息
                with torch.no_grad():    # 不计算每个节点的误差梯度
                    outputs = net(val_image)  # [batch, 10]   # 验证集进入网络进行预测，获得所有的预测结果和预测值
                    predict_y = torch.max(outputs, dim=1)[1]  # 寻找概率最大的索引在哪
                    accuracy = torch.eq(predict_y, val_label).sum().item() / val_label.size(0)          # 将预测值与真实值进行对比，如果相等，eq(predict_y, val_label)返回为1，否则为0；然后用sum求和求出预测对了多少，获得求和数值后再除以总的验证集大小，就是准确率

                    print('[%d, %5d] train_loss: %.3f  test_accuracy: %.3f' %
                          (epoch + 1, step + 1, running_loss / 500, accuracy))
                    running_loss = 0.0   # 损失清零，进行下一次五百步的训练

    print('Finished Training')
    
    ### 5.保存参数
    save_path = './Lenet.pth'
    torch.save(net.state_dict(), save_path)


if __name__ == '__main__':
    main()

分为五步：

• 定义图像预处理方式：transforms是图像预处理包，用compose把多个步骤整合在一起。ToTensor是首先将原来为（高*宽*通道数）图像变成（通道数*高*宽），因为在模型那里的图像格式是（C*H*W）；然后将图像像素值从[0,255]变成[0,1]，即归一化。Normalize是用均值和标准差归一化张量图像，将像素值变成[-1,1];具体来说，img=(img-mean)/std，其中mean和std是设置的参数决定，三个值代表三个通道。
• 下载且划分训练集和验证集：torch.utils.data.DataLoader对数据进行batch的划分，返回所有样本的img和label。参数：dataset：包含所有数据的数据集；batch_size每一组所包含数据的数量;shuffle：是否打乱数据位置，True是打乱；num_workers使用线程的数量，一般都为0。
• 定义网络、损失函数、优化器
• 训练
• 保存训练好的参数（模型）

训练结果：

 在32*32大小的图片上预测结果有67.4%，也不容易的...

预测： 

随便找一张图片，修改预测程序中的第三步图片位置信息和名称，运行。

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

from model import LeNet


def main():
    ### 1.图像预处理，网络输入需要32*32的，所以要先resize，然后归一化和标准化和训练时一样
    transform = transforms.Compose(
        [transforms.Resize((32, 32)),
         transforms.ToTensor(),
         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')
    
    ### 2.载入网络和训练好的模型参数
    net = LeNet()
    net.load_state_dict(torch.load('Lenet.pth'))
    
    ### 3.打开一张图片
    im = Image.open('1.jpg')
    im = transform(im)  # [C, H, W]
    im = torch.unsqueeze(im, dim=0)  # [N, C, H, W]，unsqueeze用于增加一个batch

    ### 4.和训练那里一样，不计算误差梯度
    with torch.no_grad():
        outputs = net(im)  # 通过网络后的预测值和概率
        predict = torch.max(outputs, dim=1)[1].numpy()    # 概率最大值的所在索引返回给predict
    print(classes[int(predict)])    # 打印出索引所在的类别


if __name__ == '__main__':
    main()

预测结果：

图片：

预测结果： 

数据可视化：

用tensorboard将训练次数-loss值、训练次数-准确率、网络架构画出来：

 此时完整代码：

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.tensorboard import SummaryWriter

def main():

    n=0
    # transform：对图像进行预处理的函数
    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 = torch.utils.data.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 = torch.utils.data.DataLoader(val_set, batch_size=5000,
                                             shuffle=False, num_workers=0)
    val_data_iter = iter(val_loader)
    val_image, val_label = next(val_data_iter)

    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)    # 定义优化器

    # dummy_input = torch.rand(512, 1, 28, 28)  # 网络中输入的数据维度
    # with SummaryWriter(comment='LeNet') as w:
    #     w.add_graph(net, (dummy_input,))  # net是你的网络名

    for epoch in range(5):  # loop over the dataset multiple times

        running_loss = 0.0
        for step, data in enumerate(train_loader, start=0):
            # get the inputs; data is a list of [inputs, labels]
            inputs, labels = data

            # zero the parameter gradients
            optimizer.zero_grad()
            # forward + backward + optimize

            outputs = net(inputs)
            loss = loss_function(outputs, labels)
            loss.backward()
            optimizer.step()


            # print statistics
            running_loss += loss.item()
            if step % 500 == 499:    # print every 500 mini-batches
                with torch.no_grad():
                    outputs = net(val_image)  # [batch, 10]
                    predict_y = torch.max(outputs, dim=1)[1]
                    accuracy = torch.eq(predict_y, val_label).sum().item() / val_label.size(0)

                    print('[%d, %5d] train_loss: %.3f  test_accuracy: %.3f' %
                          (epoch + 1, step + 1, running_loss / 500, accuracy))


                    writer = SummaryWriter("runs/logs_fina")  # 存放log文件的目录
                    writer.add_scalar('train_loss', running_loss / 500, n)  # 画loss，横坐标为训练次数
                    writer.add_scalar('test_accuracy', accuracy, n)  # 画accuracy，横坐标为训练次数
                    writer.add_graph(net, inputs)
                    n+=1
                    running_loss = 0.0


    writer.close()
    print('Finished Training')

    save_path = './Lenet.pth'
    torch.save(net.state_dict(), save_path)


if __name__ == '__main__':
    main()