实现简单卷积神经网络实现MNIST手写数据集的识别（python+tensorflow）

#MarkJhon
#2019/10/04
#homework

#?四层卷积神经网络，前两个卷积层由covonlution-relu-maxpool操作组成

#1，加载必要的编程库，开始计算图绘画
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
from tensorflow.contrib.learn.python.learn.datasets.mnist import read_data_sets

#from tensorflow.examples.tutorials.mnist import input_data
#开始计算图绘画
sess = tf.Session()


#2，加载数据集，转化为28*28的数组
data_dir = 'temp'
mnist = read_data_sets(data_dir)
#mnist = input_data.read_data_sets("MNIST_data/", one_hot = True)
train_xdata = np.array([np.reshape(x, (28, 28)) for x in mnist.train.images ])
test_xdata = np.array([np.reshape(x, (28, 28)) for x in mnist.test.images ])
train_labels = mnist.train.labels
test_labels = mnist.test.labels


#3，设置模型参数。由于图像是灰度图，所以图像深度为1，即颜色通道为1。
batch_size = 100
learning_rate = 0.005
evaluation_size = 500
image_width = train_xdata[0].shape[0]
image_height = train_xdata[0].shape[1]
target_size = max(train_labels) + 1

num_channels = 1
generations = 500
eval_every = 5
conv1_features = 25
conv2_features = 50
max_pool_size1 = 2
max_pool_size2 = 2
fully_connected_size1 = 100


#4，为数据集设占位符。同时声明训练和测试数据集变量。
#测试批量大小和评估大小根据实际训练和评估的机器物理内存来调整。
x_input_shape = (batch_size, image_width, image_height, num_channels)

x_input = tf.placeholder(tf.float32, shape = x_input_shape)
y_target = tf.placeholder(tf.int32, shape=(batch_size))

eval_input_shape = (evaluation_size, image_width, image_height, num_channels)
eval_input = tf.placeholder(tf.float32, shape=eval_input_shape)
eval_target = tf.placeholder(tf.int32, shape=(evaluation_size))





#5，声明卷积层权重和偏置，权重和偏置前边已经设置过了。
conv1_weight = tf.Variable(tf.truncated_normal([4, 4, num_channels, conv1_features], stddev = 0.1, dtype = tf.float32))
conv1_bias = tf.Variable(tf.zeros([conv1_features], dtype=tf.float32))

conv2_weight = tf.Variable(tf.truncated_normal([4, 4, conv1_features, conv2_features], stddev=0.1, dtype=tf.float32))
conv2_bias = tf.Variable(tf.zeros([conv2_features], dtype=tf.float32))

#6，声明全连接层权重和偏置。
resulting_width = image_width // (max_pool_size1 * max_pool_size2)
resulting_height = image_height // (max_pool_size1 * max_pool_size2)

full1_input_size = resulting_width * resulting_height * conv2_features
full1_weight = tf.Variable(tf.truncated_normal([full1_input_size, fully_connected_size1], stddev=0.1, dtype=tf.float32))
full1_bias = tf.Variable(tf.truncated_normal([fully_connected_size1], stddev=0.1, dtype= tf.float32))
full2_weight = tf.Variable(tf.truncated_normal([fully_connected_size1, target_size], stddev=0.1, dtype=tf.float32))
full2_bias = tf.Variable(tf.truncated_normal([target_size], stddev= 0.1, dtype=tf.float32))
#7，声明算法模型。创建一个模型函数。
def my_conv_net(input_data):
    #First
    conv1 = tf.nn.conv2d(input_data, conv1_weight, strides=[1, 1, 1, 1], padding='SAME')
    relu1 = tf.nn.relu(tf.nn.bias_add(conv1, conv1_bias))
    max_pool1 = tf.nn.max_pool(relu1, ksize=[1, max_pool_size1, max_pool_size1, 1], strides=[1, max_pool_size1, max_pool_size1, 1],padding='SAME')
    #second
    conv2 = tf.nn.conv2d(max_pool1, conv2_weight, strides=[1, 1, 1, 1], padding='SAME')
    relu2 = tf.nn.relu(tf.nn.bias_add(conv2, conv2_bias))
    max_pool2 = tf.nn.max_pool(relu2, ksize=[1, max_pool_size2, max_pool_size2, 1],strides=[1, max_pool_size2, max_pool_size2, 1], padding='SAME')
    #Transform
    final_conv_shape = max_pool2.get_shape().as_list()
    final_shape = final_conv_shape[1] * final_conv_shape[2] *final_conv_shape[3]
    flat_output = tf.reshape(max_pool2, [final_conv_shape[0], final_shape])
    #First

    fully_connected1 = tf.nn.relu(tf.add(tf.matmul(flat_output, full1_weight), full1_bias))
    #Seccond

    final_model_output = tf.add(tf.matmul(fully_connected1, full2_weight),full2_bias)
    return(final_model_output)
#8，声明训练模型。
model_output = my_conv_net(x_input)
test_model_output = my_conv_net(eval_input)

#9,用softmax函数作为和函数估计损失函数；
loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=model_output,labels=y_target))

#10，创建训练集和测试集的预测函数
prediction = tf.nn.softmax(model_output)
test_prediction = tf.nn.softmax(test_model_output)

def get_accuracy(logits, targets):
    batch_predictions = np.argmax(logits, axis=1)
    num_correct = np.sum(np.equal(batch_predictions, targets))
    return(100.* num_correct/batch_predictions.shape[0])

#11，创建优化器函数
my_optimizer = tf.train.MomentumOptimizer(learning_rate, 0.9)
train_step = my_optimizer.minimize(loss)

init = tf.initialize_all_variables()
sess.run(init)

#12，开始训练模型
train_loss = []
train_acc = []
test_acc = []
for i in range(generations):
    rand_index = np.random.choice(len(train_xdata), size=batch_size)
    rand_x = train_xdata[rand_index]
    rand_x = np.expand_dims(rand_x, 3)
    rand_y = train_labels[rand_index]
    train_dict = {x_input: rand_x, y_target: rand_y}

    sess.run(train_step, feed_dict=train_dict)
    temp_train_loss, temp_train_preds = sess.run([loss, prediction], feed_dict=train_dict)
    temp_train_acc = get_accuracy(temp_train_preds, rand_y)

    if(i+1) % eval_every == 0:
        eval_index = np.random.choice(len(test_xdata), size=evaluation_size)
        eval_x = test_xdata[eval_index]
        eval_x = np.expand_dims(eval_x, 3)

        eval_y = test_labels[eval_index]
        test_dict = {eval_input:eval_x, eval_target:eval_y}
        test_preds = sess.run(test_prediction, feed_dict=test_dict)

        temp_test_acc = get_accuracy(test_preds, eval_y)

        train_loss.append(temp_train_loss)
        train_acc.append(temp_train_acc)
        test_acc.append(temp_train_acc)
        acc_and_loss = [(i+1), temp_train_loss, temp_train_acc, temp_test_acc]

print('Generation #{}. Train Loss: {:.2f}. Train Acc (Test Acc):'
      '{:.2f} ({:.2f})'.format(*acc_and_loss))
#15，使用matplotlib模块绘制损失函数和准确度代码。
eval_indices = range(0, generations, eval_every)

#plot loss over time
plt.plot(eval_indices, train_loss, 'k-')
plt.title('Softmax Loss per Generation')
plt.xlabel('Generation')
plt.ylabel('Softax Loss')
plt.show()

#plot train and test accuracy
# plt.plot(eval_indices, train_acc, 'k-', label='Train Set Accuracy')
# plt.plot(eval_indices, test_acc, 'r--', label='Test Set Accuracy')
# plt.title('Train and Test Accuracy')
# plt.xlabel('Generation')
# plt.ylabel('Accuracy')
#
# plt.legend(loc='lower right')
# plt.show()

#15,绘制出打印最新结果的六幅抽样图
#plot the 6 of the last batch results:
# actuals = rand_y[0:6]
# predictions = np.argmax(temp_train_preds, axis=1)[0:6]
# images = np.squeeze(rand_x[0:6])
# Nrows = 2
# Ncols = 3
# for i in range(6):
#     plt.subplot(Nrows, Ncols, i+1)
#     plt.imshow(np.reshape(images[i], [28,28]), cmap='Greys_r')
#     plt.title('Actual:  ' + str(actuals[i]) + 'Pred:' + str(predictions[i]), fontsize=10)
#     frame = plt.gca()
#     frame.axes.get_xaxis().set_visible(False)
#     frame.axes.get_yaxis().set_visible(False)
# plt.show()