LeNet网络模型代码实现与示例

一、LeNet-5网络结构

Lenet是一个 7 层的神经网络&＃xff0c;包含 3 个卷积层&＃xff0c;2 个池化层&＃xff0c;1 个全连接层。其中所有卷积层的所有卷积核都为 5x5&＃xff0c;步长 stride&＃61;1&＃xff0c;池化方法都为全局 pooling&＃xff0c;激活函数为 Sigmoid。
整个 LeNet-5 网络总共包括7层&＃xff08;不含输入层&＃xff09;&＃xff0c;分别是&＃xff1a;C1、S2、C3、S4、C5、F6、OUTPUT。

二、Lenet的keras实现

如今各大深度学习框架中所使用的LeNet都是简化改进过的LeNet-5&＃xff0c;和原始的LeNet有些许不同&＃xff0c;把激活函数改为了现在很常用的ReLu。

import tensorflow as tf
from tensorflow import keras
from keras.models import Sequential
from keras.layers import Conv2D
from keras.layers import MaxPooling2D, Flatten
from keras.layers import Densedef LeNet():# model &＃61; tf.keras.models.Sequential()model &＃61; Sequential()model.add(Conv2D(32, (5,5), strides&＃61;(1,1), input_shape&＃61;(28,28,1), padding&＃61;&＃39;valid&＃39;,activation&＃61;&＃39;relu&＃39;, kernel_initializer&＃61;&＃39;uniform&＃39;))model.add(MaxPooling2D(pool_size&＃61;(2,2)))model.add(Conv2D(64, (5,5), strides&＃61;(1,1), padding&＃61;&＃39;valid&＃39;,activation&＃61;&＃39;relu&＃39;, kernel_initializer&＃61;&＃39;uniform&＃39;))model.add(MaxPooling2D(pool_size&＃61;(2,2)))model.add(Flatten())model.add(Dense(100, activation&＃61;&＃39;relu&＃39;))model.add(Dense(10, activation&＃61;&＃39;softmax&＃39;))return modelmodel &＃61; LeNet()
model.summary()


三、Lenet的pytorch实现

import torch
import torch.nn as nn
import torch.nn.functional as Fclass LeNet5(nn.Module):def __init__(self, num_classes, grayscale&＃61;False):&＃39;&＃39;&＃39;:param num_classes: 分类的数量:param grayscale: 是否为灰度图&＃39;&＃39;&＃39;super(LeNet5, self).__init__()self.grayscale &＃61; grayscaleself.num_classes &＃61; num_classesif self.grayscale: # 可以适用单通道和三通道的图像in_channels &＃61; 1else:in_channels &＃61; 3# 卷积神经网络self.features &＃61; nn.Sequential(nn.Conv2d(in_channels, 6, kernel_size&＃61;5),nn.MaxPool2d(kernel_size&＃61;2),nn.Conv2d(6, 16, kernel_size&＃61;5),nn.MaxPool2d(kernel_size&＃61;2))# 分类器self.classifier &＃61; nn.Sequential(nn.Linear(16*5*5, 120), # 这里把第三个卷积当作是全连接层nn.Linear(120, 84),nn.Linear(84, num_classes))def forward(self, x):x &＃61; self.features(x) # 输出16*5*5特征图x &＃61; torch.flatten(x, 1) # 展平&＃xff08;1,16*5*5&＃xff09;logits &＃61; self.classifier(x) # 输出10probas &＃61; F.softmax(logits, dim&＃61;1)return logits, probasnum_classes &＃61; 10 # 分类数目
grayscale &＃61; True # 是否为灰度图
data &＃61; torch.rand((1, 1, 32, 32))
print(&＃39;input data:\n&＃39;, data, &＃39;\n&＃39;)
model &＃61; LeNet5(num_classes, grayscale)
logits, probas &＃61; model(data)
print(&＃39;logits:\n&＃39;, logits)
print(&＃39;probas:\n&＃39;, probas)

四、手写数字识别&＃xff08;keras&＃xff09;

4.1 手写数字识别代码1

import tensorflow as tf
from tensorflow.keras import datasets, layers, models
import matplotlib.pyplot as plt
# from keras.layers import Conv2D, MaxPooling2D, Flatten, Dense# 1.导入数据
(train_images, train_labels), (test_images, test_labels) &＃61; datasets.mnist.load_data()# 2.归一化
# 将像素的值标准化至0到1的区间内
train_images, test_images &＃61; train_images/255.0, test_images/255.0
train_images.shape, test_images.shape, train_labels.shape, test_labels.shape
# 输出&＃xff1a;((60000, 28, 28), (10000, 28, 28), (60000,), (10000,))# 3.可视化图片
plt.figure(figsize&＃61;(20,20))
for i in range(20):plt.subplot(5, 10, i&＃43;1)plt.xticks([])plt.yticks([])plt.grid(False)plt.imshow(train_images[i], cmap&＃61;&＃39;gray&＃39;)# plt.imshow(train_images[i], cmap&＃61;plt.cm.binary)plt.xlabel(train_labels[i])
plt.show()# 4.调整图片格式
train_images &＃61; train_images.reshape((60000, 28, 28, 1))
test_images &＃61; test_images.reshape((10000, 28, 28, 1))train_images, test_images &＃61; train_images/255.0, test_images/255.0
train_images.shape, test_images.shape, train_labels.shape, test_labels.shape
# 输出&＃xff1a;((60000, 28, 28, 1), (10000, 28, 28, 1), (60000,), (10000,))# 5. 模型构建
# 构建LeNet-5网络模型
model &＃61; models.Sequential([layers.Conv2D(32, (3, 3), activation&＃61;&＃39;relu&＃39;, input_shape&＃61;(28, 28, 1)),layers.MaxPooling2D((2, 2)),layers.Conv2D(64, (3, 3), activation&＃61;&＃39;relu&＃39;),layers.MaxPooling2D((2, 2)),layers.Flatten(),layers.Dense(64, activation&＃61;&＃39;relu&＃39;),layers.Dense(10)
])# 6. 打印网络结构
model.summary()# 7. 模型编译
model.compile(optimizer&＃61;&＃39;adam&＃39;,loss&＃61;tf.keras.losses.SparseCategoricalCrossentropy(from_logits&＃61;True),metrics&＃61;[&＃39;accuracy&＃39;])# 8. 模型训练
history &＃61; model.fit(train_images, train_labels, epochs&＃61;2,validation_data&＃61;(test_images, test_labels))# 显示第一张图片
plt.imshow(test_images[1], cmap&＃61;&＃39;gray&＃39;)
# 输出预测结果
pre &＃61; model.predict(test_images)
# 输出测试集中第一张图片的预测结果
pre[1]


可视化图片

模型结构及参数

显示第一张图片

输出测试集中第一张图片的预测结果

4.2 手写数字识别代码2

# Mnist手写数字识别
# 使用TensorFlow搭建LeNet-5网络模型&＃xff0c;实现MNIST手写数字识别import tensorflow as tf
from tensorflow import keras
from keras.datasets import mnist
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers import Conv2D, MaxPooling2D, Flatten
from keras.layers.core import Dense, Activation, Dropout
from keras.utils.vis_utils import plot_model
import matplotlib.pyplot as plt(X_train,Y_train), (X_test,Y_test) &＃61; mnist.load_data()
X_test1 &＃61; X_test
Y_test1 &＃61; Y_testX_train &＃61; X_train.reshape(-1,28,28,1).astype(&＃39;float32&＃39;)/255.0
X_test &＃61; X_test.reshape(-1,28,28,1).astype(&＃39;float32&＃39;)/255.0
&＃39;&＃39;&＃39;
x &＃61; tf.reshape(x, shape&＃61;[-1, 28, 28, 1])
x_image &＃61; tf.reshape(x, [-1, 28, 28, 1])
Mnist中数据&＃xff0c;输入n个样本&＃xff0c;每个样本是28*28&＃61;784个列构成的向量。所以输入的是n*784的矩阵。
但是输入到CNN中需要卷积&＃xff0c;需要每个样本都是矩阵。
这里是将一组图像矩阵x重建为新的矩阵&＃xff0c;该新矩阵的维数为&＃xff08;a&＃xff0c;28&＃xff0c;28&＃xff0c;1&＃xff09;&＃xff0c;其中-1表示a由实际情况来定。
例如&＃xff0c;x是一组图像的矩阵&＃xff08;假设是50张&＃xff0c;大小为56×56&＃xff09;&＃xff0c;则执行则执行x_image &＃61; tf.reshape(x, [-1, 28, 28, 1])
可以计算a&＃61;50×56×56/28/28/1&＃61;200。即x_image的维数为&＃xff08;200&＃xff0c;28&＃xff0c;28&＃xff0c;1&＃xff09;
&＃39;&＃39;&＃39;"""
astype&＃xff1a;实现变量类型转换。使用 .astype() 方法在不同的数值类型之间相互转换。
a.astype(int) # 将a的数值类型转换为 int。Python中与数据类型相关函数及属性有如下三个&＃xff1a;type/dtype/astype
type() 返回参数的数据类型
dtype 返回数组中元素的数据类型
astype() 对数据类型进行转换 """# 标签预处理
nb_classes &＃61; 10
Y_train &＃61; np_utils.to_categorical(Y_train, nb_classes)
Y_test &＃61; np_utils.to_categorical(Y_test, nb_classes)
"""
np_utils.to_categorical()函数
to_categorical()用于分类&＃xff0c;将标签转为one-hot编码。。
"""# 模型搭建
model &＃61; Sequential()
model.add(Conv2D(filters&＃61;6, # 卷积核个数kernel_size&＃61;(5,5), # 卷积核大小5*5strides&＃61;1, # 步长padding&＃61;&＃39;same&＃39;, # 像素填充方式activation&＃61;&＃39;tanh&＃39;, # 激活函数input_shape&＃61;(28,28,1) # 输入数据28*28))
model.add(MaxPooling2D(pool_size&＃61;(2,2), # 池化窗口大小2*2strides&＃61;2, # 池化步长为2padding&＃61;&＃39;same&＃39; # 像素填充方式为same))
model.add(Conv2D(filters&＃61;16, kernel_size&＃61;(5,5), padding&＃61;&＃39;same&＃39;, activation&＃61;&＃39;tanh&＃39;))
model.add(MaxPooling2D(pool_size&＃61;(2,2), strides&＃61;1, padding&＃61;&＃39;same&＃39;))
model.add(Flatten())
# 全连接层
model.add(Dense(120))
model.add(Activation(&＃39;tanh&＃39;))
model.add(Dropout(0.2))# 设置为0.2&＃xff0c;改层会随机忽略20%的神经元
model.add(Dense(84))
model.add(Activation(&＃39;tanh&＃39;))
# 输出层
model.add(Dense(nb_classes))
model.add(Activation(&＃39;softmax&＃39;))# 显示模型摘要
model.summary()
plot_model(model&＃61;model, to_file&＃61;&＃39;model_cnn.png&＃39;, show_shapes&＃61;True)# 模型编译
model.compile(optimizer&＃61;&＃39;adam&＃39;, loss&＃61;&＃39;categorical_crossentropy&＃39;, metrics&＃61;[&＃39;accuracy&＃39;])# 模型训练
nb_epoch &＃61; 10
batchsize &＃61; 512
# training &＃61; model.fit(x&＃61;X_train, y&＃61;Y_train, batch_size&＃61;batchsize, epochs&＃61;nb_epoch,
# verbose&＃61;2, validation_split&＃61;0.2)
training &＃61; model.fit(x&＃61;X_train, y&＃61;Y_train, batch_size&＃61;batchsize, epochs&＃61;2,verbose&＃61;2, validation_split&＃61;0.2)# 画出训练过程随着迭代&＃xff08;epoch&＃xff09;准确率的变化图
def show_accuracy1(train_history, train, validation):plt.plot(training.history[train], linestyle&＃61;&＃39;-&＃39;, color&＃61;&＃39;b&＃39;)plt.plot(training.history[validation], linestyle&＃61;&＃39;--&＃39;, color&＃61;&＃39;r&＃39;)plt.title(&＃39;Training_accuray&＃39;)plt.xlabel(&＃39;epoch&＃39;)plt.ylabel(&＃39;train&＃39;)plt.legend([&＃39;train&＃39;, &＃39;validation&＃39;], loc&＃61;&＃39;lower right&＃39;)plt.show()
show_accuracy1(training, &＃39;accuracy&＃39;, &＃39;val_accuracy&＃39;)# 画出训练过程中随着迭代次数&＃xff08;epoch&＃xff09;误差的变化图
def show_accuracy2(train_history, train, validation):plt.plot(training.history[train], linestyle&＃61;&＃39;-&＃39;, color&＃61;&＃39;b&＃39;)plt.plot(training.history[validation], linestyle&＃61;&＃39;--&＃39;, color&＃61;&＃39;r&＃39;)plt.title(&＃39;Training_loss&＃39;)plt.xlabel(&＃39;epoch&＃39;)plt.ylabel(&＃39;train&＃39;)plt.legend([&＃39;train&＃39;, &＃39;validation&＃39;], loc&＃61;&＃39;upper right&＃39;)plt.show()
show_accuracy2(training, &＃39;loss&＃39;, &＃39;val_loss&＃39;)# 模型评估
test &＃61; model.evaluate(X_test, Y_test, verbose&＃61;1)
print(&＃39;误差&＃xff1a;&＃39;, test[0])
print(&＃39;准确率&＃xff1a;&＃39;, test[1])
# 误差&＃xff1a; 0.07175197452306747
# 准确率&＃xff1a; 0.9775000214576721
"""
model.evaluate()函数
评估模型&＃xff0c;不输出预测结果。
输入数据和标签&＃xff0c;输出损失和精确度.
loss, accuracy &＃61; model.evaluate(X_test, Y_test)
""""""
model.predict()函数
模型预测&＃xff0c;输入测试数据&＃xff0c;输出预测结果。
y_pred &＃61; model.predict(X_test, batch_size&＃61;1)
"""
"""
两者差异
&＃xff08;1&＃xff09;输入输出不同
model.evaluate&＃xff1a;输入数据&＃xff08;data&＃xff09;和真实标签&＃xff08;label&＃xff09;&＃xff0c;然后将预测结果与真实标签相比较&＃xff0c;得到两者误差并输出
model.predict&＃xff1a;输入数据&＃xff08;data&＃xff09;&＃xff0c;输出预测结果
&＃xff08;2&＃xff09;是否需要真实标签
model.evaluate&＃xff1a;需要&＃xff0c;因为需要比较预测结果与真实标签的误差
model.predict&＃xff1a;不需要&＃xff0c;只是单纯的预测结果&＃xff0c;不需要真实标签的参与
"""# 模型预测
prediction &＃61; model.predict(X_test)def plot_image(image):fig &＃61; plt.gcf() # 获取当前的图像fig.set_size_inches(2,2) # 设置图像大小plt.imshow(image, cmap&＃61;&＃39;binary&＃39;)plt.show()def pre_result(i):plot_image(X_test1[i])print(&＃39;真实值&＃xff1a;&＃39;, Y_test1[i])print(&＃39;预测值&＃xff1a;&＃39;, prediction[i])pre_result(4)


随着迭代模型准确率的变化&＃xff0c;由于笔记本性能有限&＃xff0c;仅仅迭代2次

损失函数随模型迭代的变化

最后显示图片


参考链接&＃xff1a;
https://blog.csdn.net/qq_42570457/article/details/81460807
https://zhuanlan.zhihu.com/p/116181964
https://zhuanlan.zhihu.com/p/379577547
https://blog.csdn.net/hgnuxc_1993/article/details/115566799