LeNet-5 手写数字识别

最新推荐文章于 2024-08-26 13:12:24 发布
最新推荐文章于 2024-08-26 13:12:24 发布
阅读量1.7k 收藏 42
点赞数 5
分类专栏： 深度学习 文章标签： 人工智能 深度学习 .net
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/gdz0007/article/details/135043532
版权

LeNet-5 手写数字识别

一、前言

  • LeNet-5出自论文Gradient-Based Learning Applied to Document Recognition，1998年由Yann LeCun提出，是一种用于手写体字符识别的非常高效的卷积神经网络。

  • MNIST 具有50000个训练数据

  • 10000个测试数据

  • 图像大小为28*28

  • 10类

  • 使用Sigmoid激活函数

二、LeNet网络架构

LeNet-5的基本结构包括7层网络结构（不含输入层），其中包括2个卷积层、2个降采样层（池化层）、2个全连接层和输出层。

1、输入层（Input layer）

输入层接收大小为32*32的手写数字图像，其中包括灰度值（0-255）。在实际应用中，我们通常会对输入图像进行预处理，例如对像素值进行归一化，以加快训练速度和提高模型的准确性。

2、卷积层C1（Convolutional layer C1）

卷积层C1包括6个卷积核，每个卷积核的大小为5 * 5，步长为1，填充为0。因此，每个卷积核会产生一个大小为28*28的特征图（输出通道数为6）。

问题一：如何得出产生的特征图尺寸大小？

记住这几个符号：

  • H：图片高度；

  • W：图片宽度；

  • D：原始图片通道数，也是卷积核个数；

  • F：卷积核高宽大小；

  • P：pad图像边扩充大小；

  • S：stride滑动步长。

由输入数据矩阵的尺寸W1 * H1 * D1 (输入层：32 * 32 * 5) ，求输出特征图组尺寸W2 * H2 * D2 ，公式如下：
W2=\dfrac{(W1-F+2pad)}{S}+1


H2=\dfrac{(H1-F+2pad)}{S}+1

W2与H2一般是相等的，带入公式W2=(32-5+2*0)/1+1=28。

  • featuremap为：28 * 28

  • 神经元数量：28 * 28 * 6=4704

  • 可训练参数：（5 * 5+1) * 6（每个滤波器5*5=25个unit参数和一个bias参数，一共6个滤波器）

  • 连接数：（5 * 5+1）* 6 * 28 * 28=122304

详细说明：对输入图像进行第一次卷积运算（使用 6 个大小为 5 * 5 的卷积核），得到6个C1特征图（6个大小为28 * 的 feature maps, 32-5+1=28）。我们再来看看需要多少个参数，卷积核的大小为5 * 5，总共就有6*（5 * 5+1）=156个参数，其中+1是表示一个核有一个bias。对于卷积层C1，C1内的每个像素都与输入图像中的5 * 5个像素和1个bias有连接，所以总共有1562828=122304个连接（connection）。有122304个连接，但是我们只需要学习156个参数，主要是通过权值共享实现的

3、采样层S2（下采样）（Subsampling layer S2）

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

输出特征图尺寸大小 W2=28/2=14。

  • featuremap为：14 * 14

  • 神经元数量：14 * 14 * 6

  • 连接数：（2 * 2+1）* 6 * 14 * 14

4、卷积层C3（Convolutional layer C3）

卷积层C3包括16个卷积核，每个卷积核的大小为5 * 5，步长为1，填充为0。因此，每个卷积核会产生一个大小为10 * 10的特征图（输出通道数为16）。

输出特征图尺寸大小 W2=(14-5+2 * 0)/1+1=10。

  • featuremap为：10 * 10

5、采样层S4（Subsampling layer S4）

采样层S4采用最大池化操作，每个窗口的大小为2 * 2，步长为2。因此，每个池化操作会从4个相邻的特征图中选择最大值，产生一个大小为5 * 5的特征图（输出通道数为16)。

输出特征图尺寸大小 W2=10/2=5。

  • featuremap为：5 * 5

6、全连接层C5（Fully connected layer C5）

C5将每个大小为5 * 5的特征图拉成一个长度为400(5 * 5 * 16)的向量，并通过一个带有120个神经元的全连接层进行连接。120是由LeNet-5的设计者根据实验得到的最佳值。

  • featuremap为：1 * 1

7、全连接层F6（Fully connected layer F6）

全连接层F6将120个神经元连接到84个神经元。

8、输出层（Output layer）

输出层由10个神经元组成，每个神经元对应0-9中的一个数字，并输出最终的分类结果。在训练过程中，使用交叉熵损失函数计算输出层的误差，并通过反向传播算法更新卷积核和全连接层的权重参数。

然而，在实际应用中，通常会对LeNet-5进行一些改进，例如增加网络深度、增加卷积核数量、添加正则化等方法，以进一步提高模型的准确性和泛化能力。

三、基于pytorch的LeNet-5代码实现

# 1################加载库
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.datasets as datasets
import torchvision.transforms as transforms
​
​
# 定义LeNet-5模型
class LeNet5(nn.Module):
    def __init__(self):
        super(LeNet5, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, stride=1)
        self.pool1 = nn.AvgPool2d(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5, stride=1)
        self.pool2 = nn.AvgPool2d(kernel_size=2, stride=2)
        self.fc1 = nn.Linear(in_features=16 * 4 * 4, out_features=120)
        self.fc2 = nn.Linear(in_features=120, out_features=84)
        self.fc3 = nn.Linear(in_features=84, out_features=10)
​
    def forward(self, x):
        x = self.pool1(torch.relu(self.conv1(x)))
        x = self.pool2(torch.relu(self.conv2(x)))
        x = x.view(-1, 16 * 4 * 4)
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x
# 2##########加载MNIST数据集
train_dataset = datasets.MNIST(root='./data', train=True, transform=transforms.ToTensor(), download=True)
test_dataset = datasets.MNIST(root='./data', train=False, transform=transforms.ToTensor())
​
# 定义数据加载器
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)
​
# 定义模型、损失函数和优化器
model = LeNet5()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())
# 3################训练模型
for epoch in range(10):
    for i, (images, labels) in enumerate(train_loader):
        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
​
        if (i + 1) % 100 == 0:
            print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(epoch + 1, 10, i + 1, len(train_loader),
                                                                     loss.item()))
# 4######################测试模型
model.eval()
with torch.no_grad():
    correct = 0
    total = 0
    for images, labels in test_loader:
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
​
    print('Test Accuracy: {:.2f}%'.format(100 * correct / total))

运行结果：

D:\Anaconda\envs\pytorch\python.exe E:/pythoncode/深度学习/LeNet-5.py
Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz
Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ./data\MNIST\raw\train-images-idx3-ubyte.gz
100%|██████████| 9912422/9912422 [00:00<00:00, 11053874.52it/s]
Extracting ./data\MNIST\raw\train-images-idx3-ubyte.gz to ./data\MNIST\raw
​
Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz
Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ./data\MNIST\raw\train-labels-idx1-ubyte.gz
100%|██████████| 28881/28881 [00:00<?, ?it/s]
Extracting ./data\MNIST\raw\train-labels-idx1-ubyte.gz to ./data\MNIST\raw
​
Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz
Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ./data\MNIST\raw\t10k-images-idx3-ubyte.gz
100%|██████████| 1648877/1648877 [00:00<00:00, 6208088.59it/s]
Extracting ./data\MNIST\raw\t10k-images-idx3-ubyte.gz to ./data\MNIST\raw
​
Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz
Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ./data\MNIST\raw\t10k-labels-idx1-ubyte.gz
100%|██████████| 4542/4542 [00:00<?, ?it/s]
Extracting ./data\MNIST\raw\t10k-labels-idx1-ubyte.gz to ./data\MNIST\raw
​
Epoch [1/10], Step [100/938], Loss: 0.6447
Epoch [1/10], Step [200/938], Loss: 0.1975
Epoch [1/10], Step [300/938], Loss: 0.2640
Epoch [1/10], Step [400/938], Loss: 0.3751
Epoch [1/10], Step [500/938], Loss: 0.0927
Epoch [1/10], Step [600/938], Loss: 0.0837
Epoch [1/10], Step [700/938], Loss: 0.2943
Epoch [1/10], Step [800/938], Loss: 0.1807
Epoch [1/10], Step [900/938], Loss: 0.0968
Epoch [2/10], Step [100/938], Loss: 0.1481
Epoch [2/10], Step [200/938], Loss: 0.3320
Epoch [2/10], Step [300/938], Loss: 0.1445
Epoch [2/10], Step [400/938], Loss: 0.0987
Epoch [2/10], Step [500/938], Loss: 0.0935
Epoch [2/10], Step [600/938], Loss: 0.1353
Epoch [2/10], Step [700/938], Loss: 0.0133
Epoch [2/10], Step [800/938], Loss: 0.1472
Epoch [2/10], Step [900/938], Loss: 0.1204
Epoch [3/10], Step [100/938], Loss: 0.0228
Epoch [3/10], Step [200/938], Loss: 0.1182
Epoch [3/10], Step [300/938], Loss: 0.0279
Epoch [3/10], Step [400/938], Loss: 0.0076
Epoch [3/10], Step [500/938], Loss: 0.0838
Epoch [3/10], Step [600/938], Loss: 0.0086
Epoch [3/10], Step [700/938], Loss: 0.0728
Epoch [3/10], Step [800/938], Loss: 0.0883
Epoch [3/10], Step [900/938], Loss: 0.0394
Epoch [4/10], Step [100/938], Loss: 0.0184
Epoch [4/10], Step [200/938], Loss: 0.0496
Epoch [4/10], Step [300/938], Loss: 0.1083
Epoch [4/10], Step [400/938], Loss: 0.0623
Epoch [4/10], Step [500/938], Loss: 0.1034
Epoch [4/10], Step [600/938], Loss: 0.0296
Epoch [4/10], Step [700/938], Loss: 0.0713
Epoch [4/10], Step [800/938], Loss: 0.0128
Epoch [4/10], Step [900/938], Loss: 0.0999
Epoch [5/10], Step [100/938], Loss: 0.0611
Epoch [5/10], Step [200/938], Loss: 0.0081
Epoch [5/10], Step [300/938], Loss: 0.0309
Epoch [5/10], Step [400/938], Loss: 0.0875
Epoch [5/10], Step [500/938], Loss: 0.0992
Epoch [5/10], Step [600/938], Loss: 0.1341
Epoch [5/10], Step [700/938], Loss: 0.0084
Epoch [5/10], Step [800/938], Loss: 0.0211
Epoch [5/10], Step [900/938], Loss: 0.0425
Epoch [6/10], Step [100/938], Loss: 0.0648
Epoch [6/10], Step [200/938], Loss: 0.0218
Epoch [6/10], Step [300/938], Loss: 0.1469
Epoch [6/10], Step [400/938], Loss: 0.0219
Epoch [6/10], Step [500/938], Loss: 0.0035
Epoch [6/10], Step [600/938], Loss: 0.0815
Epoch [6/10], Step [700/938], Loss: 0.0152
Epoch [6/10], Step [800/938], Loss: 0.0890
Epoch [6/10], Step [900/938], Loss: 0.0083
Epoch [7/10], Step [100/938], Loss: 0.0223
Epoch [7/10], Step [200/938], Loss: 0.0326
Epoch [7/10], Step [300/938], Loss: 0.1326
Epoch [7/10], Step [400/938], Loss: 0.0012
Epoch [7/10], Step [500/938], Loss: 0.0485
Epoch [7/10], Step [600/938], Loss: 0.0120
Epoch [7/10], Step [700/938], Loss: 0.0195
Epoch [7/10], Step [800/938], Loss: 0.0552
Epoch [7/10], Step [900/938], Loss: 0.0032
Epoch [8/10], Step [100/938], Loss: 0.0080
Epoch [8/10], Step [200/938], Loss: 0.0208
Epoch [8/10], Step [300/938], Loss: 0.0148
Epoch [8/10], Step [400/938], Loss: 0.0023
Epoch [8/10], Step [500/938], Loss: 0.0120
Epoch [8/10], Step [600/938], Loss: 0.0059
Epoch [8/10], Step [700/938], Loss: 0.0256
Epoch [8/10], Step [800/938], Loss: 0.0281
Epoch [8/10], Step [900/938], Loss: 0.0489
Epoch [9/10], Step [100/938], Loss: 0.0617
Epoch [9/10], Step [200/938], Loss: 0.0120
Epoch [9/10], Step [300/938], Loss: 0.0022
Epoch [9/10], Step [400/938], Loss: 0.0465
Epoch [9/10], Step [500/938], Loss: 0.0199
Epoch [9/10], Step [600/938], Loss: 0.0099
Epoch [9/10], Step [700/938], Loss: 0.0119
Epoch [9/10], Step [800/938], Loss: 0.0767
Epoch [9/10], Step [900/938], Loss: 0.0076
Epoch [10/10], Step [100/938], Loss: 0.0310
Epoch [10/10], Step [200/938], Loss: 0.0056
Epoch [10/10], Step [300/938], Loss: 0.0735
Epoch [10/10], Step [400/938], Loss: 0.0262
Epoch [10/10], Step [500/938], Loss: 0.0060
Epoch [10/10], Step [600/938], Loss: 0.0318
Epoch [10/10], Step [700/938], Loss: 0.0109
Epoch [10/10], Step [800/938], Loss: 0.0428
Epoch [10/10], Step [900/938], Loss: 0.0005
Test Accuracy: 98.72%
​
进程已结束,退出代码0

四、浅谈LeNet-5贡献

LeNet-5在当时的手写数字识别任务中取得了很好的效果，可以达到98%以上的准确率，这是当时最先进的技术水平。它的成功证明了深度学习的潜力，吸引了更多研究者加入到深度学习的研究中。同时，LeNet-5也为后来更加复杂的卷积神经网络奠定了基础，例如AlexNet、VGG、ResNet等。这些网络都采用了类似LeNet-5的卷积神经网络结构，但增加了更多的层数和参数，从而在图像分类、目标检测等任务中取得了更好的效果。虽然LeNet-5在当今深度学习的发展中已经不再是最先进的技术，但它的经典结构和训练方法仍然对深度学习的发展和应用有重要意义。

手写数字识别：LeNet
qq_53093222的博客
03-18 256
首先是前面所述的 MINIST 数据集的载入。Lenet 神经网络的输入是 32 * 32，因此这里首先需要把 MINIST的输入 28 * 28 进行缩放，使其大小为 32 * 32。有了数据集之后，使用一些画图工具（如 Matlplotlib）对 MINIST 数据集的输出绘图，检查输出的图像是否正确。在构建模型的类以后，可以通过输入随机的张量来测试模型的输出结果。在完成模型的构建代码后，下一步需要做的是构建训练和测试代码。LeNet 整个神经网络一共有6个组成部分，最后则是模型的测试模块。
深度卷积网络
m0_60541499的博客
01-18 913
LeNet-5是一种开创性的神经网络结构，针对手写数字识别的灰度图像，网络架构如下图所示：LeNet输入是32×32×132\times32\times132×32×1维的手写数字识别的灰度图像。卷积层1：6个5×55\times55×5卷积核，步幅1，无Padding，输出28×28×628\times28\times628×28×6。池化层1：平均池化，2×22\times22×2卷积核，步幅2，输出14×14×614\times14\time
一文彻底搞懂CNN - 手写数字识别（LeNet-5）
2401_85377976的博客
08-26 1818
传统方法局限性：传统模式识别方法依赖于手工设计的特征提取器，这些方法在处理复杂图像数据时存在局限性，如无法有效应对图像中的平移、形变和扭曲等变化。全连接网络的不足：全连接网络虽然可以作为分类器，但在处理图像数据时存在两个问题：一是参数过多，导致训练困难；二是忽略了输入数据的拓扑结构（如图像的空间相关性）。
基于LeNet实现手写体数字识别实验 [HBU]
weixin_63010525的博客
11-19 380
​​​​​​​数据集手写体数字识别是计算机视觉中最常用的图像分类任务，让计算机识别出给定图片中的手写体数字（0-9共10个数字）。由于手写体风格差异很大，因此手写体数字识别是具有一定难度的任务。。MNIST数据集是计算机视觉领域的经典入门数据集，包含了60,000个训练样本和10,000个测试样本。这些数字已经过尺寸标准化并位于图像中心，图像是固定大小(28×2828×28像素)。
lenet-5模型的手写数字识别
04-17
基于lenet-5手写数字识别神经网络，添加部分代码可充分利用CPU资源
LeNet-5实现手写数字识别
傻福网站
07-07 5827
模型的输入数据是包含手写数字信息的二维图像，将其输入到网络模型中，经过模型的前向计算得到输出的识别结果，通过损失函数度量计算输出结果与输入图像标签的差异度，并通过反向传播算法根据这个差异来调整网络各层的参数值，经过反复迭代输入，最终得到一个能准确识别输入图像的网络模型（输出的识别结果与标签一致）......
使用Lenet-5识别手写数字（含简单GUI测试，简单详细版）
weixin_52520877的博客
03-20 4869
Lenet-5识别手写数字，含简单GUI测试（通俗易懂版）
【深度学习实战—3】：基于LetNet-5的手写数字识别（附Keras实现）
热门推荐
王乐予的博客
03-27 1万+
目录😺一、数据集获取😺二、定义LeNet-5😺三、编译并训练😺四、测试模型😺五、预测结果可视化😺六、建立混淆矩阵😺附录：完整程序 当我们学习了LeNet-5网络和MNIST数据集之后，就要将经典网络用于实战中了！文末附完整程序！ 😺一、数据集获取 """ 数据集获取 """ def get_mnist_dat.
lenet5实现手写数字识别---python
sinat_39288187的博客
05-15 8964
​​​​​​lenet5实现手写数字识别 一. 导入数据集 下载数据集 查看第一张图片的尺寸 输出数据集规模 可知图片尺寸为28*28像素，通道数为1。训练集包含55000张图片，验证集包含5000张图片，测试集包含10000张图片 将训练集进行填充 # 因为mnist数据集的图片是28*28*1的格式，而lenet只接受32*32的格式 # 所以只能在这个基础上...
手写数字识别——基于TensorFlow LeNet-5模型.zip
03-29
《手写数字识别：基于TensorFlow的LeNet-5模型详解》 在现代科技领域，人工智能（AI）已经成为了一个热门话题，而深度学习作为AI的一个重要分支，正在逐步改变我们的生活。TensorFlow作为Google开发的一款强大的...
基于LeNet-5的手写体数字识别
04-24
基于LeNet-5的手写体数字识别
基于LeNet5的手写数字识别系统源码.zip
05-31
基于LeNet5的手写数字识别系统源码基于LeNet5的手写数字识别系统源码。使用说明 train.py 训练 test.py 测试 Mnist 手写数字数据集 readMnist.py 里配置 Mnist 路径（ fpath ） test.py 配置训练的模型 包含了 lenet5.pth 训练好的模型 下面是 lenet5.pth 的测试效果 基于LeNet5的手写数字识别系统源码基于LeNet5的手写数字识别系统源码。使用说明 train.py 训练 test.py 测试 Mnist 手写数字数据集 readMnist.py 里配置 Mnist 路径（ fpath ） test.py 配置训练的模型 包含了 lenet5.pth 训练好的模型 下面是 lenet5.pth 的测试效果
C语言实现神经网络手写数字识别_LeNet-5
07-02
C语言实现神经网络手写数字识别_LeNet-5
LeNet-5:LeNet-5（手写字符识别）
05-15
以上帝的名义 LeNet-5 该存储库包含Tensorflow的 （手写字符识别）的实现，以及使用和进行测试的网络。 训练mnist数据集 要使用mnist数据集训练网络，请在命令提示符下键入以下命令： python3 ./train_mnist.py mnist数据集的样本图像： 结果 时代0 Train Accuracy = 0.121 Test Accuracy = 0.121 Validation Accuracy = 0.128 纪元1 Train Accuracy = 0.963 Test Accuracy = 0.966 Validation Accuracy = 0.964 纪元2 Train Accuracy = 0.976 Test Accuracy = 0.976 Validation Accuracy = 0.977 ... 纪元50 Trai
LeNet-5 手写数字图片识别-深度学习卷积神经网络
03-08
在这个主题中，我们将深入探讨LeNet-5的设计原理、结构、工作流程以及如何应用于手写数字识别。 一、LeNet-5的基本结构 LeNet-5主要由以下几部分构成： 1. **输入层**：通常为28x28像素的手写数字图像，每个像素...
卷积神经网络案例：LeNet-5手写数字识别
qq_31391601的博客
03-21 2922
一、LeNet-5网络结构 1.1 LeNet-5介绍： 由Yann LeCun（杨立昆）于1998年提出的一种经典的卷积网络结构。 第一个成功应用于数字识别问题的卷积神经网络。 1.2 LeNet-5网络结构：共7层 输入层 卷积层 池化层 卷积层 池化层 全连接层 输出层 二、LeNet-5手写数字识别 2.1 MNIST数据集展示：mnist.load_data()加载数据集 from keras.datasets import mnist (X0,Y0),(X1,Y1) = mnist.load_
经典分类网络LeNet5项目：实现手写数字识别项目
一只努力学习的小碗~
05-08 965
使用经典分类网络LeNet5实现手写数字识别项目，对比3层卷积+2层全连接、2层卷积+3层全连接
【深度学习基础】详解Pytorch搭建CNN卷积神经网络LeNet-5实现手写数字识别
Bossfrank的博客
06-19 7208
本文相熟了卷积神经网络CNN的原理，并介绍了如何使用PyTorch框架搭建卷积神经网络模型CNN。实现了LeNet-5的模型的搭建、模型训练、测试、网络的复用、直观查看数据集的图片预测结果等，完成了机器学习领域的Hello world——手写数字识别。
剖析手写数字识别器LeNet-5认识卷积网络
lzhalan2016的博客
08-27 3477
关于卷积神经网络（CNN）的博客网上非常多，也有很多大牛们讲得生动形象，令人十分佩服，也给我的学习带来了很大的帮助，但是关于LeNet-5的具体剖析感觉还没有一篇博文讲得很清楚，本着菜鸟服务菜鸟的精神，写一个通过详细介绍LeNet-5手写识别器的过程来认识卷积网络。 CNN的核心思想无非三种： 1、局部感受野：每个神经元感受局部图像区域； 2、权值共享：同一个滤波器下，每个神经元权值参数是一
lenet-5识别手写数字
最新发布
03-24
### 使用 LeNet-5 实现手写数字识别 LeNet-5 是一种经典的卷积神经网络 (Convolutional Neural Network, CNN)，最初由 Yann LeCun 设计用于解决手写数字识别问题[^1]。该模型通过多层卷积、池化以及全连接操作提取图像中的特征，并最终利用 softmax 分类器完成预测任务。 以下是实现 LeNet-5 手写数字识别的具体方法： #### 数据准备 为了训练和测试 LeNet-5 模型，通常会使用 MNIST 数据集。这是一个广泛使用的数据集，包含 28×28 像素大小的手写数字灰度图片及其对应的标签。可以通过 TensorFlow 或 PyTorch 提供的工具加载此数据集。 ```python import tensorflow as tf from tensorflow.keras import datasets, layers, models # 加载 MNIST 数据集 (train_images, train_labels), (test_images, test_labels) = datasets.mnist.load_data() # 归一化处理像素值至 [0, 1] train_images = train_images / 255.0 test_images = test_images / 255.0 # 将图像扩展为四维张量以适应卷积层输入要求 train_images = train_images[..., tf.newaxis] test_images = test_images[..., tf.newaxis] ``` #### 构建 LeNet-5 模型 按照原始论文描述构建 LeNet-5 的网络结构，主要包括两组卷积层与最大池化层组合，随后接上三组全连接层[^3]。 ```python model = models.Sequential([ # 卷积层 C1: 输入尺寸(28x28x1)，输出尺寸(28x28x6) layers.Conv2D(filters=6, kernel_size=(5, 5), strides=(1, 1), activation='tanh', input_shape=(28, 28, 1)), # 最大池化层 S2: 输出尺寸(14x14x6) layers.AveragePooling2D(pool_size=(2, 2), strides=(2, 2)), # 卷积层 C3: 输出尺寸(10x10x16) layers.Conv2D(filters=16, kernel_size=(5, 5), strides=(1, 1), activation='tanh'), # 最大池化层 S4: 输出尺寸(5x5x16) layers.AveragePooling2D(pool_size=(2, 2), strides=(2, 2)), # 展平层 Fc5: 转换为向量形式 layers.Flatten(), # 全连接层 FC6: 隐藏单元数 120 layers.Dense(units=120, activation='tanh'), # 全连接层 FC7: 隐藏单元数 84 layers.Dense(units=84, activation='tanh'), # 输出层 FC8: Softmax 分类器，类别数量为 10 layers.Dense(units=10, activation='softmax') ]) ``` #### 编译与训练模型 定义损失函数、优化器及评估指标后即可开始训练过程。 ```python # 编译模型 model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(), metrics=['accuracy']) # 训练模型 history = model.fit(train_images, train_labels, epochs=10, validation_split=0.1) # 测试模型性能 test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2) print(f'\nTest accuracy: {test_acc}') ``` 上述代码展示了如何基于 TensorFlow/Keras 平台搭建并运行 LeNet-5 模型来进行手写数字识别的任务[^4]。 --- ####
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

真的卷不栋了

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值