機器學習實戰：TensorFlow構建簡單卷積神經網絡

模型架構

輸入數據：n*784的數據

第一層卷積：卷積層1（filter=3* 3*1,個數爲64個,padding=1,s=1)

第一層池化：池化層1（maxpooling:2*2,s=2)

第二層卷積：卷積層2（filter：3* 3* 64,128個filter,padding=1,s=1）

第二層池化：池化層2（maxpooling:2*2,s=2）

全連接層第一層：全連接層第一層（總結爲1024個向量）

全連接層第二層：全連接層第二層（10個向量)

完成代碼如下：

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

mnist = input_data.read_data_sets('data/',one_hot=True)

n_input = 784
n_out = 10

weights = {
    'wc1': tf.Variable(tf.random_normal([3,3,1,64],stddev=0.1)),#第一層卷積的【高，寬，通道，個數】
    'wc2': tf.Variable(tf.random_normal([3,3,64,128],stddev=0.1)),#第二層卷積的【高，寬，通道，個數】
    'wd1': tf.Variable(tf.random_normal([7*7*128,1024],stddev=0.1)),#第三層全連接層的參數
    'wd2': tf.Variable(tf.random_normal([1024,n_out],stddev=0.1))#輸出層參數
}

biases = {
    'bc1':tf.Variable(tf.random_normal([64],stddev=0.1)),#bc1是根據第一層卷積層神經元數決定的
    'bc2':tf.Variable(tf.random_normal([128],stddev=0.1)),#bc2是根據第二層卷積層神經元數決定的
    'bd1':tf.Variable(tf.random_normal([1024],stddev=0.1)),#bd1是根據全連接層神經元數決定的
    'bd2':tf.Variable(tf.random_normal([n_out],stddev=0.1))
}

def conv_basic(_input,_w,_b,_keepratio):# 卷積神經網絡的前向傳播
    # 對輸入進行簡單的預處理[n,h,w,c]-bitchsize大小，圖像的高度、寬度，深度
    _input_r = tf.reshape(_input,shape=[-1,28,28,1])# -1意思是讓TensorFlow自己做一個推斷，確定了其他所有維，可推斷出第一維
    '''
        tf.nn.conv2d(input, filter, strides, padding, use_cudnn_on_gpu=None, name=None)
        除去name參數用以指定該操作的name，與方法有關的一共五個參數：
        第一個參數input：指需要做卷積的輸入圖像，它要求是一個Tensor，具有[batch, in_height, in_width, in_channels]這樣的shape，
        具體含義是[訓練時一個batch的圖片數量, 圖片高度, 圖片寬度, 圖像通道數]，注意這是一個4維的Tensor，要求類型爲float32和float64其中之一
        第二個參數filter：相當於CNN中的卷積核，它要求是一個Tensor，具有[filter_height, filter_width, in_channels, out_channels]這樣的shape，
        具體含義是[卷積核的高度，卷積核的寬度，圖像通道數，卷積核個數]，要求類型與參數input相同，有一個地方需要注意，第三維in_channels，就是參數input的第四維
        第三個參數strides：卷積時在圖像每一維的步長，這是一個一維的向量，長度4分別是[訓練時一個batch的圖片數量, 圖片高度, 圖片寬度, 圖像通道數]四個維度
        第四個參數padding：string類型的量，只能是"SAME","VALID"其中之一，這個值決定了不同的卷積方式
        第五個參數：use_cudnn_on_gpu:bool類型，是否使用cudnn加速，默認爲true
    '''
    # "VALID" 僅捨棄最後列，或最後行的數據
    # "SAME" 嘗試在數據左右均勻的填充0，若填充個數爲奇數時，則將多餘的填充值放數據右側.

    _conv1 = tf.nn.conv2d(_input_r,_w['wc1'],strides=[1,1,1,1],padding='SAME')
    _conv1 = tf.nn.relu(tf.nn.bias_add(_conv1,_b['bc1']))

    '''
        tf.nn.max_pool(value, ksize, strides, padding, name=None)
        參數是四個，和卷積很類似：
        第一個參數value：需要池化的輸入，一般池化層接在卷積層後面，所以輸入通常是feature map，依然是[batch, height, width, channels]這樣的shape
        第二個參數ksize：池化窗口的大小，取一個四維向量，一般是[1, height, width, 1]，因爲我們不想在batch和channels上做池化，所以這兩個維度設爲了1
        第三個參數strides：和卷積類似，窗口在每一個維度上滑動的步長，一般也是[1, stride, stride, 1]
        第四個參數padding：和卷積類似，可以取'VALID'或者'SAME'
        返回一個Tensor，類型不變，shape仍然是[batch, height, width, channels]這種形式

    '''

    '''
    	tf.nn.dropout(x, keep_prob, noise_shape=None, seed=None, name=None)
    	根據給出的keep_prob參數，將輸入tensor x按比例輸出。
    	使用說明：
    	參數 keep_prob: 表示的是保留的比例，假設爲0.8，則20 % 的數據變爲0，然後其他的數據乘以1 / keep_prob；keep_prob越大，保留的越多；
    	參數 noise_shape：干擾形狀。此字段默認是None，表示第一個元素的操作都是獨立，但是也不一定。比例：數據的形狀是shape(x) = [k, l, m, n]，而noise_shape = [k, 1, 1,n]，
    	則第1和4列是獨立保留或刪除，第2和3列是要麼全部保留，要麼全部刪除

    '''

    _pool1 = tf.nn.max_pool(_conv1,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
    _pool1_dr1 = tf.nn.dropout(_pool1,_keepratio)# _keepratio表示保留的比例

    _conv2 = tf.nn.conv2d(_pool1_dr1,_w['wc2'],strides=[1,1,1,1],padding='SAME')
    _conv2 = tf.nn.relu(tf.nn.bias_add(_conv2,_b['bc2']))

    _pool2 = tf.nn.max_pool(_conv2,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
    _pool_dr2 = tf.nn.dropout(_pool2,_keepratio)

    # 全連接層——把輸出轉換爲矩陣（向量）的形式
    _densel = tf.reshape(_pool_dr2,[-1,_w['wd1'].get_shape().as_list()[0]])
    _fc = tf.nn.relu(tf.add(tf.matmul(_densel,_w['wd1']),_b['bd1']))
    _fc_dr1 = tf.nn.dropout(_fc,_keepratio)

    _out = tf.add(tf.matmul(_fc_dr1,_w['wd2']),_b['bd2'])
    out = {'input_r': _input_r, 'conv1': _conv1, 'pool1': _pool1, 'pool1_dr1': _pool1_dr1,
           'conv2': _conv2, 'pool2': _pool2, 'pool_dr2': _pool_dr2, 'densel': _densel,
           'fc1': _fc, 'fc_dr1': _fc_dr1, 'out': _out}
    return out

print("CNN READY")

x = tf.placeholder(tf.float32,[None,n_input])
y = tf.placeholder(tf.float32,[None,n_out])
keepratio = tf.placeholder(tf.float32)

#預測結果值
_pred = conv_basic(x,weights,biases,keepratio)['out']

#計算損失
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=_pred,labels=y))

#使用梯度下降方法求解最小值就是得到的優化值
optm = tf.train.GradientDescentOptimizer(learning_rate=0.001).minimize(cost)

#準確率
_corr = tf.equal(tf.arg_max(_pred,1),tf.argmax(y,1))#equal是判斷預測得到的結果和真實y之間結果是否相同
accr = tf.reduce_mean(tf.cast(_corr,tf.float32))#tf.cast函數將布爾值轉換成float

#初始化所有
init = tf.initialize_all_variables()

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

training_epochs = 50
batch_size = 64
display_step = 1

for epoch in range(training_epochs):
    avg_cost = 0
    num_batch = int(mnist.train.num_examples/batch_size)
    for i in range(num_batch):
        batch_xs,batch_ys = mnist.train.next_batch(batch_size)
        feed = {x:batch_xs,y:batch_ys,keepratio:0.7}
        sess.run(optm,feed_dict=feed)
        avg_cost = avg_cost + sess.run(cost,feed_dict={x:batch_xs,y:batch_ys,keepratio:1.})
    avg_cost = avg_cost /num_batch
    if epoch%display_step ==0:
        print("Epoch: %03d/%03d cost: %.9f" % (epoch, training_epochs, avg_cost))
        train_acc = sess.run(accr, feed_dict={x: batch_xs, y: batch_ys, keepratio: 1.})
        print("Training accuracy: %.3f" % (train_acc))
print("FINISHED")