一、keras CNN卷积神经网络------搭建mnist手写数字识别网络

猪猪爱学习

已于 2023-12-20 15:21:28 修改

阅读量1.4k

点赞数 25

于 2023-12-20 15:18:56 首次发布

本文链接：https://blog.csdn.net/weixin_45477686/article/details/135013337

版权

深度学习同时被 2 个专栏收录

2 篇文章 0 订阅

订阅专栏

图像识别

1 篇文章 0 订阅

订阅专栏

MNIST是一个手写体数字的图片数据集，包含 7 万张黑底白字手写数字图片，每张图片大小为 28x28 像素，图片中纯黑色像素值为 0，纯白色像素值为 1；数据集的标签是长度为 10 的一维数组。该数据集来由美国国家标准与技术研究所[ National Institute of Standards and Technology (NIST) ] 发起整理，一共统计了来自250个不同的人手写数字图片（其中50%是高中生，50%来自人口普查局的工作人员）。

该数据集包括训练集（一共包含了 60,000 张图像和标签）和测试集（一共包含了 10,000 张图像和标签）。该数据集的收集目的是希望通过算法，实现对手写数字的识别。

在开始之前我们先了解：CNN结构

1. 首先我们先导入需要的库

这里我们使用的是keras版本是2.15.0，所以我们这样导入我们需要的库

from keras.utils import to_categorical

如果是旧版本，导入的是：from keras.utils import np_utils

from keras.datasets import mnist
#from keras.utils import np_utils#旧版本
from keras.utils import to_categorical#2.15.0版本以上
import numpy as np
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import Dense,Dropout,Flatten,Conv2D,MaxPooling2D

2.下载手写数据集

函数load_data()会返回两个元组，每个元组中包含两个数组。x_train和x_test是图像数据，y_train和y_test是对应的标签

(x_Train,y_Train),(x_Test,y_Test)=mnist.load_data()
print('x_Train:',x_Train.shape)
print('y_Train:',y_Train.shape)
print('x_Test:',x_Test.shape)
print('y_Test:',y_Test.shape)

3.图形化数据集(查看前10个数据集)

''' 图形化数据集，查看前10个数据集'''
def polt_images_label_prediction(images,labels,idx,num=10):
    fig=plt.gcf()
    fig.set_size_inches(12,14)#创建一个画布12x14
    for i in range(num):
        ax=plt.subplot(5,2,1+i)#在之前的画布上创建 5 行 2 列的子图网格
        ax.imshow(images[idx],cmap='binary')
        title='label='+str(labels[idx])
        ax.set_title(title,fontsize=10)
        ax.set_xticks([])#移除当前子图的xy轴刻度线

        ax.set_yticks([])
    plt.show()
polt_images_label_prediction(x_Train,y_Train,0)

输出结果如下：

4.数据预处理

''' 数据预处理：
将features以reshape转化为6000*28*28*1的4维矩阵，并将其标准化。'''
x_Train4D=x_Train.reshape(x_Train.shape[0],28,28,1).astype('float32')#图像的数量、宽、高和通道数（因为是灰度图，所以通道数为1）
x_Test4D = x_Test.reshape(x_Test.shape[0], 28, 28, 1).astype('float32')#将数据类型转换为32位浮点数
x_Train4D_normalize = x_Train4D / 255#将图像数据进行标准化，因为原始的MNIST图像数据的像素值是介于0到255之间的整数（表示灰度值），所以除以255可以将它们标准化到0到1之间
x_Test4D_normalize = x_Test4D / 255

''' 对标签进行one-hot编码处理 '''
#未转化第一个数是 5
print('未转化第一个数是 5:',y_Train[:1])#以原始形式打印出y_Train的第一个标签

y_TrainOneHot = to_categorical(y_Train)#转换为one-hot编码格式。每个标签都被转换为一个二进制向量，其中只有一个元素是1，其余元素都是0。例如，如果一个标签是5，那么它将被转换为[0, 0, 0, 0, 0, 1]。
y_TestOneHot = to_categorical(y_Test)
#转化  One-Hot Encoding 都是以0 1 表示，5 在第六个位置
print('转化  One-Hot Encoding:',y_TrainOneHot[:1])#以one-hot编码形式打印出y_Train的第一个标签

输出结果如下：

5.建立模型

Sequential()是Keras中的一个模型，它允许我们线性地堆叠不同的网络层。这意味着每一层都会接收前一层的输出作为输入


''' 建立模型 '''
#建立一个 Sequential 线性堆叠模型，Sequential是Keras中的一个模型，它允许我们线性地堆叠不同的网络层。这意味着每一层都会接收前一层的输出作为输入
model=Sequential()
#建立第一个卷积层，input_shape 输入数字图像大小为 28*28*1， filters 卷积核个数 16 个，kernel_size 卷积核大小 3*3
#padding 是否零填充 same 表示填充， activation 激活函数 relu
model.add(Conv2D(filters = 16,
            kernel_size = (3, 3),
            padding = 'same',
            input_shape = (28, 28, 1),
            activation = 'relu'))
#建立第一个池化层 pool_size 池化窗口 2
model.add(MaxPooling2D(pool_size = (2, 2)))


#因为Keras会自动推断输入形状。当在Sequential模型中添加一个层时，Keras会记住前一层的输出形状，并将该形状作为下一层的输入形状。因此，第二个卷积层会接收第一个卷积层的输出作为输入，而不需要手动指定input_shape

#建立第二个卷积层， filters 卷积核个数 36 个，kernel_size 卷积核大小 3*3
#padding 是否零填充 same 表示填充， activation 激活函数 relu
model.add(Conv2D(filters = 36,
                kernel_size = (3, 3),
                padding = 'same',
                activation = 'relu'))#还有其他多种激活函数可供选择，取决于具体需求和网络设计（Sigmoid、Tanh、Leaky ReLU、Parametric ReLU、ELU、SELU ）
#建立第二个池化层 pool_size 池化窗口 2
model.add(MaxPooling2D(pool_size = (2, 2)))

''' #建立第三个卷积层， filters 卷积核个数 64 个，kernel_size 卷积核大小 3*3
#padding 是否零填充 same 表示填充， activation 激活函数 relu
model.add(Conv2D(filters = 64,
                kernel_size = (3, 3),
                padding = 'same',
                activation = 'relu'))
#建立第三个池化层 pool_size 池化窗口 2
model.add(MaxPooling2D(pool_size = (2, 2))) '''

避免过度拟合

Dropout()层用于减少过拟合，它随机将一部分神经元的输出设置为0

#加入Dropout避免过度拟合
model.add(Dropout(0.25))
#建立平坦层，将多维向量转化为一维向量
model.add(Flatten())#将数据从（样本数，高度，宽度）转换为（样本数， 高度*宽度）
#建立隐藏层，隐藏层有 128 个神经元， activation 激活函数用 relu
model.add(Dense(128, activation = 'relu'))

#加入Dropout避免过度拟合
model.add(Dropout(0.25))
#建立输出层，一共有 10 个神经元，因为 0 到 9 一共有 10 个类别， activation 激活函数用 softmax 这个函数用来分类
model.add(Dense(10, activation = 'softmax'))



''' 查看模型摘要 '''
print('查看模型摘要:',model.summary())

输出：每一层的名字、类型、输出形状和参数数量。

模型的输入形状和输出形状。

模型的总结信息，如总参数数量、可训练参数数量等。

6.训练模型

'categorical_crossentropy'通常用于多类分类问题

optimizer = 'adam'用于优化模型权重的算法

metrics = ['accuracy']在训练过程中跟踪的额外指标。在这里，准确率被用作度量标准

#定义训练模型， loss 损失函数用 categorical_crossentropy， optimizer 优化器用 adam， metrics 度量用 accuracy
model.compile(loss = 'categorical_crossentropy', optimizer = 'adam', metrics = ['accuracy'])
#开始训练模型， x 是训练数据集， y 是训练数据集的标签， validation_split 是把训练数据集分为 8 份训练数据集 2 份验证集
#epochs 是迭代次数 20， batch_size 是批量 256， verbose 为 2 显示训练过程
train_history = model.fit(x = x_Train4D_normalize,#训练数据集，通常是缩放到平均值为0，标准差为1
                            y = y_TrainOneHot,#训练数据的标签，通常以one-hot编码的形式表示
                            validation_split = 0.2,#从训练数据中随机选择20%作为验证集，剩下的80%作为训练集
                            epochs = 20,
                            batch_size = 256,
                            verbose = 2)

7.查看、评估和预测模型

train_history：训练历史对象

train：训练数据的标签

validation：验证数据的标签

''' 查看训练模型loss和accuracy '''
def show_train_history(train_history, train, validation):
    plt.plot(train_history.history[train])
    plt.plot(train_history.history[validation])
    plt.title('Train History')#Train History
    plt.ylabel(train)
    plt.xlabel('Epoch')
    plt.legend(['train', 'validation'], loc = 'upper left')
    plt.show()
show_train_history(train_history, 'loss', 'val_loss')
show_train_history(train_history, 'accuracy', 'val_accuracy')

使用模型的 evaluate 方法来评估模型在测试数据集上的性能。 x_Test4D_normalize 是经过预处理和归一化的测试输入数据，y_TestOneHot 是相应的经过one-hot编码的测试标签数据

scores = model.evaluate(x_Test4D_normalize, y_TestOneHot)
print('评估模型:',scores[1])

预测测试集第一个数字

prediction = np.argmax(model.predict(x_Test4D_normalize[:1]))
print('预测值：', prediction)
print('真实值：', np.argmax(y_TestOneHot[:1]))

最后输出结果：

8.总代码

from keras.datasets import mnist
#from keras.utils import np_utils
from keras.utils import to_categorical
import numpy as np
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import Dense,Dropout,Flatten,Conv2D,MaxPooling2D



''' 下载手写数据集 '''
(x_Train,y_Train),(x_Test,y_Test)=mnist.load_data()
print('x_Train:',x_Train.shape)
print('y_Train:',y_Train.shape)
print('x_Test:',x_Test.shape)
print('y_Test:',y_Test.shape)



''' 图形化数据集，查看前10个数据集'''
def polt_images_label_prediction(images,labels,idx,num=10):
    fig=plt.gcf()
    fig.set_size_inches(12,14)
    for i in range(num):
        ax=plt.subplot(5,2,1+i)
        ax.imshow(images[idx],cmap='binary')
        title='label='+str(labels[idx])
        ax.set_title(title,fontsize=10)
        ax.set_xticks([])
        ax.set_yticks([])
    plt.show()
polt_images_label_prediction(x_Train,y_Train,0)




''' 数据预处理：
将features以reshape转化为6000*28*28*1的4维矩阵，并将其标准化。'''
x_Train4D=x_Train.reshape(x_Train.shape[0],28,28,1).astype('float32')
x_Test4D = x_Test.reshape(x_Test.shape[0], 28, 28, 1).astype('float32')
x_Train4D_normalize = x_Train4D / 255
x_Test4D_normalize = x_Test4D / 255

''' 对标签进行one-hot编码处理 '''
#未转化第一个数是 5
print('未转化第一个数是 5:',y_Train[:1])

y_TrainOneHot = to_categorical(y_Train)
y_TestOneHot = to_categorical(y_Test)
#转化  One-Hot Encoding 都是以0 1 表示，5 在第六个位置
print('转化  One-Hot Encoding:',y_TrainOneHot[:1])




''' 建立模型 '''
model=Sequential()
#建立第一个卷积层
model.add(Conv2D(filters = 16,
            kernel_size = (3, 3),
            padding = 'same',
            input_shape = (28, 28, 1),
            activation = 'relu'))
model.add(MaxPooling2D(pool_size = (2, 2)))

#建立第二个卷积层
model.add(Conv2D(filters = 36,
                kernel_size = (3, 3),
                padding = 'same',
                activation = 'relu'))

model.add(MaxPooling2D(pool_size = (2, 2)))

""""""

#建立第三个卷积层
model.add(Conv2D(filters = 64,
                kernel_size = (3, 3),
                padding = 'same',
                activation = 'relu'))
model.add(MaxPooling2D(pool_size = (2, 2)))
#加入Dropout避免过度拟合
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation = 'relu'))

#加入Dropout避免过度拟合
model.add(Dropout(0.25))
model.add(Dense(10, activation = 'softmax'))


''' 查看模型摘要 '''
print('查看模型摘要:',model.summary())




'''  训练模型   '''
#定义训练模型， loss 损失函数用 categorical_crossentropy， optimizer 优化器用 adam， metrics 度量用 accuracy
model.compile(loss = 'categorical_crossentropy', optimizer = 'adam', metrics = ['accuracy'])
#开始训练模型， x 是训练数据集， y 是训练数据集的标签， validation_split 是把训练数据集分为 8 份训练数据集 2 份验证集
#epochs 是迭代次数 20， batch_size 是批量 256， verbose 为 2 显示训练过程
train_history = model.fit(x = x_Train4D_normalize,
                            y = y_TrainOneHot,
                            validation_split = 0.2,
                            epochs = 20,
                            batch_size = 256,
                            verbose = 2)

''' 查看训练模型loss和accuracy '''
def show_train_history(train_history, train, validation):
    plt.plot(train_history.history[train])
    plt.plot(train_history.history[validation])
    plt.title('Train History')#Train History
    plt.ylabel(train)
    plt.xlabel('Epoch')
    plt.legend(['train', 'validation'], loc = 'upper left')
    plt.show()
show_train_history(train_history, 'loss', 'val_loss')
show_train_history(train_history, 'accuracy', 'val_accuracy')


''' 评估模型 '''
scores = model.evaluate(x_Test4D_normalize, y_TestOneHot)
print('评估模型:',scores[1])


''' 预测模型 '''
#预测测试集第一个数字
prediction = np.argmax(model.predict(x_Test4D_normalize[:1]))
print('预测值：', prediction)
print('真实值：', np.argmax(y_TestOneHot[:1]))