上一節，我們已經講解了使用全連接網絡實現手寫數字識別，其正確率大概能達到98%，著一節我們使用卷積神經網絡來實現手寫數字識別，

其準確率可以超過99%，程序主要包括以下幾塊內容

• [1]: 導入數據，即測試集和驗證集
• [2]: 引入 tensorflow 啟動InteractiveSession(比session更靈活)
• [3]: 定義兩個初始化w和b的函數，方便後續操作
• [4]: 定義卷積和池化函數，這裏卷積采用padding，使得
• 輸入輸出圖像一樣大，池化采取2x2，那麽就是4格變一格
• [5]: 分配輸入x_和y_
• [6]: 修改x的shape
• [7]: 定義第一層卷積的w和b
• [8]: 把x_image和w進行卷積，加上b，然後應用ReLU激活函數，最後進行max-pooling
• [9]: 第二層卷積，和第一層卷積類似
• [10]: 全連接層
• [11]: 為了減少過擬合，可以在輸出層之前加入dropout。（但是本例子比較簡單，即使不加，影響也不大）
• [12]: 由一個softmax層來得到輸出
• [13]: 定義代價函數，訓練步驟，用Adam來進行優化
• [14]: 使用測試集樣本進行測試

# -*- coding: utf-8 -*-
"""
Created on Mon Apr  2 18:32:47 2018

@author: Administrator
"""

‘‘‘
這裏我們沒有定義一個實現CNN的類，實際上我們可以定義一個CNN的類，並且把每一層也定義成一個類

利用CNN實現手寫數字識別

In [1]: 導入數據，即測試集和驗證集

In [2]: 引入 tensorflow 啟動InteractiveSession(比session更靈活)

In [3]: 定義兩個初始化w和b的函數，方便後續操作

In [4]: 定義卷積和池化函數，這裏卷積采用padding，使得輸入輸出圖像一樣大，池化采取2x2，那麽就是4格變一格

In [5]: 分配輸入x_和y_

In [6]: 修改x的shape

In [7]: 定義第一層卷積的w和b

In [8]: 把x_image和w進行卷積，加上b，然後應用ReLU激活函數，最後進行max-pooling

In [9]: 第二層卷積，和第一層卷積類似

In [10]: 全連接層

In [11]: 為了減少過擬合，可以在輸出層之前加入dropout。（但是本例子比較簡單，即使不加，影響也不大）

In [12]: 由一個softmax層來得到輸出

In [13]: 定義代價函數，訓練步驟，用Adam來進行優化 

In [14]: 使用測試集樣本進行測試

 
‘‘‘


import tensorflow as tf
import numpy as np

‘‘‘
一 導入數據
‘‘‘
from tensorflow.examples.tutorials.mnist import input_data

#mnist是一個輕量級的類，它以numpy數組的形式存儲著訓練，校驗，測試數據集  one_hot表示輸出二值化後的10維
mnist = input_data.read_data_sets(‘MNIST-data‘,one_hot=True)

print(type(mnist)) #<class ‘tensorflow.contrib.learn.python.learn.datasets.base.Datasets‘>
 


print(‘Training data shape:‘,mnist.train.images.shape)           #Training data shape: (55000, 784)
print(‘Test data shape:‘,mnist.test.images.shape)                #Test data shape: (10000, 784)
print(‘Validation data shape:‘,mnist.validation.images.shape)    #Validation data shape: (5000, 784)
print(‘Training label shape:‘,mnist.train.labels.shape)          #Training label shape: (55000, 10)



#設置tensorflow對GPU使用按需分配
config = tf.ConfigProto()
config.gpu_options.allow_growth = True

sess = tf.InteractiveSession(config=config)


‘‘‘
二 構建網絡
‘‘‘
‘‘‘
初始化權值和偏重
為了創建這個模型，我們需要創建大量的權重和偏置項。這個模型中的權重在初始化時應該加入少量的噪聲來
打破對稱性以及避免0梯度。由於我們使用的是ReLU神經元，因此比較好的做法是用一個較小的正數來初始化
偏置項，以避免神經元節點輸出恒為0的問題（dead neurons）。為了不在建立模型的時候反復做初始化操作
，我們定義兩個函數用於初始化。
‘‘‘
def weight_variable(shape):
    #使用正太分布初始化權值
    initial = tf.truncated_normal(shape,stddev=0.1)    #標準差為0.1
    return tf.Variable(initial)

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

‘‘‘
卷積和赤池化
TensorFlow在卷積和池化上有很強的靈活性。我們怎麽處理邊界？步長應該設多大？在這個實例裏，我們會
一直使用vanilla版本。我們的卷積使用1步長（stride size），0邊距（padding size）的模板，保證輸
出和輸入是同一個大小。我們的池化用簡單傳統的2x2大小的模板做max pooling。為了代碼更簡潔，我們把
這部分抽象成一個函數。
‘‘‘
#定義卷積層
def conv2d(x,W):
    ‘‘‘默認 strides[0] = strides[3] = 1,strides[1]為x方向步長，strides[2]為y方向步長
     Given an input tensor of shape `[batch, in_height, in_width, in_channels]`
     and a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, 
     out_channels]`
    ‘‘‘
    return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding = ‘SAME‘)

#pooling層
def max_pooling(x):
    return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding=‘SAME‘)


#我們通過為輸入圖像和目標輸出類別創建節點，來開始構建計算題  None表示數值不固定，用來指定batch的大小
x_ = tf.placeholder(tf.float32,[None,784])
y_ = tf.placeholder(tf.float32,[None,10])


#把x轉換為卷積所需要的形式  batch_size張手寫數字，每張維度為1x28x28
‘‘‘
為了用這一層，我們把x變成一個4d向量，其第2、第3維對應圖片的寬、高，最後一維代表圖片的顏色通道數
(因為是灰度圖所以這裏的通道數為1，如果是rgb彩色圖，則為3)。
‘‘‘
X = tf.reshape(x_,shape=[-1,28,28,1])


‘‘‘
現在我們可以開始實現第一層了。它由一個卷積接一個max pooling完成。卷積在每個5x5的patch中算出
32個特征。卷積的權重張量形狀是[5, 5, 1, 32]，前兩個維度是patch的大小，接著是輸入的通道數目，
最後是輸出的通道數目。 而對於每一個輸出通道都有一個對應的偏置量。
‘‘‘
#第一層卷積，32個濾波器，卷積和為1*5*5  h_conv1.shape=[-1,28,28,32]
w_conv1 = weight_variable([5,5,1,32])
b_conv1 = bias_variable([32])
h_conv1 = tf.nn.relu(conv2d(X,w_conv1) + b_conv1)

#第一個pooling層 最大值池化層2x2 [-1,28,28,28]->[-1,14,14,32]
h_pool1 = max_pooling(h_conv1)



#第二層卷積，64個濾波器，卷積和為32*5*5  h_conv2.shape=[-1,14,14,64]
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)

#第二個pooling層 最大值池化層2x2 [-1,14,14,64]->[-1,7,7,64]
h_pool2 = max_pooling(h_conv2)

‘‘‘
全連接層
現在，圖片尺寸減小到7x7，我們加入一個有1024個神經元的全連接層，用於處理整個圖片。我們把池化層輸
出的張量reshape成一些向量，乘上權重矩陣，加上偏置，然後對其使用ReLU。
‘‘‘
h_poo2_falt = tf.reshape(h_pool2,[-1,7*7*64])
#隱藏層
w_h = weight_variable([7*7*64,1024])
b_h = bias_variable([1024])
hidden = tf.nn.relu(tf.matmul(h_poo2_falt,w_h) + b_h)


‘‘‘
加入棄權，把部分神經元輸出置為0
為了減少過擬合，我們在輸出層之前加入dropout。我們用一個placeholder來代表一個神經元的輸出在
dropout中保持不變的概率。這樣我們可以在訓練過程中啟用dropout，在測試過程中關閉dropout。
TensorFlow的tf.nn.dropout操作除了可以屏蔽神經元的輸出外，還會自動處理神經元輸出值的scale。
所以用dropout的時候可以不用考慮scale。
‘‘‘
keep_prob = tf.placeholder(tf.float32)    #棄權概率
hidden_drop = tf.nn.dropout(hidden,keep_prob)

‘‘‘
輸出層
最後，我們添加一個softmax層，就像前面的單層softmax regression一樣。
‘‘‘
w_o = weight_variable([1024,10])
b_o = bias_variable([10])
output = tf.nn.softmax(tf.matmul(hidden_drop,w_o) + b_o)


‘‘‘
三 設置對數似然損失函數
‘‘‘
#代價函數 J =-(Σy.logaL)/n    .表示逐元素乘
cost = -tf.reduce_sum(y_*tf.log(output))


‘‘‘
四 求解
‘‘‘
train = tf.train.AdamOptimizer(0.0001).minimize(cost)

#預測結果評估
#tf.argmax(output,1)  按行統計最大值得索引
correct = tf.equal(tf.argmax(output,1),tf.argmax(y_,1))       #返回一個數組 表示統計預測正確或者錯誤 
accuracy = tf.reduce_mean(tf.cast(correct,tf.float32))        #求準確率


#創建list 保存每一叠代的結果
training_accuracy_list = []
test_accuracy_list = []
training_cost_list=[]
test_cost_list=[]


#使用會話執行圖
sess.run(tf.global_variables_initializer())   #初始化變量

#開始叠代 使用Adam優化的隨機梯度下降法
for i in range(1000):   #一個epoch需要叠代次數計算公式：測試集長度 / batch_size
    x_batch,y_batch = mnist.train.next_batch(batch_size = 64)   
    #開始訓練
    train.run(feed_dict={x_:x_batch,y_:y_batch,keep_prob:1.0})   
    if (i+1)%200 == 0:
         #輸出訓練集準確率
        #training_accuracy = accuracy.eval(feed_dict={x_:mnist.train.images,y_:mnist.train.labels})
        training_accuracy,training_cost = sess.run([accuracy,cost],feed_dict={x_:x_batch,y_:y_batch,keep_prob:1.0})
        training_accuracy_list.append(training_accuracy)
        training_cost_list.append(training_cost)        
        print(‘Step {0}:Training set accuracy {1},cost {2}.‘.format(i+1,training_accuracy,training_cost))

#全部訓練完成做測試  分成200次，一次測試50個樣本
#輸出測試機準確率   如果一次性全部做測試，內容不夠用會出現OOM錯誤。所以測試時選取比較小的mini_batch來測試
#test_accuracy = accuracy.eval(feed_dict={x_:mnist.test.images,y_:mnist.test.labels})
for i in range(200):        
    x_batch,y_batch = mnist.train.next_batch(batch_size = 50)           
    test_accuracy,test_cost = sess.run([accuracy,cost],feed_dict={x_:mnist.test.images,y_:mnist.test.labels,keep_prob:1.0})
    test_accuracy_list.append(test_accuracy)
    test_cost_list.append(test_cost) 
    print(‘Step {0}:Test set accuracy {1},cost {2}.‘.format(i+1,test_accuracy,test_cost)) 
print(‘Test accuracy:‘,np.mean(test_accuracy_list))
        

‘‘‘
圖像操作
‘‘‘
import matplotlib.pyplot as plt
#隨便取一張圖像
img = mnist.train.imgaes[0]
label = mnist.train.labels[0]

print(‘圖像像素值：{0},對應的標簽{1}‘,img.reshape(28,28),np.argmax(label,axis=1))

plt.figure()

#子圖1
plt.subplot(1,2,1)
plt.imshow(img.reshape(28,28))                #顯示的是熱度圖片
plt.axis(‘off‘)                               #不顯示坐標軸

#子圖2
plt.subplot(1,2,2)
plt.imshow(img.reshape(28,28),cmap=‘gray‘)    #顯示灰度圖片
plt.axis(‘off‘)


plt.show()

‘‘‘
顯示卷積和池化層結果
‘‘‘
plt.figure()
#顯示第一個卷積層之後的結果  (1,28,28,32)
conv1 = h_conv1.eval(feed_dict={x_:img,y_:label,keep_prob:1.0})
print(‘conv1 shape‘,conv1.shape)

for i in range(32):
    show_image = conv1[:,:,:,1]
    show_image.shape = [28,28]
    plt.subplot(4,8,i)
    plt.imshow(show_image,cmap=‘gray‘)
    plt.axis(‘off‘)
plt.show()   

plt.figure()
#顯示第一個池化層之後的結果  (1,14,14,32)
pool1 = h_pool1.eval(feed_dict={x_:img,y_:label,keep_prob:1.0})
print(‘conv1 shape‘,pool1.shape)

for i in range(32):
    show_image = pool1[:,:,:,1]
    show_image.shape = [28,28]
    plt.subplot(4,8,i)
    plt.imshow(show_image,cmap=‘gray‘)
    plt.axis(‘off‘)
plt.show()     

第三節，TensorFlow 使用CNN實現手寫數字識別