10. CNN applied to handwritten digit recognition

The code running platform is jupyter-notebook, Code blocks in the article , According to jupyter-notebook Written in the order of division in , Run article code , Glue directly into jupyter-notebook that will do . The comments given by the overall code are quite simple .

1. Import third-party library

import numpy as np
from keras.datasets import mnist
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers import Dense,Dropout,Convolution2D,MaxPooling2D,Flatten
from tensorflow.keras.optimizers import Adam

2. Loading data and data preprocessing

#  Load data 
(x_train,y_train),(x_test,y_test) = mnist.load_data()
# (60000, 28, 28)
print("x_shape:\n",x_train.shape)
# (60000,)  Not yet one-hot code   You need to operate by yourself later 
print("y_shape:\n",y_train.shape)
# (60000, 28, 28) -> (60000,28,28,1)=( Number of pictures , Picture height , Image width , The number of channels in the picture ) reshape() Middle parameter filling -1 Parameter results can be calculated automatically   Divide 255.0 To normalize 
#  Normalization is critical , It can greatly reduce the amount of calculation 
x_train = x_train.reshape(-1,28,28,1)/255.0
x_test = x_test.reshape(-1,28,28,1)/255.0
#  in one hot Format 
y_train = np_utils.to_categorical(y_train,num_classes=10)
y_test = np_utils.to_categorical(y_test,num_classes=10)

3. Training models

#  Define sequential model 
model = Sequential()

#  The first convolution layer   Note that the first layer should write the size of the input image   Later layers can be ignored 
# input_shape  Input plane 
# filters  Convolution kernel / Number of filters 
# kernel_size  Convolution window size 
# strides  step 
# padding padding The way  same/valid
# activation  Activation function 
model.add(Convolution2D(
    input_shape=(28,28,1),
    filters=32,
    kernel_size=5,
    strides=1,
    padding="same",
    activation="relu"
))

#  The first pool 
model.add(MaxPooling2D(
    pool_size=2,
    strides=2,
    padding="same"
))
#  The second pooling layer 
model.add(Convolution2D(filters=64,kernel_size=5,strides=1,padding="same",activation="relu"))
#  The second pooling layer 
model.add(MaxPooling2D(pool_size=2,strides=2,padding="same"))
#  Flatten the output of the second pool layer into 1 dimension 
model.add(Flatten())
#  The first full connection layer 
model.add(Dense(units=1024,activation="relu"))
# Dropout  Random selection 50% Neurons are trained 
model.add(Dropout(0.5))
#  The second full connection layer 
model.add(Dense(units=10,activation="softmax"))

#  Define optimizer   Set the learning rate to 1e-4
adam = Adam(lr=1e-4)

#  Define optimizer ,loss function, The accuracy of calculation during training 
model.compile(optimizer=adam,loss="categorical_crossentropy",metrics=["accuracy"])

#  Training models 
model.fit(x_train,y_train,batch_size=64,epochs=10)

#  Evaluation model 
loss,accuracy=model.evaluate(x_test,y_test)

print("test loss:",loss)
print("test accuracy:",accuracy)

Code run results ：

Some points needing attention in the code , Explanations and reminders are also given in the code comments .

Be careful

• The first layer of neural network is to write the size of the input image Later layers can be ignored