如果不明白什麼是卷積神經網路,請參考:計算機視覺與卷積神經網路 下面基於開源的實現簡單梳理如何用tensorflow實現卷積神經網路.

實現卷積神經網路

載入資料集

# 載入資料集
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/",one_hot=True)
sess = tf.InteractiveSession()

定義函式

對於一些常用到的引數,定義函式去簡化他們,如權重和偏置的函式定義.其中tf.truncated_normal

# w,b,可以複用，因此設為函式
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)

定義卷積層的函式:
首先明確卷積核的引數有卷積核的尺寸,channel,和卷積核的個數,同時要定義步長的大小,和邊界的處理情況.

1. w: [5,5,1,32]其含義為5*5的卷積核,1個通道,32個卷積核.
2. stride表示步長,即卷積內積時滑動的步長,都是1代表不會遺漏圖片中的每一個點.
3. padding表示邊界的處理方式.

以上都是卷積層重要的引數,是需要記住的重要的知識點.

# 卷積層
# x輸入,W卷積引數[5,5,1,32]  5*5的卷積核，1個深度，32個卷積核
def conv2d(x,W):
    return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')

定義池化層函式:
這裡採用最大采樣,尺度為2*2,即在2*2的視窗中取出最大的一個畫素.滑動的步長為2

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

實現過程

首先placehoder需要傳入訓練的資料:
這裡是用的批量訓練的方法,即mini-batch.所以如下定義x,y_,其中x為訓練的樣本,每一個樣本為1*784的向量.x為若干個樣本,y_為真實的樣本類別,每個樣本為一個1*10的向量,其中有一個為1,其餘為0.

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

構建卷積,池化層:
卷積層+ReLU+最大池化層構成一個單元.這裡第一個卷積層有32個卷積核,所以第二個卷積的引數w為W_conv2 = weight_variable([5,5,32,64])32個通道,輸出64個卷積核.

# 卷積，relu,池化
W_conv1 = weight_variable([5,5,1,32])
b_conv1 = bias_variable([32])
#relu
h_conv1 = tf.nn.relu(conv2d(x_image,W_conv1)+b_conv1)
h_pool1 = max_pool_22(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_22(h_conv2)    # 7×7×64

本身影象的大小為28*28經過二次最大池化層變成了7*7,同時最後輸出64個卷積核因此輸出的tensor尺寸為7*7*64.
定義全連線層:

# 全連線層,輸入是7*7*64,輸出為1024個隱含層
W_fc1 = weight_variable([7*7*64,1024])    #1d
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)
# 採用dropout的trick
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1,keep_prob)
# 輸出層,10個神經元,輸入為1024
W_fc2 = weight_variable([1024,10])
b_fc2 = weight_variable([10])
# 輸出用sotfmax
y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop,W_fc2)+b_fc2)

定義損失函式,優化方式

# 定義loss,optimizer
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y_conv),reduction_indices=[1]))
train_step  =tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)

訓練即驗證

##啟動變了初始化
tf.global_variables_initializer().run()
correct_prediction = tf.equal(tf.argmax(y_conv,1),tf.argmax(y_,1))       

#高維度的
acuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))    

#要用reduce_mean
for i in range(30000):
    batch_x,batch_y  = mnist.train.next_batch(50)
    if i%1000==0:
        train_accuracy = acuracy.eval({x:batch_x,y_:batch_y,keep_prob:1.0})
        print("step %d,train_accuracy %g"%(i,train_accuracy))
    train_step.run(feed_dict={x:batch_x,y_:batch_y,keep_prob:0.5})

測試集結果

#test
print acuracy.eval({x:mnist.test.images,y_:mnist.test.labels,keep_prob:1.0})

執行結果為:

step 9000,train_accuracy 0.98
step 10000,train_accuracy 1
step 11000,train_accuracy 1
step 12000,train_accuracy 1
step 13000,train_accuracy 0.98
step 14000,train_accuracy 1
step 15000,train_accuracy 1
step 16000,train_accuracy 1
step 17000,train_accuracy 1
step 18000,train_accuracy 1
step 19000,train_accuracy 1
step 20000,train_accuracy 1
step 21000,train_accuracy 1
step 22000,train_accuracy 1
step 23000,train_accuracy 1
step 24000,train_accuracy 1
step 25000,train_accuracy 1
step 26000,train_accuracy 1
step 27000,train_accuracy 1
step 28000,train_accuracy 1
step 29000,train_accuracy 1
######測試的誤差
0.9919

參考資料: