使用TensorFlow的卷積神經網絡識別自己的單個手寫數字，填坑總結

 

折騰了幾天，爬了大大小小若干的坑，特記錄如下。代碼在最后面。

 

環境：

Python3.6.4 + TensorFlow 1.5.1 + Win7 64位 + I5 3570 CPU

 

方法：

先用MNIST手寫數字庫對CNN（卷積神經網絡）進行訓練，准確度達到98%以上時，再准備獨家手寫數字10個、畫圖軟件編輯的數字10個共計20個，讓訓練好的CNN進行識別，考察其識別准確度。

 

 調試代碼：

坑1：ModuleNotFoundError: No module named 'google'

解決：pip install protobuf

不用翻牆

 

坑2：ModuleNotFoundError: No module named 'absl'
解決：pip install absl-py

 

坑3：tensorflow.python.framework.errors_impl.InvalidArgumentError: You must feed a value for placeholder tensor 'Placeholder_2' with dtype float

解決：這個問題折騰我好久，但是最終的解決方法很無語。。。

原來的代碼是這樣的：

output = sess.run(y_conv, feed_dict={x: ndarrayImgs})  # ndarrayImgs為自己的樣本圖片數據

查了不少資料，最后發現是自己少寫了一個參數 /笑哭/笑哭， 寫成這樣就沒問題了：

output = sess.run(y_conv, feed_dict={x: ndarrayImgs, keep_prob:1.0}) 

 

 

代碼調通了之后，大坑來了：訓練后的CNN識別自己的手寫數字和用畫圖軟件編輯出來的數字，正確率只有70%左右，慘不忍睹。

 

考慮到上面20個數字都是五官端正的，那么准確率低多半是其它原因。調試思路：

1）檢查20個數字圖片的格式：灰度圖片，黑底白字，28x28像素。沒問題。

2）用MNIST自帶的測試數據進行測試，正確率95%左右。說明CNN訓練的還算到位。

3）去網上搜索，終於在知乎里發現了一條回復：MNIST的數字都是20*20大小，圖片大小28*28。把自己的圖片伸縮到20*20大小，然后平移到28*28的中心就可以了。

納尼？？原來數字輪廓大小是20x20像素，這個細節我沒注意到。開動PS，利用裁切和調整畫布功能，對圖片處理了一番。

附：MNIST數據庫及其說明   http://yann.lecun.com/exdb/mnist/

 

再次測試，正確率在85-90%左右，有明顯提升。

然而仔細分析發現，有幾個數字的識別結果經常出錯，分別是手寫的6、7、9。將這幾個數字的圖片和樣本庫中的圖片對比了一下，猜想可能是這幾個圖片中的數字的線條有些細，於是用PS又調整了一下，把線條變粗，結果識別正確率可以達到95-100%了（奇怪的是，數字1-5線條也細，為何能准確識別？）

 

調試過程記錄完畢，放代碼。使用時注意系統環境和相關軟件版本，如開頭所述。

這個代碼在每次識別前都會先訓練，在CPU上進行計算真是痛苦。。。以后打算將訓練和預測分開，訓練好的模型保存起來，預測的時候直接加載，這樣能省不少時間。

 代碼沒優化，有點凌亂，建議移步去看我的《使用TensorFlow的卷積神經網絡識別手寫數字》1、2、3系列。

 

import matplotlib
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import pylab
from tensorflow.examples.tutorials.mnist import input_data


def showMnistImg(nBytes):
    imgBytes = nBytes.reshape((28, 28))
    print(imgBytes)
    plt.figure(figsize=(2.8,2.8))
    #plt.grid() #開啟網格 
    plt.imshow(imgBytes, cmap=cm.gray)
    pylab.show()
    

def MaxMinNormalization(x,Max,Min):  
    x = (x - Min) / (Max - Min);
    return x;


def loadHandWritingImage(strFilePath):
    im=Image.open(strFilePath, 'r')
    ndarrayImg = np.array(im.convert("L"), dtype='float64')

    return ndarrayImg

def normalizeImage(ndarrayImg, maxVal = 255, minVal = 0):
    w, h = ndarrayImg.shape[0], ndarrayImg.shape[1] 
    for i in range(w):
      for j in range(h):
        ndarrayImg[i,j] = MaxMinNormalization(ndarrayImg[i,j], maxVal, minVal) #???
        
    return ndarrayImg

mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

# 單個手寫數字的784個字節的灰度值，浮點數，范圍[0,1)
print('type(mnist.train.images): ', type(mnist.train.images))  # <class 'numpy.ndarray'>
print('mnist.train.images.shape: ', mnist.train.images.shape)
##print(mnist.train.images[0])
##showMnistImg(mnist.train.images[0])


# 單個手寫數字的標簽
# 一個one-hot向量除了某一位的數字是1以外其余各維度數字都是0
# 數字n將表示成一個只有在第n維度（從0開始）數字為1的10維向量。
#print('type(mnist.train.labels[0]): ', type(mnist.train.labels[0]))# <class 'numpy.ndarray'>
#print(mnist.train.labels[19])      # [0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]


  
#構造自己的手寫圖片集合，作為test。  cnblogs.com/hatemath
from PIL import *
import numpy as np
import tensorflow as tf

# 構建測試樣本集合
files = ['0.png', '1.png', '2.png', '3.png', '4.png', '5.png', '6.png', '7.png', '8.png', '9.png',
         '00.png', '11.png', '22.png', '33.png', '44.png', '55.png', '66.png', '77.png', '88.png', '99.png']

ndarrayImgs = np.zeros((len(files), 784)) # x行784列
#print('type(ndarrayImgs): ', type(ndarrayImgs))
#print('ndarrayImgs.shape: ', ndarrayImgs.shape)

index = 0
for file in files:
    
    # 加載圖片
    ndarrayImg = loadHandWritingImage('numbers/' + file)

    #print('type(ndarrayImg): ', type(ndarrayImg))
    #print(ndarrayImg)
    
    # 歸一化
    normalizeImage(ndarrayImg)

    # 轉為1x784的數組
    ndarrayImg = ndarrayImg.reshape((1, 784))
    #print('type(ndarrayImg): ', type(ndarrayImg))
    #print('ndarrayImg.shape: ', ndarrayImg.shape)

    # 放到測試樣本集中
    ndarrayImgs[index] = ndarrayImg
    index = index + 1


# 構建測試樣本的實際值集合，用於計算正確率
ndarrayLabels = np.array([   [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
                             [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],
                             [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],
                             [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],
                             [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],
                             [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],
                             [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],
                             [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],
                             [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
                             [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.],
                             [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
                             [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],
                             [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],
                             [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],
                             [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],
                             [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],
                             [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],
                             [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],
                             [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
                             [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]
                             ])
print('type(ndarrayLabels): ', type(ndarrayLabels))


#print(ndarrayImgs[3])
##showMnistImg(ndarrayImgs[3])
#print(ndarrayLabels[3]) 


# 下面開始CNN相關

def conv2d(x, W):
  return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

def max_pool_2x2(x):
  return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                        strides=[1, 2, 2, 1], padding='SAME')


def weight_variable(shape):
  initial = tf.truncated_normal(shape, stddev=0.1)
  return tf.Variable(initial)

def bias_variable(shape):
  initial = tf.constant(0.1, shape=shape)
  return tf.Variable(initial)


x = tf.placeholder(tf.float32, shape=[None, 784])
y_ = tf.placeholder(tf.float32, shape=[None, 10])


W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])

x_image = tf.reshape(x, [-1, 28, 28, 1])

h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)


W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])

h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)



W_fc1 = weight_variable([7 * 7 * 64, 1024])
b_fc1 = bias_variable([1024])

h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)


keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)


W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])

y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2
#print(y_conv)



cross_entropy = tf.reduce_mean(
    tf.nn.softmax_cross_entropy_with_logits_v2(labels=y_, logits=y_conv))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

with tf.Session() as sess:
  sess.run(tf.global_variables_initializer())
  for i in range(1000):
    batch = mnist.train.next_batch(50)
    
    if i % 100 == 0:
      train_accuracy = accuracy.eval(feed_dict={
          x: batch[0], y_: batch[1], keep_prob: 1.0})
      print('step %d, training accuracy %g' % (i, train_accuracy))
      if(train_accuracy>0.98):
          break
          
    train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})



  print('測試Mnist test數據集 准確率 %g' % accuracy.eval(feed_dict={
      x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))

  # 測試耗時
  import time
  start = time.time()
  accu = accuracy.eval(feed_dict={x: ndarrayImgs, y_: ndarrayLabels, keep_prob: 1.0})
  end = time.time()
  
  print('識別zzh手寫數據%d個, 准確率為 %g, 每個耗時%g秒' % (len(ndarrayImgs), accu, (end-start)/len(ndarrayImgs)))

  output = sess.run(y_conv, feed_dict={x: ndarrayImgs, keep_prob:1.0})  
  print('預測值：', output.argmax(axis=1)) # axis：0表示按列，1表示按行
  print('實際值：', ndarrayLabels.argmax(axis=1))

 

 

貼2次運行結果，供參考：

 

Extracting MNIST_data\train-images-idx3-ubyte.gz
Extracting MNIST_data\train-labels-idx1-ubyte.gz
Extracting MNIST_data\t10k-images-idx3-ubyte.gz
Extracting MNIST_data\t10k-labels-idx1-ubyte.gz

type(mnist.train.images):  <class 'numpy.ndarray'>
mnist.train.images.shape:  (55000, 784)
type(ndarrayLabels):  <class 'numpy.ndarray'>

step 0, training accuracy 0.14
step 100, training accuracy 0.86
step 200, training accuracy 0.82
step 300, training accuracy 0.98

測試Mnist test數據集 准確率 0.9213
識別zzh手寫數據20個, 准確率為 0.9, 每個耗時0.000750029秒
預測值： [0 1 2 3 4 5 6 1 8 9 0 1 2 3 4 5 6 2 8 9]
實際值： [0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9]
>>> 

 

Extracting MNIST_data\train-images-idx3-ubyte.gz
Extracting MNIST_data\train-labels-idx1-ubyte.gz
Extracting MNIST_data\t10k-images-idx3-ubyte.gz
Extracting MNIST_data\t10k-labels-idx1-ubyte.gz

type(mnist.train.images):  <class 'numpy.ndarray'>
mnist.train.images.shape:  (55000, 784)
type(ndarrayLabels):  <class 'numpy.ndarray'>

step 0, training accuracy 0.14
step 100, training accuracy 0.84
step 200, training accuracy 0.92
step 300, training accuracy 0.88
step 400, training accuracy 0.96
step 500, training accuracy 0.98

測試Mnist test數據集 准確率 0.9445
識別zzh手寫數據20個, 准確率為 1, 每個耗時0.000779998秒
預測值： [0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9]
實際值： [0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9]
>>>

 

  

總結：

　　1) CNN雖然是個神器，但是要想提高手寫數字識別率，除了CNN的訓練外，還要在手寫圖片上做足前戲，啊呸，做足預處理，要把手寫圖片按照MNIST規范進行調整，畢竟訓練的樣本就是按照那些規范來的。

　　2) 再次重申一下圖片規范：灰度圖片，黑底白字，數字的外圍輪廓大小是20x20像素，圖片總體的大小是28x28像素。自動化的預處理可以用opencv來做。

　　3) 用CPU做訓練，非常慢。我的機器上，訓練500次耗時1分鍾，每次調試都這么等，太浪費時間了。考慮保存/加載模型的方案，或者搞一塊N卡，用CUDA計算應該會快很多。