基于MNIST数据的卷积神经网络CNN

blake

本文基于TensorFlow官网的Tutorial写成。输入数据是MNIST，全称是Modified National Institute of Standards and Technology，是一组由这个机构搜集的手写数字扫描文件和每个文件对应标签的数据集，经过一定的修改使其适合机器学习算法读取。这个数据集可以从牛的不行的Yann LeCun教授的网站获取。
本系列文章的这一篇对这份数据集使用了softmax regression，在测试集上取得了接近92%的准确率。本文将使用卷积神经网络以获得更高的准确率。关于CNN的理论知识，可以参考这篇文章

1. #!/usr/bin/env python
   
2. # -*- coding=utf-8 -*-
   
3. # @author: 陈水平
   
4. # @date: 2017-02-04
   
5. # @description: implement a CNN model upon MNIST handwritten digits
   
6. # @ref: http://yann.lecun.com/exdb/mnist/
   
7. 
   
8. import gzip
   
9. import struct
   
10. import numpy as np
    
11. from sklearn import preprocessing
    
12. import tensorflow as tf
    
13. 
    
14. # MNIST data is stored in binary format,
    
15. # and we transform them into numpy ndarray objects by the following two utility functions
    
16. def read_image(file_name):
    
17.     with gzip.open(file_name, 'rb') as f:
    
18.         buf = f.read()
    
19.         index = 0
    
20.         magic, images, rows, columns = struct.unpack_from('>IIII' , buf , index)
    
21.         index += struct.calcsize('>IIII')
    
22. 
    
23.         image_size = '>' + str(images*rows*columns) + 'B'
    
24.         ims = struct.unpack_from(image_size, buf, index)
    
25.         
    
26.         im_array = np.array(ims).reshape(images, rows, columns)
    
27.         return im_array
    
28. 
    
29. def read_label(file_name):
    
30.     with gzip.open(file_name, 'rb') as f:
    
31.         buf = f.read()
    
32.         index = 0
    
33.         magic, labels = struct.unpack_from('>II', buf, index)
    
34.         index += struct.calcsize('>II')
    
35.         
    
36.         label_size = '>' + str(labels) + 'B'
    
37.         labels = struct.unpack_from(label_size, buf, index)
    
38. 
    
39.         label_array = np.array(labels)
    
40.         return label_array
    
41. 
    
42. print "Start processing MNIST handwritten digits data..."
    
43. train_x_data = read_image("MNIST_data/train-images-idx3-ubyte.gz")  # shape: 60000x28x28
    
44. train_x_data = train_x_data.reshape(train_x_data.shape[0], train_x_data.shape[1], train_x_data.shape[2], 1).astype(np.float32)
    
45. train_y_data = read_label("MNIST_data/train-labels-idx1-ubyte.gz")  
    
46. test_x_data = read_image("MNIST_data/t10k-images-idx3-ubyte.gz")  # shape: 10000x28x28
    
47. test_x_data = test_x_data.reshape(test_x_data.shape[0], test_x_data.shape[1], test_x_data.shape[2], 1).astype(np.float32)
    
48. test_y_data = read_label("MNIST_data/t10k-labels-idx1-ubyte.gz")
    
49. 
    
50. train_x_minmax = train_x_data / 255.0
    
51. test_x_minmax = test_x_data / 255.0
    
52. 
    
53. # Of course you can also use the utility function to read in MNIST provided by tensorflow
    
54. # from tensorflow.examples.tutorials.mnist import input_data
    
55. # mnist = input_data.read_data_sets("MNIST_data/", one_hot=False)
    
56. # train_x_minmax = mnist.train.images
    
57. # train_y_data = mnist.train.labels
    
58. # test_x_minmax = mnist.test.images
    
59. # test_y_data = mnist.test.labels
    
60. 
    
61. # Reformat y into one-hot encoding style
    
62. lb = preprocessing.LabelBinarizer()
    
63. lb.fit(train_y_data)
    
64. train_y_data_trans = lb.transform(train_y_data)
    
65. test_y_data_trans = lb.transform(test_y_data)
    
66. 
    
67. print "Start evaluating CNN model by tensorflow..."
    
68. 
    
69. # Model input
    
70. x = tf.placeholder(tf.float32, shape=[None, 28, 28, 1])
    
71. y_ = tf.placeholder(tf.float32, [None, 10])
    
72. 
    
73. # Weight initialization
    
74. def weight_variable(shape):
    
75.     initial = tf.truncated_normal(shape, stddev=0.1)
    
76.     return tf.Variable(initial)
    
77. 
    
78. def bias_variable(shape):
    
79.     initial = tf.constant(0.1, shape=shape)
    
80.     return tf.Variable(initial)
    
81. 
    
82. # Convolution and Pooling
    
83. def conv2d(x, W):
    
84.     # `tf.nn.conv2d()` computes a 2-D convolution given 4-D `input` and `filter` tensors
    
85.     # input tensor shape `[batch, in_height, in_width, in_channels]`, batch is number of observation
    
86.     # filter tensor shape `[filter_height, filter_width, in_channels, out_channels]`
    
87.     # strides: the stride of the sliding window for each dimension of input.
    
88.     # padding: 'SAME' or 'VALID', determine the type of padding algorithm to use
    
89.     return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
    
90. 
    
91. def max_pool_2x2(x):
    
92.     # `tf.nn.max_pool` performs the max pooling on the input
    
93.     #  ksize: the size of the window for each dimension of the input tensor.
    
94.     return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')
    
95. 
    
96. 
    
97. # First convolutional layer
    
98. # Convolution: compute 32 features for each 5x5 patch
    
99. # Max pooling: reduce image size to 14x14.
    
100. W_conv1 = weight_variable([5, 5, 1, 32])
     
101. b_conv1 = bias_variable([32])
     
102. 
     
103. h_conv1 = tf.nn.relu(conv2d(x,  W_conv1) + b_conv1)
     
104. h_pool1 = max_pool_2x2(h_conv1)
     
105. 
     
106. # Second convolutional layer
     
107. # Convolution: compute 64 features for each 5x5 patch
     
108. # Max pooling: reduce image size to 7x7
     
109. W_conv2 = weight_variable([5, 5, 32, 64])
     
110. b_conv2 = bias_variable([64])
     
111. 
     
112. h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
     
113. h_pool2 = max_pool_2x2(h_conv2)
     
114. 
     
115. # Densely connected layer
     
116. # Fully-conected layer with 1024 neurons
     
117. W_fc1 = weight_variable([7 * 7 * 64, 1024])
     
118. b_fc1 = bias_variable([1024])
     
119. 
     
120. h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
     
121. h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
     
122. 
     
123. # Dropout
     
124. # To reduce overfitting, we apply dropout before the readout layer.
     
125. keep_prob = tf.placeholder(tf.float32)
     
126. h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
     
127. 
     
128. # Readout layer
     
129. W_fc2 = weight_variable([1024, 10])
     
130. b_fc2 = bias_variable([10])
     
131. 
     
132. y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2
     
133. 
     
134. # Train and evaluate
     
135. loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y_conv, y_))
     
136. # y = tf.nn.softmax(y_conv)
     
137. # loss = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
     
138. optimizer = tf.train.AdamOptimizer(1e-4)
     
139. # optimizer = tf.train.GradientDescentOptimizer(1e-4)
     
140. train = optimizer.minimize(loss)
     
141. 
     
142. correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
     
143. accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
     
144. 
     
145. init = tf.initialize_all_variables()
     
146. sess = tf.Session()
     
147. sess.run(init)
     
148. 
     
149. for step in range(20000):
     
150.     sample_index = np.random.choice(train_x_minmax.shape[0], 50)
     
151.     batch_xs = train_x_minmax[sample_index, :]
     
152.     batch_ys = train_y_data_trans[sample_index, :]
     
153.     if step % 100 == 0:
     
154.         train_accuracy = sess.run(accuracy, feed_dict={
     
155.             x: batch_xs, y_: batch_ys, keep_prob: 1.0})
     
156.         print "step %d, training accuracy %g" % (step, train_accuracy)
     
157.     sess.run(train, feed_dict={x: batch_xs, y_: batch_ys, keep_prob: 0.5})
     
158. 
     
159. print "test accuracy %g" % sess.run(accuracy, feed_dict={
     
160.     x: test_x_minmax, y_: test_y_data_trans, keep_prob: 1.0})

复制代码

输出如下：

1. Start processing MNIST handwritten digits data...
   
2. Start evaluating CNN model by tensorflow...
   
3. step 0, training accuracy 0.1
   
4. step 100, training accuracy 0.82
   
5. step 200, training accuracy 0.92
   
6. step 300, training accuracy 0.96
   
7. step 400, training accuracy 0.92
   
8. step 500, training accuracy 0.92
   
9. step 600, training accuracy 1
   
10. step 700, training accuracy 0.94
    
11. step 800, training accuracy 0.96
    
12. step 900, training accuracy 0.96
    
13. step 1000, training accuracy 0.94
    
14. step 1100, training accuracy 0.98
    
15. step 1200, training accuracy 0.94
    
16. step 1300, training accuracy 0.98
    
17. step 1400, training accuracy 0.96
    
18. step 1500, training accuracy 1
    
19. ...
    
20. step 15700, training accuracy 1
    
21. step 15800, training accuracy 0.98
    
22. step 15900, training accuracy 1
    
23. step 16000, training accuracy 1
    
24. step 16100, training accuracy 1
    
25. step 16200, training accuracy 1
    
26. step 16300, training accuracy 1
    
27. step 16400, training accuracy 1
    
28. step 16500, training accuracy 1
    
29. step 16600, training accuracy 1
    
30. step 16700, training accuracy 1
    
31. step 16800, training accuracy 1
    
32. step 16900, training accuracy 1
    
33. step 17000, training accuracy 1
    
34. step 17100, training accuracy 1
    
35. step 17200, training accuracy 1
    
36. step 17300, training accuracy 1
    
37. step 17400, training accuracy 1
    
38. step 17500, training accuracy 1
    
39. step 17600, training accuracy 1
    
40. step 17700, training accuracy 1
    
41. step 17800, training accuracy 1
    
42. step 17900, training accuracy 1
    
43. step 18000, training accuracy 1
    
44. step 18100, training accuracy 1
    
45. step 18200, training accuracy 1
    
46. step 18300, training accuracy 1
    
47. step 18400, training accuracy 1
    
48. step 18500, training accuracy 1
    
49. step 18600, training accuracy 1
    
50. step 18700, training accuracy 1
    
51. step 18800, training accuracy 1
    
52. step 18900, training accuracy 1
    
53. step 19000, training accuracy 1
    
54. step 19100, training accuracy 1
    
55. step 19200, training accuracy 1
    
56. step 19300, training accuracy 1
    
57. step 19400, training accuracy 1
    
58. step 19500, training accuracy 1
    
59. step 19600, training accuracy 1
    
60. step 19700, training accuracy 1
    
61. step 19800, training accuracy 1
    
62. step 19900, training accuracy 1
    
63. test accuracy 0.9929

复制代码