tensorflow uses CNN to analyze the mnist handwritten digit dataset

import tensorflow as tf
import numpy as np
import them
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
from tensorflow.examples.tutorials.mnist import input_data

mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
trX, trY, teX, teY = mnist.train.images, mnist.train.labels, mnist.test.images, mnist.test.labels
#Change the shape of the above trX and teX to [-1,28,28,1], -1 means that the number of input pictures is not considered, 28×28 is the number of pixels of the length and width of the picture,
# 1 is the number of channels, because the MNIST image is black and white, so the channel is 1, and if it is an RGB color image, the channel is 3.
trX = trX.reshape(-1, 28, 28, 1)  # 28x28x1 input img
teX = teX.reshape(-1, 28, 28, 1)  # 28x28x1 input img

X = tf.placeholder("float", [None, 28, 28, 1])
Y = tf.placeholder("float", [None, 10])
#Initialize the weights and define the network structure.
# Here, we will build a convolutional neural network with 3 convolutional layers and 3 pooling layers, followed by 1 fully connected layer and 1 output layer
def init_weights(shape):
    return tf.Variable(tf.random_normal(shape, stddev=0.01))

w = init_weights([3, 3, 1, 32]) # patch size is 3×3, input dimension is 1, output dimension is 32
w2 = init_weights([3, 3, 32, 64]) # patch size is 3×3, input dimension is 32, output dimension is 64
w3 = init_weights([3, 3, 64, 128]) # patch size is 3×3, input dimension is 64, output dimension is 128
w4 = init_weights([128 * 4 * 4, 625]) # Fully connected layer, the input dimension is 128 × 4 × 4, the output data of the previous layer is converted from three dimensions to one dimension, and the output dimension is 625
w_o = init_weights([625, 10]) # output layer, the input dimension is 625, the output dimension is 10, representing 10 categories (labels)
# The construction function of the neural network model, passing in the following parameters
# X: input data
# w: weight of each layer
# p_keep_conv, p_keep_hidden: the proportion of neurons to keep in dropout

def model(X, w, w2, w3, w4, w_o, p_keep_conv, p_keep_hidden):
    # The first set of convolutional layers and pooling layers, and finally dropout some neurons
    l1a = tf.nn.relu(tf.nn.conv2d(X, w, strides=[1, 1, 1, 1], padding='SAME'))
    # l1a shape=(?, 28, 28, 32)
    l1 = tf.nn.max_pool(l1a, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
    # l1 shape=(?, 14, 14, 32)
    l1 = tf.nn.dropout(l1, p_keep_conv)

    # The second set of convolutional layers and pooling layers, and finally dropout some neurons
    l2a = tf.nn.relu(tf.nn.conv2d(l1, w2, strides=[1, 1, 1, 1], padding='SAME'))
    # l2a shape=(?, 14, 14, 64)
    l2 = tf.nn.max_pool(l2a, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
    # l2 shape=(?, 7, 7, 64)
    l2 = tf.nn.dropout(l2, p_keep_conv)
    # The third group of convolutional layers and pooling layers, and finally dropout some neurons
    l3a = tf.nn.relu(tf.nn.conv2d(l2, w3, strides=[1, 1, 1, 1], padding='SAME'))
    # l3a shape=(?, 7, 7, 128)
    l3 = tf.nn.max_pool(l3a, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
    # l3 shape=(?, 4, 4, 128)
    l3 = tf.reshape(l3, [-1, w4.get_shape().as_list()[0]])    # reshape to (?, 2048)
    l3 = tf.nn.dropout(l3, p_keep_conv)
    # Fully connected layer, finally dropout some neurons
    l4 = tf.nn.relu(tf.matmul(l3, w4))
    l4 = tf.nn.dropout(l4, p_keep_hidden)
    # output layer
    pyx = tf.matmul(l4, w_o)
    return pyx #return the predicted value

#We define a placeholder for dropout - keep_conv, which indicates how many neurons in a layer are kept. Generate network models to get predicted values
p_keep_conv = tf.placeholder("float")
p_keep_hidden = tf.placeholder("float")
py_x = model(X, w, w2, w3, w4, w_o, p_keep_conv, p_keep_hidden) #Get the predicted value
#Define the loss function, here we still use tf.nn.softmax_cross_entropy_with_logits to compare the difference between the predicted value and the real value, and do the mean processing;
# Define the training operation (train_op), use the optimizer tf.train.RMSPropOptimizer that implements the RMSProp algorithm, the learning rate is 0.001, and the decay value is 0.9 to minimize the loss;
# Define the predicted operation (predict_op)
cost = tf.reduce_mean(tf.nn. softmax_cross_entropy_with_logits(logits=py_x, labels=Y))
train_op = tf.train.RMSPropOptimizer(0.001, 0.9).minimize(cost)
predict_op = tf.argmax(py_x, 1)
#define the batch size at training time and the batch size at evaluation time
batch_size = 128
test_size = 256
# start graph in one session, start training and evaluation
# Launch the graph in a session
with tf.Session() as sess:
    # you need to initialize all variables
    tf. global_variables_initializer().run()
    for i in range(100):
        training_batch = zip(range(0, len(trX), batch_size),
                             range(batch_size, len(trX)+1, batch_size))
        for start, end in training_batch:
            sess.run(train_op, feed_dict={X: trX[start:end], Y: trY[start:end],
                                          p_keep_conv: 0.8, p_keep_hidden: 0.5})

        test_indices = np.arange(len(teX))  # Get A Test Batch
        np.random.shuffle(test_indices)
        test_indices = test_indices[0:test_size]

        print(i, np.mean(np.argmax(teY[test_indices], axis=1) ==
                         sess.run(predict_op, feed_dict={X: teX[test_indices],
                                                         p_keep_conv: 1.0,
                                                         p_keep_hidden: 1.0})))