开发者

Python神经网络TensorFlow基于CNN卷积识别手写数字

目录
  • 基础理论
  • 一、训练CNN卷积神经网络
    • 1、载入数据
    • 2、改变数据维度
    • 3、归一化
    • 4、独热编码
    • 5、搭建CNN卷积神经网络
      • 5-1、第一层:第一个卷积层
      • 5-2、第二层:第二个卷积层
      • 5-3、扁平化
      • 5-4、第三层:第一个全连接层
      • 5-5、第四层:第二个全连接层(输出层)
    • 6、编译
      • 7、训练
        • 8、保存模型
          • 代码
          • 二、识别自己的手写数字(图像)
            • 1、载入数据
              • 2、载入训练好的模型
                • 3、载入自己写的数字图片并设置大小
                  • 4、转灰度图
                    • 5、转黑底白字、数据归一化
                      • 6、转四维数据
                        • 7、预测
                          • 8、显示图像
                            • 效果展示
                              • 代码

                              Python神经网络TensorFlow基于CNN卷积识别手写数字

                              基础理论

                              Python神经网络TensorFlow基于CNN卷积识别手写数字

                              第一层:卷积层。

                              第二层:卷积层。

                              第三层:全连接层。

                              第四层:输出层。

                              图中原始的手写数字的图片是一张 2828 的图片,并且是黑白的,所以图片的通道数是1,输入数据是 28281 的数据,如果是彩色图片,图片的通道数就为 3。

                              该网络结构是一个 4 层的卷积神经网络(计算神经网络层数的时候,有权值的才算是一层,池化层就不能单独算一层)(池化的计算是在卷积层中进行的)。

                              对多张特征图求卷积,相当于是同时对多张特征图进行特征提取。

                              Python神经网络TensorFlow基于CNN卷积识别手写数字

                              特征图数量越多说明卷积网络提取的特征数量越多,如果特征图数量设置得太少容易出现欠拟合,如果特征图数量设置得太多容易出现过拟合,所以需要设置为合适的数值。

                              一、训练CNN卷积神经网络

                              1、载入数据

                              # 1、载入数据
                              mnist = tf.keras.datasets.mnist
                              (train_data, train_target), (test_data, test_target) = mnist.load_data()

                              2、改变数据维度

                              注:在TensorFlow中,在做卷积的时候需要把数据变成4维的格式。

                              这4个维度分别是:数据数量,图片高度,图片宽度,图片通道数。

                              # 3、归一化(有助于提升训练速度)
                              train_data = train_data/255.0
                              test_data = test_data/255.0

                              3、归一化

                              # 3、归一化(有助于提升训练速度)
                              train_data = train_data/255.0
                              test_data = test_data/255.0

                              4、独热编码

                              # 4、独热编码
                              train_target = tf.keras.utils.to_categorical(train_target, num_classes=10)
                              test_target = tf.keras.utils.to_categorical(test_target, num_classes=10)    #10种结果

                              5、搭建CNN卷积神经网络

                              model = Sequential()

                              5-1、第一层:第一个卷积层

                              第一个卷积层:卷积层+池化层。

                              # 5-1、第一层:卷积层+池化层
                              # 第一个卷积层
                              model.add(Convolution2D(input_shape = (28,28,1), filters = 32, kernel_size = 5, strides = 1, padding = 'same', activation = 'relu'))
                              http://www.cppcns.com#         卷积层         输入数据                  滤波器数量      卷积核大小        步长          填充数据(same padding)  激活函数
                              # 第一个池化层 # pool_size
                              model.add(MaxPooling2D(pool_size = 2, strides = 2, padding = 'same',))
                              #         池化层(最大池化) 池化窗口大小   步长          填充方式

                              5-2、第二层:第二个卷积层

                              # 5-2、第二层:卷积层+池化层
                              # 第二个卷积层
                              model.add(Convolution2D(64, 5, strides=1, padding='same', activation='relu'))
                              # 64:滤波器个数      5:卷积窗口大小
                              # 第二个池化层
                              model.add(MaxPooling2D(2, 2, 'same'))

                              5-3、扁平化

                              把(64,7,7,64)数据变成:(64,7*7*64)。

                              flatten扁平化:

                              Python神经网络TensorFlow基于CNN卷积识别手写数字

                              # 5-3、扁平化 (相当于把(64,7,7,64)数据->(64,7*7*64))
                              model.add(Flatten())

                              5-4、第三层:第一个全连接层

                              # 5-4、第三层:第一个全连接层

                              model.add(Dense(1024,activation = 'relu'))

                              model.add(D编程客栈ropout(0.5))

                              5-5、第四层:第二个全连接层(输出层)

                              # 5-5、第四层:第二个全连接层(输出层)
                              model.add(Dense(10, activation='softmax'))
                              # 10:输出神经元个数

                              6、编译

                              设置优化器、损失函数、标签。

                              # 6、编译
                              model.compile(optimizer=Adam(lr=1e-4), loss='categorical_crossentropy', metrics=['accuracy'])
                              #            优化器(adam)               损失函数(交叉熵损失函数)            标签

                              7、训练

                              # 7、训练
                              model.fit(train_data, train_target, batch_size=64, epochs=10, validation_data=(test_data, test_target))

                              8、保存模型

                              # 8、保存模型
                              model.save('mnist.h5')

                              效果:

                              Epoch 1/10

                              938/938 [==============================] - 142s 151ms/step - loss: 0.3319 - accuracy: 0.9055 - val_loss: 0.0895 - val_accuracy: 0.9728

                              Epoch 2/10

                              938/938 [==============================] - 158s 169ms/step - loss: 0.0911 - accuracy: 0.9721 - val_loss: 0.0515 - val_accuracy: 0.9830

                              Epoch 3/10

                              938/938 [==============================] - 146s 156ms/step - loss: 0.0629 - accuracy: 0.9807 - val_loss: 0.0389 - val_accuracy: 0.9874

                              Epoch 4/10

                              938/938 [==============================] - 120s 128ms/step - loss: 0.0498 - accuracy: 0.9848 - val_loss: 0.0337 - val_accuracy: 0.9889

                              Epoch 5/10

                              938/938 [==============================] - 119s 127ms/step - loss: 0.0424 - accuracy: 0.9869 - val_loss: 0.0273 - val_accuracy: 0.9898

                              Epoch 6/10

                              938/938 [==============================] - 129s 138ms/step编程客栈 - loss: 0.0338 - accuracy: 0.9897 - val_loss: 0.0270 - val_accuracy: 0.9907

                              Epoch 7/10

                              938/938 [==============================] - 124s 133ms/step - loss: 0.0302 - accuracy: 0.9904 - val_loss: 0.0234 - val_accuracy: 0.9917

                              Epoch 8/10

                              938/938 [==============================] - 132s 140ms/step - loss: 0.0264 - accuracy: 0.9916 - val_loss: 0.0240 - val_accuracy: 0.9913

                              Epoch 9/10

                              938/938 [==============================] - 139s 148ms/step - loss: 0.0233 - accuracy: 0.9926 - val_loss: 0.0235 - val_accuracy: 0.9919

                              Epoch 10/10

                              938/938 [==============================] - 139s 148ms/step - loss: 0.0208 - accuracy: 0.9937 - val_loss: 0.0215 - val_accuracy: 0.9924

                              可以发现训练10次以后,效果达到了99%+,还是比较不错的。

                              Python神经网络TensorFlow基于CNN卷积识别手写数字

                              代码

                              # 手写数字识别 -- CNN神经网络训练
                              import os
                              os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
                               import tensorflow as tf
                              from tensorflow.keras.mo编程客栈dels import Sequential
                              from tensorflow.keras.layers import Dense,Dropout,Convolution2D,MaxPooling2D,Flatten
                              from tensorflow.keras.optimizers import Adam
                               # 1、载入数据
                              mnist = tf.keras.datasets.mnist
                              (train_data, train_target), (test_data, test_target) = mnist.load_data()
                              # 2、改变数据维度
                              train_data = train_data.reshape(-1, 28, 28, 1)
                              test_data = test_data.reshape(-1, 28, 28, 1)
                              # 注:在TensorFlow中,在做卷积的时候需要把数据变成4维的格式
                              # 这4个维度分别是:数据数量,图片高度,图片宽度,图片通道数 
                              # 3、归一化(有助于提升训练速度)
                              train_data = train_data/255.0
                              test_data = test_data/255.0 
                              # 4、独热编码
                              train_target = tf.keras.utils.to_categorical(train_target, num_classes=10)
                              test_target = tf.keras.utils.to_categorical(test_target, num_classes=10)    #10种结果 
                              # 5、搭建CNN卷积神经网络
                              model = Sequential()
                              # 5-1、第一层:卷积层+池化层
                              # 第一个卷积层
                              model.add(Convolution2D(input_shape = (28,28,1), filters = 32, kernel_size = 5, strides = 1, padding = 'same', activation = 'relu'))
                              #         卷积层         输入数据                  滤波器数量      卷积核大小        步长          填充数据(same padding)  激活函数
                              # 第一个池化层 # pool_size
                              model.add(MaxPooling2D(pool_size = 2, strides = 2, padding = 'same',))
                              #         池化层(最大池化) 池化窗口大小   步长          填充方式 
                              # 5-2、第二层:卷积层+池化层
                              # 第二个卷积层
                              model.add(Convolution2D(64, 5, strides=1, padding='same', activation='relu'))
                              # 64:滤波器个数      5:卷积窗口大小
                              # 第二个池化层
                              model.add(MaxPooling2D(2, 2, 'same')) 
                              # 5-3、扁平化 (相当于把(64,7,7,64)数据->(64,7*7*64))
                              model.add(Flatten()) 
                              # 5-4、第三层:第一个全连接层
                              model.add(Dense(1024, activation = 'relu'))
                              model.add(Dropout(0.5)) 
                              # 5-5、第四层:第二个全连接层(输出层)
                              model.add(Dense(10, activation='softmax'))
                              # 10:输出神经元个数 
                              # 6、编译
                              model.compile(optimizer=Adam(lr=1e-4), loss='categorical_crossentropy', metrics=['accuracy'])
                              #            优化器(adam)               损失函数(交叉熵损失函数)            标签 
                              # 7、训练
                              model.fit(train_data, train_target, batch_size=64, epochs=10, validation_data=(test_data, test_target)) 
                              # 8、保存模型
                              model.save('mnist.h5')

                              二、识别自己的手写数字(图像)

                              1、载入数据

                              # 1、载入数据
                              mnist = tf.keras.datasets.mnist
                              (x_train, y_train), (x_test, y_test) = mnist.load_data()

                              数据集的图片(之一):

                              Python神经网络TensorFlow基于CNN卷积识别手写数字

                              2、载入训练好的模型

                              # 2、载入训练好的模型
                              model = load_model('mnist.h5')

                              3、载入自己写的数字图片并设置大小

                              # 3、载入自己写的数字图片并设置大小
                              img = Image.open('6.jpg')
                              # 设置大小(和数据集的图片一致)
                              img = img.resize((28, 28))

                              Python神经网络TensorFlow基于CNN卷积识别手写数字

                              4、转灰度图

                              # 4、转灰度图
                              gray = np.array(img.convert('L'))       #.convert('L'):转灰度图

                              Python神经网络TensorFlow基于CNN卷积识别手写数字

                              可以发现和数据集中的白底黑字差别很大,所以我们把它反转一下:

                              5、转黑底白字、数据归一化

                              MNIST数据集中的数据都是黑底白字,且取值在0~1之间。

                              # 5、转黑底白字、数据归一化
                              gray_inv = (255-gray)/255.0

                              6、转四维数据

                              CNN神经网络预测需要四维数据。

                              # 6、转四维数据(CNN预测需要)
                              image = gray_inv.reshape((1,28,28,1))

                              7、预测

                              # 7、预测
                              prediction = model.predict(image)           # 预测
                              prediction = np.argmax(prediction,axis=1)   # 找出最大值
                              print('预测结果:', prediction)

                              Python神经网络TensorFlow基于CNN卷积识别手写数字

                              8、显示图像

                              # 8、显示
                              # 设置plt图表
                              f, ax = plt.subplots(3, 3, figsize=(7, 7))
                              # 显示数据集图像
                              ax[0][0].set_title('train_model')
                              ax[0][0].axis('off')
                              ax[0][0].imshow(x_train[18], 'gray')
                              # 显示原图
                              ax[0][1].set_title('img')
                              ax[0][1].axis('off')
                              ax[0][1].imshow(img, 'gray')
                              # 显示灰度图(白底黑字)
                              ax[0][2].set_title('gray')
                              ax[0][2].axis('off')
                              ax[0][2].imshow(gray, 'gray')
                              # 显示灰度图(黑底白字)
                              ax[1][0].set_title('grifyhHUSay')
                              ax[1][0].axis('off')
                              ax[1][0].imshow(gray_inv, 'gray')
                               
                              plt.show()

                              效果展示

                              Python神经网络TensorFlow基于CNN卷积识别手写数字

                              Python神经网络TensorFlow基于CNN卷积识别手写数字

                              Python神经网络TensorFlow基于CNN卷积识别手写数字

                              代码

                              # 识别自己的手写数字(图像预测)
                              import os
                              os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
                              import tensorflow as tf
                              from tensorflow.keras.models import load_model
                              import matplotlib.pyplot as plt
                              from PIL import Image
                              import numpy as np 
                              # 1、载入数据
                              mnist = tf.keras.datasets.mnist
                              (x_train, y_train), (x_test, y_test) = mnist.load_data() 
                              # 2、载入训练好的模型
                              model = load_model('mnist.h5') 
                              # 3、载入自己写的数字图片并设置大小
                              img = Image.open('5.jpg')
                              # 设置大小(和数据集的图片一致)
                              img = img.resize((28, 28)) 
                              # 4、转灰度图
                              gray = np.array(img.convert('L'))       #.convert('L'):转灰度图
                              # 5、转黑底白字、数据归一化
                              gray_inv = (255-gray)/255.0 
                              # 6、转四维数据(CNN预测需要)
                              image = gray_inv.reshape((1,28,28,1)) 
                              # 7、预测
                              prediction = model.predict(image)           # 预测
                              prediction = np.argmax(prediction,axis=1)   # 找出最大值
                              print('预测结果:', prediction) 
                              # 8、显示
                              # 设置plt图表
                              f, ax = plt.subplots(2, 2, figsize=(5, 5))
                              # 显示数据集图像
                              ax[0][0].set_title('train_model')
                              ax[0][0].axis('off')
                              ax[0][0].imshow(x_train[18], 'gray')
                              # 显示原图
                              ax[0][1].set_title('img')
                              ax[0][1].axis('off')
                              ax[0][1].imshow(img, 'gray')
                              # 显示灰度图(白底黑字)
                              ax[1][0].set_title('gray')
                              ax[1][0].axis('off')
                              ax[1][0].imshow(gray, 'gray')
                              # 显示灰度图(黑底白字)
                              ax[1][1].set_title(f'predict:{prediction}')
                              ax[1][1].axis('off')
                              ax[1][1].imshow(gray_inv, 'gray') 
                              plt.show()

                              以上就是python神经网络TensorFlow基于CNN卷积识别手写数字的详细内容,更多关于TensorFlow识别手写数字的资料请关注我们其它相关文章!

                              0

                              上一篇:

                              下一篇:

                              精彩评论

                              暂无评论...
                              验证码 换一张
                              取 消

                              最新开发

                              开发排行榜