Tensorflow uses CNN to analyze mnIST handwritten digital data sets

import tensorflow as tf
import numpy as np
import os
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 trX and teX into [-1,28,28,1], -1 means that the number of input images is not considered,28 ×28 is the number of pixels of the length and width of the image,
# 1 is the number of channels. Since MNIST images are black and white, the channel is 1. For RGB color images, 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 weights and define network structure.
# Here, we are going to build a convolutional neural network with three convolutional layers and three pooling layers, followed by a full connection layer and an 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])     The input dimension of the fully connected layer is 128 × 4 × 4, and the output data of the previous layer is converted from 3d to 1d, and the output dimension is 625
w_o = init_weights([625.10])   # output layer, input dimension 625, output dimension 10, represents 10 classes (labels)
# Neural network model builder function, passing in the following parameters
# X: Input data
# w: The weight of each layer
# P_keep_conv, P_keep_hidden: Dropout Ratio of neurons to keep

def model(X, w, w2, w3, w4, w_o, p_keep_conv, p_keep_hidden) :
    # 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 connect layers, and 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 the placeholder for dropout -- keep_conv, which indicates what percentage of neurons are retained in a layer. Generate the network model and get the predicted value
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
Here we still use TF.nn.softMAX_cross_entropy_with_logits to compare the difference between the predicted value and the true value, and do the mean processing;
# define training operations (train_op), USES the implementation RMSProp algorithm optimizer tf. Train. RMSPropOptimizer, vector is 0.001, the attenuation value of 0.9, minimize the losses;
# define 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 batch sizes for training and batch sizes for evaluation
batch_size = 128
test_size = 256
# Launch the diagram in a session to 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})))
Copy the code

\