【tensorflow CNN】构建cnn网络，识别mnist手写数字识别

本文主要是介绍【tensorflow CNN】构建cnn网络，识别mnist手写数字识别，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

#coding:utf8
"""
构建cnn网络，识别mnist
input                   conv1                   padding   max_pool([2,2],strides=[2,2])               conv2      
x[-1,28,28,1] 卷积 [5,5,1,32] -> [-1,24,24,32]->[-1,28,28,32]->[-1,14,14,32]       卷积      [5,5,32,64]->[-1,10,10,64]padding   max_pool([2,2],strides=[2,2])  flatten    full connected layer 64个节点    dropout   softmax
-> [-1,14,14,64]->[-1,7,7,64] ->           [7*7*64,-1]  矩阵相乘 [64,7*7*64]  """from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np
import mathmnist = input_data.read_data_sets("./mnist/",one_hot=True)print("Training set:",mnist.train.images.shape)
print("Training set labels:",mnist.train.labels.shape)
print("Dev Set(Cross Validation set):",mnist.validation.images.shape)
print("Dev Set labels:",mnist.validation.labels.shape)
print("Test Set:",mnist.test.images.shape)
print("Test Set labels:",mnist.test.labels.shape)x_train = mnist.train.images
y_train = mnist.train.labels
x_dev = mnist.validation.images
y_dev = mnist.validation.labels
x_test = mnist.test.images
y_test = mnist.test.labelsdef create_placeholders(n_x, n_y):"""Creates the placeholders for the tensorflow session.Arguments:n_x -- scalar, size of an image vector (num_px * num_px = 64 * 64 * 3 = 12288)n_y -- scalar, number of classes (from 0 to 5, so -> 6)Returns:X -- placeholder for the data input, of shape [n_x, None] and dtype "float"Y -- placeholder for the input labels, of shape [n_y, None] and dtype "float"Tips:- You will use None because it let's us be flexible on the number of examples you will for the placeholders.In fact, the number of examples during test/train is different."""### START CODE HERE ### (approx. 2 lines)X = tf.placeholder(tf.float32, [None,n_x], name="X")Y = tf.placeholder(tf.float32, [None,n_y], name="Y")### END CODE HERE ###return X, Ydef random_mini_batches(X, Y, mini_batch_size=64):"""Creates a list of random minibatches from (X, Y)Arguments:X -- input data, of shape (input size, number of examples)Y -- true "label" vector (1 for blue dot / 0 for red dot), of shape (1, number of examples)mini_batch_size -- size of the mini-batches, integerReturns:mini_batches -- list of synchronous (mini_batch_X, mini_batch_Y)"""m = X.shape[1]  # 训练样本个数mini_batches = []# Step 1: Shuffle (X, Y)permutation = list(np.random.permutation(m))shuffled_X = X[permutation,:]shuffled_Y = Y[permutation,:]# Step 2: Partition (shuffled_X, shuffled_Y). Minus the end case.num_complete_minibatches = math.floor(m / mini_batch_size)  # number of mini batches of size mini_batch_size in your partitionningfor k in range(0, num_complete_minibatches):mini_batch_X = shuffled_X[k * mini_batch_size:(k + 1) * mini_batch_size,:]mini_batch_Y = shuffled_Y[k * mini_batch_size:(k + 1) * mini_batch_size,:]mini_batch = (mini_batch_X, mini_batch_Y)mini_batches.append(mini_batch)# Handling the end case (last mini-batch < mini_batch_size)if m % mini_batch_size != 0:mini_batch_X = shuffled_X[mini_batch_size * num_complete_minibatches:,:]mini_batch_Y = shuffled_Y[mini_batch_size * num_complete_minibatches:,:]mini_batch = (mini_batch_X, mini_batch_Y)mini_batches.append(mini_batch)return mini_batchesdef parameter_init(shape):return tf.Variable(tf.random_normal(shape))#定义一个函数，用于构建卷积层
def conv2d(x, W):return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')#定义一个函数，用于构建池化层
def max_pool(x):return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],strides=[1, 2, 2, 1], padding='SAME')def init_parameters():parameters = {}parameters["W_conv1"] = parameter_init([5,5,1,32])parameters["b_conv1"] = parameter_init([32])parameters["W_conv2"] = parameter_init([5,5,32,64])parameters["b_conv2"] = parameter_init([64])parameters["W_fc1"] = parameter_init([7*7*64,256])parameters["b_fc1"] = parameter_init([256])parameters["W_out"] = parameter_init([256,10])parameters["b_out"] = parameter_init([10])return parametersdef forward_propagation(x,parameters):x = tf.reshape(x,[-1,28,28,1])W_conv1 = parameters["W_conv1"]b_conv1 = parameters["b_conv1"]h_conv1 = tf.nn.relu(conv2d(x,W_conv1)+b_conv1)  #第一个卷积层h_pool1 = max_pool(h_conv1)                      #第一个池化层W_conv2 = parameters["W_conv2"]b_conv2 = parameters["b_conv2"]h_conv2 = tf.nn.relu(conv2d(h_pool1,W_conv2)+b_conv2)  #第二个全连接层h_pool2 = max_pool(h_conv2)                            #第二个池化层W_fc1 = parameters["W_fc1"]             #第一个全连接层，256个节点b_fc1 = parameters["b_fc1"]h_pool2_flat = tf.reshape(h_pool2,[-1,7*7*64])           #第二个池化层flatten to 1 dimensional vectorh_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat,W_fc1) + b_fc1)#keep_prob = tf.placeholder("float")#h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)                  #dropout层W_out = parameters["W_out"]b_out = parameters["b_out"]Z = tf.matmul(h_fc1,W_out) + b_outreturn Zdef compute_cost(Z, Y):"""Computes the costArguments:Z -- output of forward propagation (output of the last LINEAR unit), of shape (10, number of examples)Y -- "true" labels vector placeholder, same shape as Z3Returns:cost - Tensor of the cost function"""# to fit the tensorflow requirement for tf.nn.softmax_cross_entropy_with_logits(...,...)logits = Zlabels = Ycost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=labels))return costdef tf_cnn_model(X_train,Y_train,X_test,Y_test,learning_rate=0.001,num_epochs=100,minibatch_size=64,print_cost=True):(m,n_x) = X_train.shape  # (n_x: input size, m : number of examples in the train set)n_y = Y_train.shape[1]  # n_y : output sizecosts = []  # to keep track of the costX = tf.placeholder(tf.float32, [None,n_x], name="X")Y = tf.placeholder(tf.float32, [None,n_y], name="Y")parameters = init_parameters()Z = forward_propagation(X,parameters)cost = compute_cost(Z, Y)optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)init = tf.global_variables_initializer()with tf.Session() as sess:sess.run(init)for epoch in range(num_epochs):epoch_cost = 0.  # Defines a cost related to an epochnum_minibatches = int(m / minibatch_size)minibatches = random_mini_batches(X_train, Y_train, minibatch_size)for minibatch in minibatches:(minibatch_X, minibatch_Y) = minibatch_, minibatch_cost = sess.run([optimizer, cost], feed_dict={X: minibatch_X, Y: minibatch_Y})epoch_cost += minibatch_cost / num_minibatches#if print_cost == True and epoch % 10 == 0:print("Cost after epoch %i: %f" % (epoch, epoch_cost))#if print_cost == True and epoch % 5 == 0:costs.append(epoch_cost)# plot the costplt.plot(np.squeeze(costs))plt.ylabel('cost')plt.xlabel('iterations (per tens)')plt.title("Learning rate =" + str(learning_rate))plt.show()parameters = sess.run(parameters)print("Parameters have been trained!")correct_prediction = tf.equal(tf.argmax(Z,1), tf.argmax(Y,1))accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))print("Test Accuracy:", accuracy.eval({X: X_test, Y: Y_test}))"""# Training cyclefor epoch in range(num_epochs):epoch_cost = 0.total_batch = int(mnist.train.num_examples/minibatch_size)# Loop over all batchesfor i in range(total_batch):batch_x, batch_y = mnist.train.next_batch(minibatch_size)# Run optimization op (backprop) and cost op (to get loss value)_, minibatch_cost = sess.run([optimizer, cost], feed_dict={X: batch_x,Y: batch_y})# Compute average lossepoch_cost += minibatch_cost / total_batchif print_cost == True and epoch % 10 == 0:print("Cost after epoch %i: %f" % (epoch, epoch_cost))if print_cost == True and epoch % 5 == 0:costs.append(epoch_cost)plt.plot(np.squeeze(costs))plt.ylabel('cost')plt.xlabel('iterations (per tens)')plt.title("Learning rate =" + str(learning_rate))plt.show()parameters = sess.run(parameters)        print("Optimization Finished!")# Test modelcorrect_prediction = tf.equal(tf.argmax(Z, 1), tf.argmax(Y, 1))# Calculate accuracyaccuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))print("Accuracy:", accuracy.eval({x: X_test, y: Y_test}))"""return parameterstf_cnn_model(x_train, y_train, x_test, y_test,learning_rate=0.001, num_epochs=40,minibatch_size=64, print_cost=True)