• 第6章 圖像識別與卷積神經網絡
  • 6.1 圖像識別問題簡介及經典數據集
  • 6.2 卷積神經網絡簡介
  • 6.3 卷積神經網絡常用結構
    • 6.3.1 卷積層
    • 6.3.2 池化層
  • 6.4 經典卷積神經網絡模型
    • 6.4.1 LeNet-5模型
    • 6.4.2 Inception模型
  • 6.5 卷積神經網絡實現遷移學習
    • 6.5.1 遷移學習的介紹

第6章 圖像識別與卷積神經網絡

本章通過利用CNN實現圖像識別的應用來說明如何使用TensorFlow實現卷積神經網絡

6.1 圖像識別問題簡介及經典數據集

1. Cifar

Cifar-10：10種不同種類的60000張圖像，像素大小為32*32的彩色圖像

Cifar-100：20 個大類，大類又細分為 100 個小類別，每類包含 600 張圖像。

• Cifar相比MNIST的最大區別：彩色，且每張圖包含一個種類的實體分類難度更高。
• 無論Cifar還是MNIST，相比真實環境的圖像識別，還有兩個主要的問題：
  
• 現實生活的圖片分辨率遠遠高于32*32，且分辨率不固定；
• 現實生活中物體類別很多，且每張圖像中不會僅僅出現一種物體；

2. ImageNet

• 由斯坦福教授李飛飛（Feifei Li）帶頭整理的數據庫，更加貼近真實生活環境。
• Imagenet數據集有1400多萬幅圖片，涵蓋2萬多個類別；其中有超過百萬的圖片有明確的類別標注和圖像中物體位置的標注，

• 相關信息：
  1）Total number of non-empty synsets: 21841

  2）Total number of images: 14,197,122

  3）Number of images with bounding box annotations: 1,034,908

  4）Number of synsets with SIFT features: 1000

  5）Number of images with SIFT features: 1.2 million
  

6.2 卷積神經網絡簡介

前面所介紹的神經網絡都為全連接神經網絡，本節的卷積神經網絡是非全連接的神經網絡，全連接與卷積神經網絡的結構對比如下：

兩者之間最主要的區別就在于相鄰兩層之間的連接方式

1. 為什么全連接不能很好的處理圖像數據

最大的問題在于全連接層參數太多，使得計算速度減慢，且容易導致過擬合問題。

2. 卷積神經網絡的優勢

卷積神經網絡的前幾層都被組織成一個三維矩陣，可以看出前幾層的每個節點都是和上層中的部分節點相連，卷積神經網絡由以下五部分構成：

1. 輸入層

輸入層是整個神經網絡的輸入，在圖像處理中，輸入一般代表一張圖片的像素矩陣。在上圖中，最左側的三維矩陣就代表一張圖片。三維矩陣的長和寬代表圖像的大小，深度代表了圖像的色彩通道。從輸入層開始，卷積神經網絡通過不同的神經網絡結構將上一層的三維矩陣轉化為下一層的三維矩陣，知道最后的全連接層。

2. 卷積層

卷積層是卷積神經網絡中最重要的部分。卷積層中每一個節點的輸入只是上一層神經網絡的一小塊，這個小塊常用的大小有3?3或5?5，卷積層試圖將神經網絡中的每個小塊進行更加深入的分析從而抽象得到更高層次的特征，一般來說經過卷積層處理過的節點矩陣會變得更深。

3. 池化層

池化層神經網絡不會改變三維矩陣的深度，但是它可以縮小矩陣的大小。池化操作可以認為是將一張分辨率較高的圖片轉化為分辨率較低的圖片。池化層可以進一步縮小最后全連接層中節點的個數，從而達到減少整個神經網絡中參數的目的。

4. 全連接層

經過多輪卷積層和池化層的處理之后，卷積神經網絡的最后一般會是由1-2個全連接層來給出最后的分類結果。經過幾輪卷積層和池化層處理之后，可以認為圖像中的信息已經被抽象成了信息含量更高的特征。 可以將卷積和池化層看成特征提取的過程，提取完成之后，仍然需要使用全連接層來完成分類任務。

5. Softmax層（pooling層）

Softmax層主要用于分類問題，通過softmax可以得到當前樣例屬于不同種類的概率分布情況。

6.3 卷積神經網絡常用結構

6.3.1 卷積層

TensorFlow文檔中將下圖的部分被稱為“過濾器”或“內核”，過濾器可以將當前層神經網絡上的一個子節點矩陣轉化為下一層神經網絡上的一個單位節點矩陣（長和寬都為1，但深度不限的節點矩陣）。

• 過濾器：

• 常用的過濾器的大小為 3*3 或 5*5 的，過濾器處理的矩陣深度和當前車網絡節點矩陣的深度一致。
• 尺寸：過濾器輸入節點矩陣的大小
• 深度：輸出節點矩陣的深度
• 上圖中，左側小矩陣的尺寸為過濾器的尺寸，右側單位矩陣的深度為過濾器的深度。
• 前向傳播過程：通過左側小矩陣的節點計算出右側單位矩陣中節點的過程

• 過濾器的前向傳播
  卷積層結構的前向傳播過程就是通過將一個過濾器從神經網絡當前層的左上角移動到右下角，并且在移動過程中計算每一個對應的單位矩陣得到的。
  
  傳播過程：左上角→→右上角→→左下角→→右下角

• 全零填充：為了避免尺寸變化，可以使用“全零填充”，可以使得前向傳播后兩矩陣大小不變。
  

• 設置不同的步長：也可以調整卷積后矩陣的大小
  

• 參數共享：每一個卷積層中使用的濾波器中的參數都是一樣的（很重要的性質）

• 使得圖像上的內容不受位置的影響，因為一幅圖上的濾波器是相同的，無論“1”出現在圖中的哪個位置，濾波的結果都是一樣的。

• 很大程度上減少神經網絡的參數

• 示例：全零填充、步長為2的卷積層前向傳播過程

左上角的計算方式：

ReLU(0×1+0×(?1)+0×0+1×2+1)=ReLU(3)=3ReLU(0×1+0×(?1)+0×0+1×2+1)=ReLU(3)=3

• TensorFlow實現卷積神經網絡

1.創建濾波器的權值和偏置

filter_weight=tf.get_variable('weights',[5,5,3,16],initializer=tf.truncated_initializer(stddev=0.1))# t通過tf.get_variable的方式創建濾波器的權值和偏置# 聲明一個4維矩陣，前面兩個是濾波器尺寸、第三個表示當前層深度、第四個表示過濾器的深度（也就是卷積核個數） biases=tf.get_variable('biases',[16],initializer=tf.constant_initializer(0.1))# 當前層矩陣上不同位置的偏置項也是共享的，所以偏置項個數=下一層深度，本例為16

2.實現卷積層的前向傳播

conv=tf.nn.conv2d(input,filter_weight,strides=[1,1,1,1],padding='SAME')# tf.nn.conv2提供了一個非常方便的函數來實現卷積層的前向傳播# 第一個輸入：當前層節點矩陣# （比如輸入層，input[0,:,:,:]表示輸入第一張圖像，input[1,:,:,:]表示輸入第二張圖像# 第二個參數：卷積層的權重# 第三個參數不同維度上的步長（第一維和最后一維要求一定是1，因為步長只對矩陣的長和寬有效）# 第四個參數：填充的方法，可選'SAME'（全0填充）/'VALID'（不填充）

3.加上偏置項

bias=tf.nn.bias_add(conv,biases)# tf.nn.bias_add提供了一個方便的函數給每個節點加上偏置項# 不直接使用加法：因為矩陣上不同位置上的節點都需要加上相同的偏置項

4.激活

actived_conv=tf.nn.relu(bias)# 將計算結果通過ReLU函數激活

6.3.2 池化層

• 作用：

• 減少參數
• 防止過擬合
• 獲得平移不變性

• 常用池化類型：

• 最大池化
• 平均池化

• 池化層的作用范圍：

• 只影響一個深度上的節點
• 在長、寬、深這三個維度都要進行移動

• TensorFlow實現最大池化層的前向傳播

pool = tf.nn.max_pool(actived_conv,ksize[1,3,3,1],strides=[1,2,2,1],padding='SAME')# 第一個參數：當前層節點矩陣# 第二個參數：過濾器尺寸# 給出的是一個長度為4的一位數組，但數組的首位和末位必須為1# 意味著池化層的過濾器是不可以跨過不同樣例或節點矩陣深度的# 第三個參數：步長，第一維和最后一維必須為1，即池化層不能減少節點矩陣的深度或者輸入樣例的個數# 第四個參數：填充方法，'SAME'表示全0填充，'VALID'表示不填充

• TensorFlow實現平均池化層的前向傳播

pool = tf.nn.avg_pool(actived_conv,ksize[1,3,3,1],strides=[1,2,2,1],padding='SAME')# 第一個參數：當前層節點矩陣# 第二個參數：過濾器尺寸# 給出的是一個長度為4的一維數組，但數組的首位和末位必須為1# 意味著池化層的過濾器是不可以跨過不同樣例或節點矩陣深度的# 第三個參數：步長，第一維和最后一維必須為1，即池化層不能減少節點矩陣的深度或者輸入樣例的個數# 第四個參數：填充方法，'SAME'表示全0填充，'VALID'表示不填充

卷積層、池化層樣例

# 《TensorFlow實戰Google深度學習框架》06 圖像識別與卷積神經網絡 # win10 Tensorflow1.0.1 python3.5.3 # CUDA v8.0 cudnn-8.0-windows10-x64-v5.1 # filename:ts06.01.py # 卷積層、池化層樣例import tensorflow as tf import numpy as np# 1. 輸入矩陣 M = np.array([[[1],[-1],[0]],[[-1],[2],[1]],[[0],[2],[-2]]]) print("Matrix shape is: ",M.shape) # Matrix shape is: (3, 3, 1)# 2. 定義卷積過濾器, 深度為1 filter_weight = tf.get_variable('weights', [2, 2, 1, 1], initializer = tf.constant_initializer([[1, -1],[0, 2]])) biases = tf.get_variable('biases', [1], initializer = tf.constant_initializer(1))# 3. 調整輸入的格式符合TensorFlow的要求 M = np.asarray(M, dtype='float32') M = M.reshape(1, 3, 3, 1)# 4. 計算矩陣通過卷積層過濾器和池化層過濾器計算后的結果 x = tf.placeholder('float32', [1, None, None, 1]) conv = tf.nn.conv2d(x, filter_weight, strides=[1, 2, 2, 1], padding='SAME') bias = tf.nn.bias_add(conv, biases) pool = tf.nn.avg_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME') with tf.Session() as sess:tf.global_variables_initializer().run()convoluted_M = sess.run(bias, feed_dict={x: M})pooled_M = sess.run(pool, feed_dict={x: M})print("convoluted_M: \n", convoluted_M)print("pooled_M: \n", pooled_M)

輸出：

Matrix shape is: (3, 3, 1) convoluted_M: [[[[ 7.],[ 1.]][[-1.],[-1.]]]]pooled_M: [[[[ 0.25],[ 0.5 ]][[ 1. ],[-2. ]]]]

6.4 經典卷積神經網絡模型

6.4.1 LeNet-5模型

Yann LeCun 教授于1998年提出，是第一個成功用于數字識別的卷積神經網絡，在mnist數據集上，可以達到99.2%的效果，共有7層，如下圖所示。

輸入原始圖像的大小是32×32

1. 卷積層

輸入：原始圖像的像素（32*32*1）

過濾器：尺寸為5*5，深度為6，不使用全0填充，步長為1

輸出：尺寸為 32-5+1=28，深度為6

參數個數：5*5*1*6+6=156，

下一層節點矩陣的節點：28*28*6=4704，每個節點和5*5=25 個當前層節點相連

本層卷積層共有連接個數：4704*（25+1）=122304

2. 池化層

輸入：第一層的輸出，是一個28*28*6的節點矩陣

過濾器：大小為2*2，長、寬、步長都為2

輸出：14*14*6

3. 卷積層

輸入：14*14*6

過濾器：大小為5*5，深度為16，不使用0填充，步長為1

輸出：10*10*16，按標準的卷積層，本層應該有5*5*6*16+16=2416個參數

共有：10*10*16*（25+1）=41600個連接

4. 池化層

輸入：10*10*16

過濾器：大小為2*2，步長為2

輸出：矩陣大小為5*5*16

5. 全連接層

輸入：5*5*16，本來論文中稱本層為卷積層，但是因為濾波器大小為5*5，所以和全連接層沒有區別，之后就將其看成全連接層。如果將矩陣5*5*16拉成一個向量，則和第四章的無區別

輸出：節點個數為120

總共參數：5*5*16*120+120個參數。

6. 全連接層

輸入：節點個數為120個

輸出：節點個數為84個

總共參數：120*84+84=10164個

7. 全連接層

輸入：84個節點

輸出：10個節點

總共參數：84*10+10=850個

代碼示例：

• LeNet_inference.py

# 《TensorFlow實戰Google深度學習框架》06 圖像識別與卷積神經網絡 # win10 Tensorflow1.0.1 python3.5.3 # CUDA v8.0 cudnn-8.0-windows10-x64-v5.1 # filename:LeNet5_infernece.py # LeNet5前向傳播import tensorflow as tf# 1. 設定神經網絡的參數 INPUT_NODE = 784 OUTPUT_NODE = 10IMAGE_SIZE = 28 NUM_CHANNELS = 1 NUM_LABELS = 10CONV1_DEEP = 32 CONV1_SIZE = 5CONV2_DEEP = 64 CONV2_SIZE = 5FC_SIZE = 512# 2. 定義前向傳播的過程 def inference(input_tensor, train, regularizer):with tf.variable_scope('layer1-conv1'):conv1_weights = tf.get_variable("weight", [CONV1_SIZE, CONV1_SIZE, NUM_CHANNELS, CONV1_DEEP],initializer=tf.truncated_normal_initializer(stddev=0.1))conv1_biases = tf.get_variable("bias", [CONV1_DEEP],initializer=tf.constant_initializer(0.0))conv1 = tf.nn.conv2d(input_tensor, conv1_weights, strides=[1, 1, 1, 1],padding='SAME')relu1 = tf.nn.relu(tf.nn.bias_add(conv1, conv1_biases))with tf.name_scope("layer2-pool1"):pool1 = tf.nn.max_pool(relu1, ksize = [1,2,2,1],strides=[1,2,2,1],padding="SAME")with tf.variable_scope("layer3-conv2"):conv2_weights = tf.get_variable("weight", [CONV2_SIZE, CONV2_SIZE, CONV1_DEEP, CONV2_DEEP],initializer=tf.truncated_normal_initializer(stddev=0.1))conv2_biases = tf.get_variable("bias", [CONV2_DEEP],initializer=tf.constant_initializer(0.0))conv2 = tf.nn.conv2d(pool1, conv2_weights, strides=[1, 1, 1, 1], padding='SAME')relu2 = tf.nn.relu(tf.nn.bias_add(conv2, conv2_biases))with tf.name_scope("layer4-pool2"):pool2 = tf.nn.max_pool(relu2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1],padding='SAME')pool_shape = pool2.get_shape().as_list()nodes = pool_shape[1] * pool_shape[2] * pool_shape[3]reshaped = tf.reshape(pool2, [pool_shape[0], nodes])with tf.variable_scope('layer5-fc1'):fc1_weights = tf.get_variable("weight", [nodes, FC_SIZE],initializer=tf.truncated_normal_initializer(stddev=0.1))if regularizer != None: tf.add_to_collection('losses', regularizer(fc1_weights))fc1_biases = tf.get_variable("bias", [FC_SIZE], initializer=tf.constant_initializer(0.1))fc1 = tf.nn.relu(tf.matmul(reshaped, fc1_weights) + fc1_biases)if train: fc1 = tf.nn.dropout(fc1, 0.5)with tf.variable_scope('layer6-fc2'):fc2_weights = tf.get_variable("weight", [FC_SIZE, NUM_LABELS],initializer=tf.truncated_normal_initializer(stddev=0.1))if regularizer != None: tf.add_to_collection('losses', regularizer(fc2_weights))fc2_biases = tf.get_variable("bias", [NUM_LABELS],initializer=tf.constant_initializer(0.1))logit = tf.matmul(fc1, fc2_weights) + fc2_biasesreturn logit

• LeNet_train.py

# 《TensorFlow實戰Google深度學習框架》06 圖像識別與卷積神經網絡 # win10 Tensorflow1.0.1 python3.5.3 # CUDA v8.0 cudnn-8.0-windows10-x64-v5.1 # filename:LeNet5_train.py # LeNet5訓練import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data import LeNet_inference import os import numpy as np# 1. 定義神經網絡相關的參數 BATCH_SIZE = 100 LEARNING_RATE_BASE = 0.01 LEARNING_RATE_DECAY = 0.99 REGULARIZATION_RATE = 0.0001 TRAINING_STEPS = 55000 MOVING_AVERAGE_DECAY = 0.99 MODEL_SAVE_PATH = "LeNet5_model/" # 在當前目錄下存在LeNet5_model子文件夾 MODEL_NAME = "LeNet5_model"# 2. 定義訓練過程 def train(mnist):# 定義輸出為4維矩陣的placeholderx = tf.placeholder(tf.float32, [BATCH_SIZE,LeNet_inference.IMAGE_SIZE,LeNet_inference.IMAGE_SIZE,LeNet_inference.NUM_CHANNELS],name='x-input')y_ = tf.placeholder(tf.float32, [None, LeNet_inference.OUTPUT_NODE], name='y-input')regularizer = tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)y = LeNet_inference.inference(x, True, regularizer)global_step = tf.Variable(0, trainable=False)# 定義損失函數、學習率、滑動平均操作以及訓練過程。variable_averages = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)variables_averages_op = variable_averages.apply(tf.trainable_variables())cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))cross_entropy_mean = tf.reduce_mean(cross_entropy)loss = cross_entropy_mean + tf.add_n(tf.get_collection('losses'))learning_rate = tf.train.exponential_decay(LEARNING_RATE_BASE,global_step,mnist.train.num_examples / BATCH_SIZE, LEARNING_RATE_DECAY,staircase=True)train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)with tf.control_dependencies([train_step, variables_averages_op]):train_op = tf.no_op(name='train')# 初始化TensorFlow持久化類。saver = tf.train.Saver()with tf.Session() as sess:tf.global_variables_initializer().run()for i in range(TRAINING_STEPS):xs, ys = mnist.train.next_batch(BATCH_SIZE)reshaped_xs = np.reshape(xs, (BATCH_SIZE,LeNet_inference.IMAGE_SIZE,LeNet_inference.IMAGE_SIZE,LeNet_inference.NUM_CHANNELS))_, loss_value, step = sess.run([train_op, loss, global_step], feed_dict={x: reshaped_xs, y_: ys})if i % 1000 == 0:print("After %d training step(s), loss on training batch is %g." % (step, loss_value))saver.save(sess, os.path.join(MODEL_SAVE_PATH, MODEL_NAME), global_step=global_step)# 3. 主程序入口 def main(argv=None):mnist = input_data.read_data_sets("MNIST_data", one_hot=True)train(mnist)if __name__ == '__main__':tf.app.run()

輸出：

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.gzAfter 1 training step(s), loss on training batch is 6.10953. After 1001 training step(s), loss on training batch is 0.801586. After 2001 training step(s), loss on training batch is 0.829287. After 3001 training step(s), loss on training batch is 0.655056. After 4001 training step(s), loss on training batch is 0.698159. After 5001 training step(s), loss on training batch is 0.744295. After 6001 training step(s), loss on training batch is 0.657604. After 7001 training step(s), loss on training batch is 0.697003. After 8001 training step(s), loss on training batch is 0.685206. After 9001 training step(s), loss on training batch is 0.651352. After 10001 training step(s), loss on training batch is 0.729663. After 11001 training step(s), loss on training batch is 0.666927. After 12001 training step(s), loss on training batch is 0.65114. After 13001 training step(s), loss on training batch is 0.648548. ...

• LeNet_eval.py（測試該網絡在mnist的正確率，達到99.4%，巨幅高于第五章的98.4%）

# 《TensorFlow實戰Google深度學習框架》06 圖像識別與卷積神經網絡 # win10 Tensorflow1.0.1 python3.5.3 # CUDA v8.0 cudnn-8.0-windows10-x64-v5.1 # filename:LeNet5_eval.py # 測試import time import math import tensorflow as tf import numpy as np from tensorflow.examples.tutorials.mnist import input_data import LeNet5_infernece import LeNet5_traindef evaluate(mnist):with tf.Graph().as_default() as g:# 定義輸出為4維矩陣的placeholderx = tf.placeholder(tf.float32, [mnist.test.num_examples,#LeNet5_train.BATCH_SIZE,LeNet5_infernece.IMAGE_SIZE,LeNet5_infernece.IMAGE_SIZE,LeNet5_infernece.NUM_CHANNELS],name='x-input')y_ = tf.placeholder(tf.float32, [None, LeNet5_infernece.OUTPUT_NODE], name='y-input')validate_feed = {x: mnist.test.images, y_: mnist.test.labels}global_step = tf.Variable(0, trainable=False)regularizer = tf.contrib.layers.l2_regularizer(LeNet5_train.REGULARIZATION_RATE)y = LeNet5_infernece.inference(x, False, regularizer)correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))variable_averages = tf.train.ExponentialMovingAverage(LeNet5_train.MOVING_AVERAGE_DECAY)variables_to_restore = variable_averages.variables_to_restore()saver = tf.train.Saver(variables_to_restore)#n = math.ceil(mnist.test.num_examples / LeNet5_train.BATCH_SIZE)n = math.ceil(mnist.test.num_examples / mnist.test.num_examples)for i in range(n):with tf.Session() as sess:ckpt = tf.train.get_checkpoint_state(LeNet5_train.MODEL_SAVE_PATH)if ckpt and ckpt.model_checkpoint_path:saver.restore(sess, ckpt.model_checkpoint_path)global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]xs, ys = mnist.test.next_batch(mnist.test.num_examples)#xs, ys = mnist.test.next_batch(LeNet5_train.BATCH_SIZE)reshaped_xs = np.reshape(xs, (mnist.test.num_examples,#LeNet5_train.BATCH_SIZE,LeNet5_infernece.IMAGE_SIZE,LeNet5_infernece.IMAGE_SIZE,LeNet5_infernece.NUM_CHANNELS))accuracy_score = sess.run(accuracy, feed_dict={x:reshaped_xs, y_:ys})print("After %s training step(s), test accuracy = %g" % (global_step, accuracy_score))else:print('No checkpoint file found')return# 主程序 def main(argv=None):mnist = input_data.read_data_sets("../../../datasets/MNIST_data", one_hot=True)evaluate(mnist)if __name__ == '__main__':tf.app.run()

LeNet-5模型的缺點
不能很好的解決所有問題，比如類似ImageNet的復雜數據集

如何設計卷積神經網絡架構
該正則表達公式總結了經典的用于圖像分類問題的卷積神經網絡架構

輸入層→→（卷積層+→→池化層？）+→→全連接層+
其中：

+表示一層或多層

“池化層？”表示沒有或一層池化層，因為有的網絡是通過直接調整卷積層步長來完成的參數減少

多倫卷積核池化之后，輸出層之前會有1~2個全連接層

LeNet-5的正則表達：

輸入層→→卷積層→→池化層→→卷積層→→池化層→→全連接層→→全連接層→→輸出層

從VGGNet觀察正則表達式的特點：

convX-Y：濾波器的邊長為X，深度為Y

VGGNet中的濾波器的邊長基本都為3或1

LeNet-5中使用了大小為5*5的濾波器，一般都不會超過5，但也有的設置為7*7，甚至11*11的

在濾波器的深度選擇上，大部分都采用逐層遞增的方式，VGG中，每經過一個池化層，濾波器的深度*2，

卷積層的步長一般為2，但也有例外（使用2或3）

池化層配置相對簡單，用的最多的是最大池化層，邊長一般為2或3，步長一般為2或3

6.4.2 Inception模型

已知濾波器的大小可選，但是沒有先驗知識幫助我們去選擇其大小，所以Inception模型將不同尺寸的濾波器的濾波結果通過并聯的方式結合在一起，即將得到的矩陣拼接起來。

Inception模型會使用不同尺寸的濾波器處理矩陣，使用全0填充和步長為1的方法獲得的特征圖譜大小是相同的，不會影響矩陣的拼接。

Inception-v3模型共有46層，由11個Inception模塊構成，上圖中方框標注的就是一個模塊，Inception-v3模型有96個卷積層，直接使用上文的TensorFlow模型會非常冗長，所以此處介紹TensorFlow-Slim工具來更加簡潔的實現同樣結構的神經網絡代碼量。

1.直接使用TensorFlow原始API實現卷積層

with tf.variable_scope(scope_name):weights=tf.get_variable("weight",...)biases=tf.get_variable("bias",...)conv=tf.nn.conv2d(...)relu=tf.nn.relu(tf.nn.bias_add(conv,biases))

2.使用TensorFlow-Slim實現卷積層

tf.contrib.slim.conv2d (inputs,num_outputs,#[卷積核個數]kernel_size,#[高度，寬度]stride=1,#步長padding='SAME',#VALID

存在于tensorflow.contrib的庫中，導入方法：import tensorflow.contrib.slim as slim

net=slim.conv2d(input,32,[3,3]) # 可以在一行中實現一個卷積層的前向傳播算法 # 第一個參數：輸入節點矩陣 # 第二個參數：當前卷積層過濾器的深度 # 第三個參數：過濾器的尺寸 # 可選步長、填充、激活函數、變量命名空間等

6.5 卷積神經網絡實現遷移學習

6.5.1 遷移學習的介紹

從上表可以看出，隨著模型層數及復雜度的增加，模型在ImageNet上的錯誤率也隨之降低，然而訓練神經網絡需要非常多的標注數據，ImageNet數據集中有120萬標注圖像，所以才能使得152層的ResNet模型達到分類的96.5%的正確率，實際中很難收集到如此多的標記數據，即使收集也會花費很多的人力物力，并且海量的訓練數據使得復雜的卷積神經網絡的訓練需要幾天甚至幾周，為了解決標注數據和訓練時間的問題，提出了遷移學習。

遷移學習：將一個問題上訓練好的模型通過簡單的調整使其適用于一個新的問題。比如可以保留訓練好的Inception-v3模型中所有卷積層的參數，只是替換最后一層全連接層，可以解決一個新的圖像分類問題。

瓶頸層：在最后這一層全連接層之前的網絡層稱之為瓶頸層。

• 將新的圖像通過訓練好的卷積神經網絡直到瓶頸層的過程可以看成是對圖像進行特征提取的過程。
• 可以認為瓶頸層的輸出節點向量可以被作為任何圖像的一個更加精簡且表達能力更強的特征向量，于是可以用該訓練好的神經網絡在新的數據集上完成對圖像特征的提取。
• 再將提取到的特征作為輸入來訓練一個新的單層全連接神經網絡處理新的分類問題

遷移學習相比重新訓練的優缺點：

• 缺點：效果不如完全重新訓練
• 優點：需要的訓練時間和訓練樣本數要遠遠小于訓練完整的模型

代碼實現：

# 《TensorFlow實戰Google深度學習框架》06 圖像識別與卷積神經網絡 # win10 Tensorflow1.0.1 python3.5.3 # CUDA v8.0 cudnn-8.0-windows10-x64-v5.1 # filename:ts06.03.py # 遷移學習# 以下實驗需要如下資源 # 源碼及資源位置：git clone https://github.com/caicloud/tensorflow-tutorial.git # 需要tensorflow-tutorial.git庫中的flower_photos和inception_dec_2015 # tensorflow-tutorial\Deep_Learning_with_TensorFlow\datasets\flower_photos # tensorflow-tutorial\Deep_Learning_with_TensorFlow\datasets\inception_dec_2015import glob import os.path import random import numpy as np import tensorflow as tf from tensorflow.python.platform import gfile# 1. 模型和樣本路徑的設置 # inception-v3模型瓶頸層的節點數 BOTTLENECK_TENSOR_SIZE = 2048# inception-v3模型中代表瓶頸層結果的張量名稱，谷歌提供的inception-v3模型中，這個張量名稱就是'pool_3/_reshape:0' # 訓練過程中，可以利用tensor.name來獲取張量的名稱 BOTTLENECK_TENSOR_NAME = 'pool_3/_reshape:0'# 圖像輸入張量所對應的名稱 JPEG_DATA_TENSOR_NAME = 'DecodeJpeg/contents:0'# 保存的模型文件目錄 MODEL_DIR = '../../datasets/inception_dec_2015' # 下載的谷歌訓練好的inception-v3模型文件名 MODEL_FILE= 'tensorflow_inception_graph.pb'# 因為一個訓練數據會被使用多次，所以可以將原始圖像通過inception-v3模型計算得到的特征向量保存在文件中， # 以免重復計算，下面是這些文件的存放地址。 CACHE_DIR = '../../datasets/bottleneck'# 圖片數據文件夾 # 該文件夾中每一個子文件夾代表一個需要區分的類別，每個子文件夾中存放了對應類別的圖片 INPUT_DATA = '../../datasets/flower_photos'# 驗證集百分比 VALIDATION_PERCENTAGE = 10 # 測試集百分比 TEST_PERCENTAGE = 10# 2. 神經網絡參數的設置 LEARNING_RATE = 0.01 STEPS = 4000 BATCH = 100# 3. 把樣本中所有的圖片列表并按訓練、驗證、測試數據分開 # testing_percentage：測試數據集的大小 # validation_percentage：驗證數據集的大小 def create_image_lists(testing_percentage, validation_percentage):# 定義一個result字典，key存儲類別名稱， 與key對應的value也是一個字典，存儲所有該類的圖片名稱result = {}# 獲取當前目錄下所有的子目錄sub_dirs = [x[0] for x in os.walk(INPUT_DATA)]is_root_dir = Truefor sub_dir in sub_dirs:if is_root_dir:is_root_dir = Falsecontinueextensions = ['jpg', 'jpeg', 'JPG', 'JPEG']file_list = []dir_name = os.path.basename(sub_dir)for extension in extensions:file_glob = os.path.join(INPUT_DATA, dir_name, '*.' + extension)file_list.extend(glob.glob(file_glob))if not file_list: continuelabel_name = dir_name.lower()# 初始化training_images = []testing_images = []validation_images = []for file_name in file_list:base_name = os.path.basename(file_name)# 隨機劃分數據chance = np.random.randint(100)if chance < validation_percentage:validation_images.append(base_name)elif chance < (testing_percentage + validation_percentage):testing_images.append(base_name)else:training_images.append(base_name)result[label_name] = {'dir': dir_name,'training': training_images,'testing': testing_images,'validation': validation_images,}return result# 4. 定義函數通過類別名稱、所屬數據集和圖片編號獲取一張圖片的地址 def get_image_path(image_lists, image_dir, label_name, index, category):label_lists = image_lists[label_name]category_list = label_lists[category]mod_index = index % len(category_list)base_name = category_list[mod_index]sub_dir = label_lists['dir']full_path = os.path.join(image_dir, sub_dir, base_name)return full_path# 5. 定義函數獲取Inception-v3模型處理之后的特征向量的文件地址 def get_bottleneck_path(image_lists, label_name, index, category):return get_image_path(image_lists, CACHE_DIR, label_name, index, category) + '.txt'# 6. 定義函數使用加載的訓練好的Inception-v3模型處理一張圖片，得到這個圖片的特征向量 # 該過程實際上就是將當前圖片作為輸入九三瓶頸張量的值，這個瓶頸張量的值就是該圖像的新的特征向量 def run_bottleneck_on_image(sess, image_data, image_data_tensor, bottleneck_tensor):bottleneck_values = sess.run(bottleneck_tensor, {image_data_tensor: image_data})# 將四維數組壓縮為一個特征向量bottleneck_values = np.squeeze(bottleneck_values)return bottleneck_values# 7. 定義函數會先試圖尋找已經計算且保存下來的特征向量，如果找不到則先計算這個特征向量，然后保存到文件 def get_or_create_bottleneck(sess, image_lists, label_name, index, category, jpeg_data_tensor, bottleneck_tensor):label_lists = image_lists[label_name]sub_dir = label_lists['dir']sub_dir_path = os.path.join(CACHE_DIR, sub_dir)if not os.path.exists(sub_dir_path): os.makedirs(sub_dir_path)bottleneck_path = get_bottleneck_path(image_lists, label_name, index, category)if not os.path.exists(bottleneck_path):image_path = get_image_path(image_lists, INPUT_DATA, label_name, index, category)image_data = gfile.FastGFile(image_path, 'rb').read()bottleneck_values = run_bottleneck_on_image(sess, image_data, jpeg_data_tensor, bottleneck_tensor)bottleneck_string = ','.join(str(x) for x in bottleneck_values)with open(bottleneck_path, 'w') as bottleneck_file:bottleneck_file.write(bottleneck_string)else:with open(bottleneck_path, 'r') as bottleneck_file:bottleneck_string = bottleneck_file.read()bottleneck_values = [float(x) for x in bottleneck_string.split(',')]return bottleneck_values# 8. 這個函數隨機獲取一個batch的圖片作為訓練數據 def get_random_cached_bottlenecks(sess, n_classes, image_lists, how_many, category, jpeg_data_tensor, bottleneck_tensor):bottlenecks = []ground_truths = []for _ in range(how_many):label_index = random.randrange(n_classes)label_name = list(image_lists.keys())[label_index]image_index = random.randrange(65536)bottleneck = get_or_create_bottleneck(sess, image_lists, label_name, image_index, category, jpeg_data_tensor, bottleneck_tensor)ground_truth = np.zeros(n_classes, dtype=np.float32)ground_truth[label_index] = 1.0bottlenecks.append(bottleneck)ground_truths.append(ground_truth)return bottlenecks, ground_truths# 9. 這個函數獲取全部的測試數據，并計算正確率 def get_test_bottlenecks(sess, image_lists, n_classes, jpeg_data_tensor, bottleneck_tensor):bottlenecks = []ground_truths = []label_name_list = list(image_lists.keys())for label_index, label_name in enumerate(label_name_list):category = 'testing'for index, unused_base_name in enumerate(image_lists[label_name][category]):bottleneck = get_or_create_bottleneck(sess, image_lists, label_name, index, category,jpeg_data_tensor, bottleneck_tensor)ground_truth = np.zeros(n_classes, dtype=np.float32)ground_truth[label_index] = 1.0bottlenecks.append(bottleneck)ground_truths.append(ground_truth)return bottlenecks, ground_truths# 10. 定義主函數 def main():image_lists = create_image_lists(TEST_PERCENTAGE, VALIDATION_PERCENTAGE)n_classes = len(image_lists.keys())# 讀取已經訓練好的Inception-v3模型。with gfile.FastGFile(os.path.join(MODEL_DIR, MODEL_FILE), 'rb') as f:graph_def = tf.GraphDef()graph_def.ParseFromString(f.read())bottleneck_tensor, jpeg_data_tensor = tf.import_graph_def(graph_def, return_elements=[BOTTLENECK_TENSOR_NAME, JPEG_DATA_TENSOR_NAME])# 定義新的神經網絡輸入bottleneck_input = tf.placeholder(tf.float32, [None, BOTTLENECK_TENSOR_SIZE], name='BottleneckInputPlaceholder')ground_truth_input = tf.placeholder(tf.float32, [None, n_classes], name='GroundTruthInput')# 定義一層全鏈接層with tf.name_scope('final_training_ops'):weights = tf.Variable(tf.truncated_normal([BOTTLENECK_TENSOR_SIZE, n_classes], stddev=0.001))biases = tf.Variable(tf.zeros([n_classes]))logits = tf.matmul(bottleneck_input, weights) + biasesfinal_tensor = tf.nn.softmax(logits)# 定義交叉熵損失函數。cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=ground_truth_input)cross_entropy_mean = tf.reduce_mean(cross_entropy)train_step = tf.train.GradientDescentOptimizer(LEARNING_RATE).minimize(cross_entropy_mean)# 計算正確率。with tf.name_scope('evaluation'):correct_prediction = tf.equal(tf.argmax(final_tensor, 1), tf.argmax(ground_truth_input, 1))evaluation_step = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))with tf.Session() as sess:init = tf.global_variables_initializer()sess.run(init)# 訓練過程。for i in range(STEPS):train_bottlenecks, train_ground_truth = get_random_cached_bottlenecks(sess, n_classes, image_lists, BATCH, 'training', jpeg_data_tensor, bottleneck_tensor)sess.run(train_step,feed_dict={bottleneck_input: train_bottlenecks, ground_truth_input: train_ground_truth})if i % 100 == 0 or i + 1 == STEPS:validation_bottlenecks, validation_ground_truth = get_random_cached_bottlenecks(sess, n_classes, image_lists, BATCH, 'validation', jpeg_data_tensor, bottleneck_tensor)validation_accuracy = sess.run(evaluation_step, feed_dict={bottleneck_input: validation_bottlenecks, ground_truth_input: validation_ground_truth})print('Step %d: Validation accuracy on random sampled %d examples = %.1f%%' %(i, BATCH, validation_accuracy * 100))# 在最后的測試數據上測試正確率。test_bottlenecks, test_ground_truth = get_test_bottlenecks(sess, image_lists, n_classes, jpeg_data_tensor, bottleneck_tensor)test_accuracy = sess.run(evaluation_step, feed_dict={bottleneck_input: test_bottlenecks, ground_truth_input: test_ground_truth})print('Final test accuracy = %.1f%%' % (test_accuracy * 100))if __name__ == '__main__':tf.app.run()

總結

以上是生活随笔為你收集整理的TensorFlow：实战Google深度学习框架（五）图像识别与卷积神经网络的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。