卷積神經網絡CNN原理詳解及TensorFlow編寫CNN

前一篇文章介紹什么是過擬合，并采用droput解決神經網絡中過擬合的問題，以TensorFlow和sklearn的load_digits為案例講解；本篇文章詳細講解了卷積神經網絡CNN原理，并通過TensorFlow編寫CNN實現了MNIST分類學習案例。本專欄主要結合作者之前的博客、AI經驗和"莫煩大神"的視頻介紹，后面隨著深入會講解更多的Python人工智能應用。

基礎性文章，希望對您有所幫助，如果文章中存在錯誤或不足之處，還請海涵~作者作為人工智能的菜鳥，希望大家能與我在這一筆一劃的博客中成長起來。寫了這么多年博客，嘗試第一個付費專欄，但更多博客尤其基礎性文章，還是會繼續免費分享，但該專欄也會用心撰寫，望對得起讀者，共勉！

文章目錄：

• 一.卷積神經網絡原理
• 1.什么是CNN
• 2.CNN原理
• 二.TensorFlow實現CNN
• 三.總結

代碼下載地址（歡迎大家關注點贊）：

• https://github.com/eastmountyxz/
• AI-for-TensorFlow
• https://github.com/eastmountyxz/
• AI-for-Keras

學Python近八年，認識了很多大佬和朋友，感恩。作者的本意是幫助更多初學者入門，因此在github開源了所有代碼，也在公眾號同步更新。深知自己很菜，得拼命努力前行，編程也沒有什么捷徑，干就對了。希望未來能更透徹學習和撰寫文章，也能在讀博幾年里學會真正的獨立科研。同時非常感謝參考文獻中的大佬們的文章和分享。

- https://blog.csdn.net/eastmount

一.卷積神經網絡原理

1.什么是CNN

一般的神經網絡在理解圖片信息的時候還是有不足之處，這時卷積神經網絡就成為了計算機處理圖片的助推器。卷積神經網絡的英文是Convolutional Neural Network，簡稱CNN。它通常應用于圖像識別和語音識等領域，并能給出更優秀的結果，也可以應用于視頻分析、機器翻譯、自然語言處理、藥物發現等領域。著名的阿爾法狗讓計算機看懂圍棋就是基于卷積神經網絡的。

神經網絡是由很多神經層組成，每一層神經層中存在很多神經元，這些神經元是識別事物的關鍵，當輸入是圖片時，其實就是一堆數字。

首先，卷積是什么意思呢？卷積是指不在對每個像素做處理，而是對圖片區域進行處理，這種做法加強了圖片的連續性，看到的是一個圖形而不是一個點，也加深了神經網絡對圖片的理解。

卷積神經網絡批量過濾器，持續不斷在圖片上滾動搜集信息，每一次搜索都是一小塊信息，整理這一小塊信息之后得到邊緣信息。比如第一次得出眼睛鼻子輪廓等，再經過一次過濾，將臉部信息總結出來，再將這些信息放到全神經網絡中進行訓練，反復掃描最終得出的分類結果。如下圖所示，貓的一張照片需要轉換為數學的形式，這里采用長寬高存儲，其中黑白照片的高度為1，彩色照片的高度為3(RGB)。

過濾器搜集這些信息，將得到一個更小的圖片，再經過壓縮增高信息嵌入到普通神經層上，最終得到分類的結果，這個過程即是卷積。Convnets是一種在空間上共享參數的神經網絡，如下圖所示，它將一張RGB圖片進行壓縮增高，得到一個很長的結果。

近幾年神經網絡飛速發展，其中一個很重要的原因就是CNN卷積神經網絡的提出，這也是計算機視覺處理的飛躍提升。關于TensorFlow中的CNN，Google公司也出了一個非常精彩的視頻教程，也推薦大家去學習。

Google官方卷積神經網絡介紹視頻 - 優達學城

2.CNN原理

本文主要講解如何去應用CNN，下面我們先簡單看看CNN是如何處理信息的。這里參考Google官方視頻介紹，強烈推薦大家學習。

假設你有一張小貓咪的照片，如下圖所示，它可以被表示為一個博餅，它有寬度（width）和高度（height），并且由于天然存在紅綠藍三色，它還擁有RGB厚度（depth），此時你的輸入深度為3。

假設我們現在拿出圖片的一小塊，運行一個具有K個輸出的小神經網絡，像圖中一樣把輸出表示為垂直的一小列。

在不改變權重的情況下，通過小神經網絡滑動掃遍整個圖片，就像我們拿著刷子刷墻一樣水平垂直的滑動。

此時，輸出端畫出了另一幅圖像，如下圖中紅色區域所示。它與之前的寬度和高度不同，更重要的是它跟之前的深度不同，而不是僅僅只有紅綠藍，現在你得到了K個顏色通道，這種操作稱為——卷積。

如果你的塊大小是整張圖片，那它跟普通的神經網絡層沒有任何區別，正是由于我們使用了小塊，我們有很多小塊在空間中共享較少的權重。卷積不在對每個像素做處理，而是對圖片區域進行處理，這種做法加強了圖片的連續性，也加深了神經網絡對圖片的理解。

一個卷積網絡是組成深度網絡的基礎，我們將使用數層卷積而不是數層的矩陣相乘。如下圖所示，讓它形成金字塔形狀，金字塔底是一個非常大而淺的圖片，僅包括紅綠藍，通過卷積操作逐漸擠壓空間的維度，同時不斷增加深度，使深度信息基本上可以表示出復雜的語義。同時，你可以在金字塔的頂端實現一個分類器，所有空間信息都被壓縮成一個標識，只有把圖片映射到不同類的信息保留，這就是CNN的總體思想。

上圖的具體流程如下：

• 首先，這是有一張彩色圖片，它包括RGB三原色分量，圖像的長和寬為256*256，三個層面分別對應紅（R）、綠（G）、藍（B）三個圖層，也可以看作像素點的厚度。
• 其次，CNN將圖片的長度和寬度進行壓縮，變成12812816的方塊，壓縮的方法是把圖片的長度和寬度壓小，從而增高厚度。
• 再次，繼續壓縮至646464，直至3232256，此時它變成了一個很厚的長條方塊，我們這里稱之為分類器Classifier。該分類器能夠將我們的分類結果進行預測，MNIST手寫體數據集預測結果是10個數字，比如[0,0,0,1,0,0,0,0,0,0]表示預測的結果是數字3，Classifier在這里就相當于這10個序列。
• 最后，CNN通過不斷壓縮圖片的長度和寬度，增加厚度，最終會變成了一個很厚的分類器，從而進行分類預測。

如果你想實現它，必須還要正確實現很多細節。此時，你已經接觸到了塊和深度的概念，塊（PATCH）有時也叫做核（KERNEL），如下圖所示，你堆棧的每個薄餅都被叫做特征圖（Feature Map），這里把三個特性映射到K個特征圖中，PATCH/KERNEL的功能是從圖片中抽離一小部分進行分析，每次抽離的小部分都會變成一個長度、一個寬度、K個厚度的數列。

另一個你需要知道的概念是——步幅（STRIDE）。它是當你移動濾波器或抽離時平移的像素的數量，每一次跨多少步去抽離圖片中的像素點。

如果步幅STRIDE等于1，表示每跨1個像素點抽離一次，得到的尺寸基本上和輸入相同。

如果步幅STRIDE等于2，表示每次跨2個像素點抽離，意味著變為一半的尺寸。它收集到的信息就會被縮減，圖片的長度和寬度被壓縮了，壓縮合并成更小的一塊立方體。

壓縮完之后再合并成一個立方體，它就是更小的一塊立方體，包含了圖片中的所有信息。

抽離圖片信息的方式稱為PADDING（填充），一般分為兩種：

• VALID PADDING： 抽出來這層比原先那層圖片寬和長裁剪了一點，抽取的內容全部是圖片內的。
• SAME PADDING： 抽離出的那層與之前的圖片一樣的長和寬，抽取的內容部分再圖片外，圖片外的值用0來填充。

研究發現，卷積過程會丟失一些信息，比如現在想跨2步去抽離原始圖片的重要信息，形成長寬更小的圖片，該過程中可能會丟失重要的圖片信息。為了解決這個問題，通過POOLING（持化）可以避免。其方法是：卷積時不再壓縮長寬，盡量保證更多信息，壓縮工作交給POOLING。經過圖片到卷積，持化處理卷積信息，再卷積再持化，將結果傳入兩層全連接神經層，最終通過分類器識別貓或狗。

總結：整個CNN從下往上依次經歷“圖片->卷積->持化->卷積->持化->結果傳入兩層全連接神經層->分類器”的過程，最終實現一個CNN的分類處理。

• IMAGE 圖片
• CONVOLUTION 圖層
• MAX POOLING 更好地保存原圖片的信息
• CONVOLUTION 圖層
• MAX POOLING 更好地保存原圖片的信息
• FULLY CONNECTED 神經網絡隱藏層
• FULLY CONNECTED 神經網絡隱藏層
• CLASSIFIER 分類器

寫到這里，CNN的基本原理講解完畢，希望大家對CNN有一個初步的理解。同時建議大家處理神經網絡時，先用一般的神經網絡去訓練它，如果得到的結果非常好，就沒必要去使用CNN，因為CNN結構比較復雜。

二.TensorFlow實現CNN

接著我們講解如何在TensorFlow代碼中編寫CNN。之前我們用一般的神經網絡來預測MNIST手寫數字時，其準確率能達到87.78%。但該準確率相對目前的技術來說，是非常低的，我們需要編寫CNN來實現，它能提升到96%左右。

第一步，打開Anaconda，然后選擇已經搭建好的“tensorflow”環境，運行Spyder。

第二步，導入擴展包。

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

第三步，下載數據集。

由于MNIST數據集是TensorFlow的示例數據，所以我們只需要下面一行代碼，即可實現數據集的讀取工作。如果數據集不存在它會在線下載，如果數據集已經被下載，它會被直接調用。

# 下載數據集 數字1到10
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

獲取的數據如下圖所示：

第四步，定義compute_accuracy()函數，輸出的準確度result為該函數返回的結果。

mnist分為train data（訓練數據集）和test data（測試數據集），如果整個數據集拿去訓練，會造成人為的誤差，分好成兩個獨立的事件效果會更好。這里定義compute_accuracy()函數計算準確度，代碼如下：

#-------------------------------定義計算準確度函數------------------------------
# 參數：預測xs和預測ys
def compute_accuracy(v_xs, v_ys):
    # 定義全局變量
    global prediction
    # v_xs數據填充到prediction變量中 生成預測值0到1之間的概率
    y_pre = sess.run(prediction, feed_dict={xs:v_xs,keep_prob: 1})
    # 比較預測最大值(y_pre)和真實最大值(v_ys)的差別 如果等于就是預測正確,否則錯誤
    correct_prediction = tf.equal(tf.argmax(y_pre,1), tf.argmax(v_ys,1))
    # 計算正確的數量
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    # 輸出結果為百分比 百分比越高越準確
    result = sess.run(accuracy, feed_dict={xs:v_xs, ys:v_ys, keep_prob:1})
    return result

接著我們需要編寫定義weight、bias、conv2d、max_pool_2x2等函數。

第五步，定義權重和誤差變量。

#---------------------------------定義權重和誤差變量------------------------------
# 輸入shape返回變量定義的參數
def weight_variable(shape):
    # 產生截斷正態分布隨機數
    initial = tf.truncated_normal(shape, stddev=0.1)
    return tf.Variable(initial)
    
def bias_variable(shape):
    # 誤差初始值定義為0.1
    initial = tf.constant(0.1, shape=shape)
    return tf.Variable(initial)

第六步，定義卷積神經網絡層。

#---------------------------------定義卷積神經網絡層------------------------------
# 定義二維CNN x表示輸入值或圖片的值 W表示權重
def conv2d(x, W):
    # 輸入x表示整張圖片的信息 權重W strides表示步長跨度 [1,x_movement,y_movement,1]
    # strides:一個長度為4的列表 第一個和最后一個元素為1 第二個為元素是水平x方向的跨度 第三個元素為垂直y方向跨度
    # padding包括兩種形式 VALID和SAME
    return tf.nn.conv2d(x, W, strides=[1,1,1,1], padding='SAME')

抽離圖片信息的方式成為PADDING，這里使用“SAME PADDING”，抽離出的那層與之前的圖片一樣的長和寬。

第七步，為了防止跨度太大，丟失東西太多，這里添加了POOLING處理，減小跨度。最終得到結果的形狀都一樣，但它能保留更多的圖片信息。

conv2d()函數和max_pool_2x2()比較類似，但是con2d階段保留了原始長度和寬度（strides=[1,1,1,1]），而在pooling階段減小長度和寬度（strides=[1,2,2,1]）。

#------------------------------------定義POOLING---------------------------------
def max_pool_2x2(x):
    # Must have strides[0] = striders[3] = 1
    # x_movement和y_movement隔兩個步長移動一次 從而壓縮整幅圖片的長和寬
    return tf.nn.max_pool(x, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')

第八步，定義placeholder，用于傳入值xs和ys至神經網絡。

# 設置傳入的值xs和ys
xs = tf.placeholder(tf.float32, [None, 784])  #每張圖片28*28=784個點
ys = tf.placeholder(tf.float32, [None, 10])   #每個樣本有10個輸出
# keeping probability
keep_prob = tf.placeholder(tf.float32)
# 形狀修改
# xs包括了所有的圖片樣本 -1表示圖片個數維度暫時不管(后續補充) 
# 28*28表示像素點 1表示信道(該案例圖片黑白為1,彩色為3)
x_image = tf.reshape(xs, [-1,28,28,1])
print(x_image.shape) #[n_samples,28,28,1]

接下來我們就開始講解如何添加神經層。

第九步，增加神經層 conv1 layer。

小方塊的長度和寬度是5，in size為1是圖片的厚度，輸出的高度是32。

h_conv1輸出的大小為282832，因為padding采用“SAME”的形式，W_conv1輸出值為32，故厚度也為32，長度和寬度相同為28。而由于POOLING處理設置的strides步長為2，故其輸出大小也有變化，其結果為141432。核心代碼如下：

#-------------------------------增加神經層 conv1 layer------------------------------
# 定義權重
W_conv1 = weight_variable([5,5,1,32]) #patch 5*5, input size 1, output size 32
# 定義bias
b_conv1 = bias_variable([32]) #32個長度
# 搭建CNN的第一層
# 嵌套一個relu非線性化激勵處理  計算 = x_image輸入*權重 + 誤差
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1) # output size 28*28*32
# POOLING處理
h_pool1 = max_pool_2x2(h_conv1)                          # output size 14*14*32

第十步，通過同樣的方法定義conv2 layer。

W_conv2定義的patch為5*5，傳入大小為32，傳出大小為64，不斷將其變厚，類似于下圖所示。圖片最早的厚度為1（MNIST數據集是黑白圖片，如果是彩色則為3），接著第一層厚度變成32，第三層厚度增長為64。

此時h_conv2的輸出結果為141464，第二層POOLING處理會繼續縮小一半，h_pool2輸出結果為7764，高度不變。

#-------------------------------增加神經層 conv2 layer------------------------------
# 定義權重
W_conv2 = weight_variable([5,5,32,64]) #patch 5*5, input size 32, output size 64
# 定義bias
b_conv2 = bias_variable([64]) #64個長度
# 搭建CNN的第二層
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2) # output size 14*14*64
# POOLING處理
h_pool2 = max_pool_2x2(h_conv2)                          # output size 7*7*64

接下來我們開始定義func1 layer和func2layer。

第十一步，定義func1 layer，即第一個全連接神經層。

定義權重，輸入值為conv2 layer的輸出值7764，輸出值為1024，讓其變得更高更厚。

#-------------------------------增加神經層 func1 layer------------------------------
# 定義權重 輸入值為conv2 layer的輸出值7*7*64 輸出為1024
W_fc1 = weight_variable([7*7*64, 1024])
# 定義bias
b_fc1 = bias_variable([1024]) #1024個長度
# 將h_pool2輸出值7*7*64轉換為一維數據 [n_samples,7,7,64]->>[n_samples,7*7*64]
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64]) #-1表示樣本數
# 乘法
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
# 解決過擬合
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

第十二步，進行最后一層的Layer處理。

#-------------------------------增加神經層 func2 layer------------------------------
# 定義權重 輸入值為1024 輸出為10對應10個數字
W_fc2 = weight_variable([1024, 10])
# 定義bias
b_fc2 = bias_variable([10])
# 預測 使用softmax計算概率
prediction = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

這里簡單總結下神經網絡：

• conv1 layer：經過卷積和POOLING處理，最終輸出141432
• conv2 layer：經過卷積和POOLING處理，最終輸出7764
• func1 layer：平常使用的神經網絡，輸入7764，最終輸出1024
• func2 layer：平常使用的神經網絡，輸入1024，最終輸出10，代表10個數字，即為prediction

第十三步，定義誤差loss和訓練。

這里使用的優化器是AdamOptimizer()函數，其學習效率比GradientDescentOptimizer()更高，學習效率設置為0.0001。

# 預測值與真實值誤差 平均值->求和->ys*log(prediction)
cross_entropyloss = tf.reduce_mean(-tf.reduce_sum(ys * tf.log(prediction), 
                     reduction_indices=[1]))  #loss
# 訓練學習 學習效率設置為0.0001
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropyloss) #減小誤差

第十四步，初始化操作。

# 定義Session
sess = tf.Session()
# 初始化
init = tf.initialize_all_variables()
sess.run(init)

第十五步，神經網絡分類學習。

for i in range(1000):
    # 提取一部分的xs和ys
    batch_xs, batch_ys = mnist.train.next_batch(100) #從下載好的數據集提取100個樣本
    # 訓練
    sess.run(train_step, feed_dict={xs:batch_xs, ys:batch_ys})
    # 每隔50步輸出一次結果
    if i % 50 == 0:
        # 計算準確度
        print(compute_accuracy(
                mnist.test.images, mnist.test.labels))

最終完整代碼如下：

# -*- coding: utf-8 -*-
"""
Created on Fri Dec 20 14:27:01 2019
@author: xiuzhang Eastmount CSDN
"""
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
# 下載數據集 數字1到10
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
#-------------------------------定義計算準確度函數------------------------------
# 參數：預測xs和預測ys
def compute_accuracy(v_xs, v_ys):
    # 定義全局變量
    global prediction
    # v_xs數據填充到prediction變量中 生成預測值0到1之間的概率
    y_pre = sess.run(prediction, feed_dict={xs:v_xs,keep_prob: 1})
    # 比較預測最大值(y_pre)和真實最大值(v_ys)的差別 如果等于就是預測正確,否則錯誤
    correct_prediction = tf.equal(tf.argmax(y_pre,1), tf.argmax(v_ys,1))
    # 計算正確的數量
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    # 輸出結果為百分比 百分比越高越準確
    result = sess.run(accuracy, feed_dict={xs:v_xs, ys:v_ys, keep_prob:1})
    return result
#---------------------------------定義權重和誤差變量------------------------------
# 輸入shape返回變量定義的參數
def weight_variable(shape):
    # 產生截斷正態分布隨機數
    initial = tf.truncated_normal(shape, stddev=0.1)
    return tf.Variable(initial)
    
def bias_variable(shape):
    # 誤差初始值定義為0.1
    initial = tf.constant(0.1, shape=shape)
    return tf.Variable(initial)
#---------------------------------定義卷積神經網絡層------------------------------
# 定義二維CNN x表示輸入值或圖片的值 W表示權重
def conv2d(x, W):
    # 輸入x表示整張圖片的信息 權重W strides表示步長跨度 [1,x_movement,y_movement,1]
    # strides:一個長度為4的列表 第一個和最后一個元素為1 第二個為元素是水平x方向的跨度 第三個元素為垂直y方向跨度
    # padding包括兩種形式 VALID和SAME
    return tf.nn.conv2d(x, W, strides=[1,1,1,1], padding='SAME')
#------------------------------------定義POOLING---------------------------------
def max_pool_2x2(x):
    # Must have strides[0] = striders[3] = 1
    # x_movement和y_movement隔兩個步長移動一次 從而壓縮整幅圖片的長和寬
    return tf.nn.max_pool(x, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')
    
#-----------------------------定義placeholder輸入至神經網絡-------------------------
# 設置傳入的值xs和ys
xs = tf.placeholder(tf.float32, [None, 784])  #每張圖片28*28=784個點
ys = tf.placeholder(tf.float32, [None, 10])   #每個樣本有10個輸出
# keeping probability
keep_prob = tf.placeholder(tf.float32)
# 形狀修改
# xs包括了所有的圖片樣本 -1表示圖片個數維度暫時不管(后續補充) 
# 28*28表示像素點 1表示信道(該案例圖片黑白為1,彩色為3)
x_image = tf.reshape(xs, [-1,28,28,1])
print(x_image.shape) #[n_samples,28,28,1]
    
#-------------------------------增加神經層 conv1 layer------------------------------
# 定義權重
W_conv1 = weight_variable([5,5,1,32]) #patch 5*5, input size 1, output size 32
# 定義bias
b_conv1 = bias_variable([32]) #32個長度
# 搭建CNN的第一層
# 嵌套一個relu非線性化激勵處理  計算 = x_image輸入*權重 + 誤差
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1) # output size 28*28*32
# POOLING處理
h_pool1 = max_pool_2x2(h_conv1)                          # output size 14*14*32
#-------------------------------增加神經層 conv2 layer------------------------------
# 定義權重
W_conv2 = weight_variable([5,5,32,64]) #patch 5*5, input size 32, output size 64
# 定義bias
b_conv2 = bias_variable([64]) #64個長度
# 搭建CNN的第二層
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2) # output size 14*14*64
# POOLING處理
h_pool2 = max_pool_2x2(h_conv2)                          # output size 7*7*64
#-------------------------------增加神經層 func1 layer------------------------------
# 定義權重 輸入值為conv2 layer的輸出值7*7*64 輸出為1024
W_fc1 = weight_variable([7*7*64, 1024])
# 定義bias
b_fc1 = bias_variable([1024]) #1024個長度
# 將h_pool2輸出值7*7*64轉換為一維數據 [n_samples,7,7,64]->>[n_samples,7*7*64]
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64]) #-1表示樣本數
# 乘法
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
# 解決過擬合
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
#-------------------------------增加神經層 func2 layer------------------------------
# 定義權重 輸入值為1024 輸出為10對應10個數字
W_fc2 = weight_variable([1024, 10])
# 定義bias
b_fc2 = bias_variable([10])
# 預測 使用softmax計算概率
prediction = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
#------------------------------定義loss和訓練-------------------------------
# 預測值與真實值誤差 平均值->求和->ys*log(prediction)
cross_entropyloss = tf.reduce_mean(-tf.reduce_sum(ys * tf.log(prediction), 
                     reduction_indices=[1]))  #loss
# 訓練學習 學習效率設置為0.0001
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropyloss) #減小誤差
#-----------------------------------初始化-----------------------------------
# 定義Session
sess = tf.Session()
# 初始化
init = tf.initialize_all_variables()
sess.run(init)
#---------------------------------神經網絡學習---------------------------------
for i in range(1000):
    # 提取一部分的xs和ys
    batch_xs, batch_ys = mnist.train.next_batch(100) #從下載好的數據集提取100個樣本
    # 訓練
    sess.run(train_step, feed_dict={xs:batch_xs, ys:batch_ys, keep_prob:0.5})
    # 每隔50步輸出一次結果
    if i % 50 == 0:
        # 計算準確度
        print(compute_accuracy(
                mnist.test.images, mnist.test.labels))

接著運行代碼，CPU基本上滿負荷運轉。

最終輸出結果如下圖所示，可以看到，最早預測的準確度結果非常低為6.78%，最后提升到了96.92%，其結果高于之前的一般神經網絡的結果87.79%（第六篇博客），由此可見TensorFlow CNN的分類學習效果還不錯。

0.0678
0.8096
0.8839
0.9119
0.9266
0.9361
0.9441
0.9496
0.9505
0.9561
0.9566
0.9616
0.9625
0.9644
0.9648
0.9668
0.9689
0.9698
0.9709
0.9692

三.總結

寫到這里，這篇文章就結束了。本文詳細介紹了卷積神經網絡CNN的基本原理，并通過TensorFlow實現CNN卷積神經網絡，結合MNIST手寫體識別數據集進行分類學習。

最后，希望這篇基礎性文章對您有所幫助，如果文章中存在錯誤或不足之處，還請海涵~作為人工智能的菜鳥，我希望自己能不斷進步并深入，后續將它應用于圖像識別、網絡安全、對抗樣本等領域，指導大家撰寫簡單的學術論文，一起加油！