• 💂 个人主页:风间琉璃
• 🤟 版权: 本文由【风间琉璃】原创、在CSDN首发、需要转载请联系博主
• 💬 如果文章对你有帮助、欢迎关注、点赞、收藏(一键三连)和订阅专栏哦

目录

前言 

一、LeNet-5

二、LeNet-5网络实现

1.定义LeNet-5模型

2.加载数据集

3.训练模型

4.测试模型

三、实现图像分类

---

前言 

 LeNet-5是一个经典的深度卷积神经网络，由Yann LeCun在1998年提出，旨在解决手写数字识别问题，被认为是卷积神经网络的开创性工作之一。该网络是第一个被广泛应用于数字图像识别的神经网络之一，也是深度学习领域的里程碑之一。

一、LeNet-5

下图是 LeNet-5 的网络结构图，它 接受32×32大小的数字、字符图片，经过第一个卷积层得到[b，6, 28，28]形状的张量，经过一个向下采样层，张量尺寸缩小到[b,6,14,14]，经过第二个卷积层，得到[b,16,10,10]形状的张量，同样经过下采样层，张量尺寸缩小到[b,16, 5,5]，在进入全连接层之前，先将张量 打成[b，16*5*5 ]的张量，送入输出节点数分别为 120、84 的 2 个全连接层，得到[b,84]的张量，最后通过Gaussian connections层，最终输出[b,10]。

LeNet-5的基本结构包括7层网络结构（不含输入层），其中包括2个卷积层、2个降采样层（池化层）、2个全连接层和输出层。LeNet-5 网络层数较少(2 个卷积层和 2 个全连接层)，参数量较少，计算代价较低，尤其在现代GPU的加持下，数分钟即可训练好 LeNet-5 网络。 

这里网络结构只给了进行卷积核池化前后的特征图的大小，那么如果确定卷积核的尺寸和通道数呢？

1.输入特征层的channel与卷积核的channel相同。

2.输出特征层的channel与卷积核个数相同。

经过卷积后的矩阵尺寸大小计算公式为：

N = (W - F + 2P) /  S  +1

①输入图片大小WxW

②卷积核Filter大小FxF

③步长S

④panding填充值P

比如输入层接收大小为 32×32 的手写数字图像，卷积层C1包括6个卷积核，每个卷积核的大小为 5×5 ，步长为1，填充为0。因此，每个卷积核会产生一个大小为 28×28 的特征图（输出通道数为6）。

N(28) = (32-5+0)/1 + 1 =27 + 1 = 28

采样层S2采用最大池化（max-pooling）操作，每个窗口的大小为 2×2 ，步长为2。因此，每个池化操作会从4个相邻的特征图中选择最大值，产生一个大小为 14×14 的特征图（输出通道数为6）。这样可以减少特征图的大小，提高计算效率，并且对于轻微的位置变化可以保持一定的不变性。其他的网络层也是一样的，可以相互推算。

二、LeNet-5网络实现

1.定义LeNet-5模型

根据上面网络模型使用Pytorch实现LeNet-5网络模型的搭建

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(in_channels=3, out_channels=6, kernel_size=5)
        self.pool1 = nn.MaxPool2d(2, 2)
        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)

    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)
        x = F.relu(self.fc1(x))       # output(120)
        x = F.relu(self.fc2(x))       # output(84)
        x = self.fc3(x)                # output(10)
        return x

if __name__ == '__main__':
    net = LeNet()
    print(net)

2.加载数据集

使用CIFAR10数据集，加载数据集后还需要对数据集进行预处理，如图像格式转换(Tensor)、归一化、标准化等处理。然后使用DataLoader分批次加载数据集，用于训练和测试。

# 预处理
    transform = transforms.Compose(
        [transforms.ToTensor(),  # 将图像转化为tensor，并做归一化：[0,1] 数据类型转换 + 标准化
         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))  # 输入数据的数值范围标准化为特定的均值和标准差
         ]
    )

    # 加载训练集
    train_set = torchvision.datasets.CIFAR10(root='./data', train=True, transform=transform, download=True)
    train_loader = torch.utils.data.DataLoader(train_set, batch_size=36, shuffle=True, num_workers=0)
    # 加载测试集
    val_set = torchvision.datasets.CIFAR10(root='./data', train=False, transform=transform, download=True)
    val_loader = torch.utils.data.DataLoader(val_set, batch_size=5000, num_workers=0)

    # 使用next函数从val_data_iter迭代器中获取下一个批次的数据
    val_data_iter = iter(val_loader)
    val_image, val_label = next(val_data_iter)

3.训练模型

实例化网络模型，并进行网络模型的训练。

    net = LeNet()
    loss_function = nn.CrossEntropyLoss()
    optimizer = optim.Adam(net.parameters(), lr=0.001)

    for epoch in range(10):  # 训练次数
        # 每次训练的损失值
        running_loss = 0.0
        # 获取批次的索引 step 和数据 data
        for step, data in enumerate(train_loader, start=0):
            # 获取images,labels; data是一个列表[images, labels]
            images, labels = data

            # 将优化器的梯度缓冲区清零
            optimizer.zero_grad()
            # forward + backward + optimize
            # 前向传播，得到模型的输出
            outputs = net(images)
            # 计算模型的输出和真实标签 labels 之间的损失（误差）
            loss = loss_function(outputs, labels)
            # 通过反向传播算法计算损失对模型参数的梯度
            loss.backward()
            # 根据梯度更新模型参数，这是优化器的一次参数更新步骤
            optimizer.step()

4.测试模型

在每训练到500次时，进行一次测试。

            # 测试
            running_loss += loss.item()
            if step % 500 == 499:
                # 关闭梯度计算。因为在验证或测试时不需要计算梯度，所以可以提高运行效率
                with torch.no_grad():
                    outputs = net(val_image)  # [batch, 10]
                    # 选择输出中概率最高的类别作为预测结果，并且是在第一个维度[batch,10]
                    # max 返回找到最大的值以及该值所在的位置（索引），是一个元组(val ,index)
                    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))
                    running_loss = 0.0

在网络训练完成后，记得保存网络模型，用于后续的部署和使用。

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

三、实现图像分类

将上面保存的模型用来测试其他图片，检验模型训练的效果。

import torch
import torchvision.transforms as transforms
from PIL import Image, ImageDraw
from model import LeNet

def main():
    # 图片预处理
    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')

    # s实例化网络
    net = LeNet()
    # 加载网络模型
    net.load_state_dict(torch.load('Lenet.pth'))

    img = Image.open('dog.jpg')
    # [H, W, C] --> [C, H, W]
    image = transform(img)
    # 增加维度：[N, C, H, W]，使满足网络的输入维度要求
    image = torch.unsqueeze(image, dim=0)

    with torch.no_grad():
        # 得到预测结果
        outputs = net(image)
        # 得到分类标签
        predict = torch.max(outputs, dim=1)[1].numpy()
    print(classes[int(predict)])
    draw = ImageDraw.Draw(img)
    text = classes[int(predict)]
    # 文本的左上角位置
    position = (10, 10)
    # fill 指定文本颜色
    draw.text(position, text, fill='red')
    img.show()

if __name__ == '__main__':
    main()

预测结果：

结束语
感谢你观看我的文章呐~本次航班到这里就结束啦 🛬

希望本篇文章有对你带来帮助 🎉，有学习到一点知识~

躲起来的星星🍥也在努力发光，你也要努力加油（让我们一起努力叭）。

最后，博主要一下你们的三连呀（点赞、评论、收藏），不要钱的还是可以搞一搞的嘛~

不知道评论啥的，即使扣个666也是对博主的鼓舞吖 💞 感谢 💐