文章目錄

• 一、圖像識別＆經典數據集
• • 1、Cifar數據集
  • 2、 ImageNet
• 二、CNN
• 三、卷積神經網絡常用結構
• • 1、卷積層
  • 2、池化層
  • • （２）實現
• 四、經典CNN模型
• • 1、LeNet-5 模型（1998）
  • • （１）模型
    • （２）代碼示例
  • 2、CNN模型正則表達
  • 3、Inception-v3模型
  • • （１）Inception結構
    • （２）Inception模塊實現
• 五、ＣＮＮ遷移學習
• • 1、遷移學習介紹
  • 2、TF實現遷移學習
  • • （１）獲取數據集
    • （２）數據預處理
    • （３）獲取預訓練模型
    • （４）遷移學習代碼實現

一、圖像識別＆經典數據集

圖像識別：希望借助計算機程序來處理、分析和理解圖片中的內容，使得計算機可以從圖片中自動識別各種不同模式的目標和對象。

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萬多個類別；其中有超過百萬的圖片有明確的類別標注和圖像中物體位置（bounding box）的標注，一張圖片中可能出現多個同義詞集所代表的實體。
• ILSVRC2012數據集：1000 個類別的 120 萬張圖片，其中
  每張圖片屬于且只屬于一個類別。

top-N 正確率：圖像識別算法給出前 N 個答案中有一個是正確的概率。其中 N 的取值一般為 3 或 5

二、CNN

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

Q1：為什么全連接不能很好的處理圖像數據?

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

Q2：卷積神經網絡的優勢

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

Q3：卷積神經網絡由以下五部分構成：

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

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

池化層
池化層神經網絡不會改變三維矩陣的深度，但是它可以縮小矩陣的大小。池化層可以進一步縮小最后全連接層中節點的個數，從而達到減少整個神經網絡中參數的目的。

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

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

三、卷積神經網絡常用結構

1、卷積層

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

過濾器：

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

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

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

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

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

• 使得圖像上的內容不受位置的影響，因為一幅圖上的濾波器是相同的，無論“1”出現在圖中的哪個位置，濾波的結果都是一樣的。
• 很大程度上減少神經網絡的參數
• 卷積層的參數個數和圖片的大小無關，它只和過濾器的尺寸、深度以及當前層節點矩陣的深度有關。
  • 參數個數：過濾器的長×過濾器的寬×當前層節點矩陣的深度×過濾器的深度（輸出節點矩陣的深度）+偏置數(=過濾器的深度過濾器的深度)

一個卷積層的前向傳播過程

import tensorflow as tf# 參數變量是一個四維矩陣， # 分為是過濾器的尺寸（長、寬）、當前層的深度、過濾器的深度 filter_weight = tf.get_variable('weights', [5, 5, 3, 16], initializer=tf.truncated_normal_initializer(stddev=0.1)) # 偏置項也是共享的,參數值為下一層深度個（過濾器的深度）個不同的偏置項 biases = tf.get_variable('biases', [16], initializer=tf.constant_initializer(0.1))# tf.nn.conv2d實現卷積層前向傳播 # 第一個輸入：當前層節點矩陣,第一維對應一個輸入batch # （比如輸入層，input[0,:,:,:]表示輸入第一張圖像，input[1,:,:,:]表示輸入第二張圖像 # 第二個參數：卷積層的權重 # 第三個參數不同維度上的步長（第一維和最后一維要求一定是1，因為步長只對矩陣的長和寬有效） # 第四個參數：填充的方法，可選'SAME'（全0填充）/'VALID'（不填充） conv = tf.nn.conv2d(input, filter_weight, strides=[1,1,1,1], padding='SAME')# tf.nn.bias_add 可以在每一個節點加上偏置項 # 不直接使用加法：因為矩陣上不同位置上的節點都需要加上相同的偏置項 bias = tf.nn.bias_add(conv, biases) # 將計算結果通過ReLU函數激活 actived_relu = tf.nn.relu(bias)

2、池化層

作用：

• 減少參數
• 防止過擬合
• 獲得平移不變性
• 加快計算速度

常用池化的類型：

• 最大池化
• 平均池化

池化層的作用范圍：

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

（２）實現

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

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'表示不填充

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

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'表示不填充

四、經典CNN模型

通過這些經典的卷積神經網絡的網絡結構可以總結出卷積神經網絡結構設計的一些模式。

1、LeNet-5 模型（1998）

（１）模型

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

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

第一層：卷積層

• 輸入：原始圖像的像素（32×32×1）
• 過濾器：尺寸為 $5\times 5$，深度為6，不使用全0填充，步長為1
• 輸出：尺寸為 $32?5+1=28$，深度為6
• 參數個數：$5\times 5\times 1\times 6+6=156$
• 下一層節點矩陣的節點： $28\times 28\times 6=4704$ ，每個節點和 $5\times 5=25$ 個當前層節點相連
• 本層卷積層共有連接個數： $28\times 28\times 6\times (25+1)=122304$

第二層：池化層

• 輸入：第一層的輸出，是一個 $28\times 28\times 6$ 的節點矩陣
• 過濾器：大小為2*2，長、寬、步長都為2
• 輸出：$14\times 14\times 6$

第三層：卷積層

• 輸入：$14\times 14\times 6$
• 過濾器：大小為$5\times 5$，深度為16，不使用0填充，步長為1
• 輸出：$10\times 10\times 16$，按標準的卷積層，本層應該有 $5\times 5\times 16\times +16=2416$個參數
• 共有：$10\times 10\times 16\times (25+1)=41600$ 個連接

第四層：池化層
輸入：$10\times 10\times 16$
過濾器：大小為 $2\times 2$，步長為2
輸出：矩陣大小為 $5\times 5\times 16$

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

第六層：全連接層
輸入：節點個數為120個
輸出：節點個數為84個
總共參數：$120\times 84+84=10164$ 個

第七層：全連接層
輸入：84個節點
輸出：10個節點
總共參數：$84\times 10+10=850$ 個

（２）代碼示例

１. lenet_inference.py

# -*- coding:utf-8 -*- import tensorflow as tf# 1. 配置神經網絡的參數。 INPUT_NODE = 784 OUTPUT_NODE = 10IMAGE_SIZE = 28 NUM_CHANNELS = 1 NUM_LABELS = 10# layer1:conv1 CONV1_DEEP = 32 CONV1_SIZE = 5 # layer:CONV2 CONV2_DEEP = 64 CONV2_SIZE = 5 # FC節點個數 FC_SIZE = 512# 2. 定義卷積神經網絡的前向傳播過程。 # train參數用于區分訓練過程和測試過程。 # 這個程序中將用到 dropout 方法，只在訓練時使用。 def inference(input_tensor, train, regularizer):with tf.variable_scope('layer1-conv1'):conv1_weights = tf.get_variable("weights",[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.variable_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("weights",[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.variable_scope('layer4-pool2'):pool2 = tf.nn.max_pool(relu2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')# 將第四層池化層的輸出轉換為第五層 FC 層的輸入格式# size: 7*7*74 -> 一個一維向量# 注意因為每一層神經網絡的輸入輸出都是一個batch的矩陣，所以這里得到的維度也包含一個batch中的數據個數pool_shape = pool2.get_shape().as_list()# pool_shape[0] 一個 batch 中數據的個數nodes = pool_shape[1] * pool_shape[2] * pool_shape[3]# 通過 tf.reshape 函數將第四層的輸出變成一個 batch 的向量reshaped = tf.reshape(pool2, [pool_shape[0], nodes])# 引入dropout, dropout 一般只在全連接層而不是卷積層或者池化層使用。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, OUTPUT_NODE],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

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/' 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("./datasets/MNIST_DATA", one_hot=True)train(mnist)if __name__ == '__main__':tf.app.run()

輸出結果

After 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. ...

３．lent_eval.py（測試該網絡在mnist的正確率，達到99.16%，巨幅高于第五章的98.4%）

import time import math import tensorflow as tf import numpy as np from tensorflow.examples.tutorials.mnist import input_data import lenet_inference import lenet_traindef evaluate(mnist):with tf.Graph().as_default() as g:# 定義輸出為4維矩陣的placeholderx = tf.placeholder(tf.float32, [mnist.test.num_examples,#lenet_train.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')validate_feed = {x: mnist.test.images, y_: mnist.test.labels}global_step = tf.Variable(0, trainable=False)regularizer = tf.contrib.layers.l2_regularizer(lenet_train.REGULARIZATION_RATE)y = lenet_inference.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(lenet_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 / lenet_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(lenet_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(lenet_train.BATCH_SIZE)reshaped_xs = np.reshape(xs, (mnist.test.num_examples,#lenet_train.BATCH_SIZE,lenet_inference.IMAGE_SIZE,lenet_inference.IMAGE_SIZE,lenet_inference.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()

輸出結果

After 54001 training step(s), test accuracy = 0.9916

2、CNN模型正則表達

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

如何設計卷積神經網絡架構
該正則表達公式總結了經典的用于圖像分類問題的卷積神經網絡架構
輸入層　→（卷積層+　→　池化層？）+　→　全連接層+
其中：

+表示一層或多層

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

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

==》
LeNet-5的正則表達：

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

此外，AlexNet、ZFNet、VGGNet都滿足上述正則表達式。

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

相關配置

• convX-Y：濾波器的邊長為X，深度為Y
  • VGGNet中的濾波器的邊長基本都為3或1
  • LeNet-5中使用了大小為55的濾波器，一般都不會超過5，但也有的設置為77，甚至11*11的
• 在濾波器的深度選擇上，大部分都采用逐層遞增的方式，VGG中，每經過一個池化層，濾波器的深度*2，
  • 卷積層的步長一般為2，但也有例外（使用2或3）
• 池化層配置相對簡單，用的最多的是最大池化層，邊長一般為2或3，步長一般為2或3

3、Inception-v3模型

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

（１）Inception結構

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

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

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

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

• 使用TensorFlow-Slim實現卷積層

import tensorflow.contrib.slim as slimtf.contrib.slim.conv2d (inputs,num_outputs,#[卷積核個數]kernel_size,#[高度，寬度]stride=1,#步長padding='SAME',#VALID） net=slim.conv2d(input,32,[3,3]) # 可以在一行中實現一個卷積層的前向傳播算法 # 第一個參數：輸入節點矩陣 # 第二個參數：當前卷積層過濾器的深度 # 第三個參數：過濾器的尺寸 # 可選步長、填充、激活函數、變量命名空間等

（２）Inception模塊實現

# loading the lib of slim import tensorflow as tfslim = tf.contrib.slim# slim.arg_scope函數用于設置默認參數取值。 # 第一個參數：一個函數列表。該列表中函數將使用默認的參數取值 # 調用slim.conv2d(net, 320 , [1 , 1])函數時會自動加上 stride=1 和 padding＝’ SAME’的參數。若函數調用時指定stride，則這里默認值就補在使用。 # 作用：較少冗余的代碼# loading the lib of slim with slim.arg_scope([slim.conv2d, slim.max_pool2d, slim.avg_pool2d], stride=1, padding='VALID):...# 此處省略Inception-v3模型中年其他網絡結構而直接實現最后方框中的Inception結構。# 假設：輸入圖片經過之前的神經網絡前向傳播的結果保存在變量net中。net = 上一層的輸出節點矩陣# 為一個 Inception 模塊聲明一個統一的變量命名空間。with tf.variable_scope('Mixed_7c'):# 給 Inception 模塊中每一條路徑聲明一個命名空間。with tf.variable_scope('Branch_0'):# 實現一個過濾器邊長為 1 ，深度為 320 的卷積層。branch_0 = slim.conv2d(net, 320, [1, 1], scope='Conv2d_0a_1x1')with tf.variable_scope('Branch_1'):branch_1 = slim.conv2d(net, 384, [1, 1], scope='Conv2d_0a_1x1')# tf.concat函數可以將多個矩陣拼接起來。# 第一個參數:拼接的維度, "3"代表了矩陣是在深度這個維度上進行拼接,如圖 6-16 所示branch_1 = tf.concat(3, [# 如圖 6-17 所示，此處 2 層卷積層的輸入都是branch_1而不是netslim.conv2d(branch_1, 384, [1, 3], scope='Conv2d_0b_1x3'),slim.conv2d(branch_1, 384, [3, 1], scope='Conv2d_0c_3x1')])with tf.variable_scope('Branch_2'):branch_2 = slim.conv2d(net, 448, [1, 1], scope='Conv2d_0a_1x1')branch_2 = slim.conv2d(branch_2, 384, [3, 3], scope='Conv2d_0b_3x3')branch_2 = tf.concat(3, [slim.conv2d(branch_2, 384, [1, 3], scope='Conv2d_0c_1x3'),slim.conv2d(branch_2, 384, [3, 1], scope='Conv2d_0d_3x1')])with tf.variable_scope('Branch_3'):branch_3 = slim.avg_pool2d(net, [3, 3], scope='AvgPool_0a_3x3')branch_3 = slim.conv2d(branch_3, 192, [1, 1], scope='Conv2d_0b_1x1')# Inception 模塊的最后輸出是由上面 4 個計算結果拼接得到的。net = tf.concat(3, [branch_0, branch_1, branch_2, branch_3])

五、ＣＮＮ遷移學習

1、遷移學習介紹

目標：為了解決標注數據和訓練時間的問題。（很難收集到非常多的標注數據；要訓練一個復雜的卷積神經網絡需要幾天甚至幾周的時間 。）
不足：一般來說，在數據量足夠的情況下，遷移學習的效果不如完全重新訓練。但是遷移學習所需要的訓練時間和訓練樣本數要遠遠小于訓練完整的模型 。

遷移學習：將一個問題上訓練好的模型通過簡單的調整使其適用于一個新的問題 。

實例：利用 ImageNet 數據集上訓練好的 Inception-v3 模型來解決一個新的圖像分類問題 。 根據論文 DeCAF: A Deep Convolutional Activation Feature for Generic Visual Recognition 中的結論，可以保留訓練好的 Inception-v3 模型中所有卷積層的參數，只是替換最后一層全連接層。 在最后這一層全連接層之前的網絡層稱之為瓶頸層（ bottleneck ）。

2、TF實現遷移學習

（１）獲取數據集

wget http://download.tensorflow.org/example_images/flower_photos.tgz tar xzf flower_photos.tgz

文件夾包含了 5 個子文件夾 ， 每一個子文件夾的名稱為一種花的名稱，代表了不同的類別 。平均每一種花有 734 張圖片，每一張圖片都是 RGB 色彩模式的，大小也不相同。

（２）數據預處理

將原始的圖像數據整理成模型需要的輸入數據。
==》將所有的圖片數據劃分成訓練、 驗證和測試 3 個數據集；圖像轉換為2992993的數字矩陣。

#-*-coding:utf-8-*-import tensorflow as tf import glob import os.path import numpy as np from tensorflow.contrib.slim import slim from tensorflow.python.platform import gfile# 原始輸入數據的目錄 INPUT_DATA = './datasets/flower_photos' # 輸出文件地址。將整理后的圖片數據通過 numpy 的格式保存。 OUTPUT_FILE = './datasets/flower_processed_data.npy'# 測試數據和驗證數據比例。 VALIDATION_PERCENTAGE = 10 TEST_PERCENTAGE = 10def create_image_lists(sess, testing_percentage, valiation_percentage):sub_dirs = [x[0] for x in os.walk(INPUT_DATA)]is_root_dir = True# 初始化各個數據集training_images = []training_labels = []testing_images = []testing_labels = []valiation_images = []valiation_labels = []current_label = 0count = 0# 讀取所有的子目錄。for sub_dir in sub_dirs:if is_root_dir:is_root_dir = Falsecontinue# 獲取一個子目錄中所有的圖片文件。extensions = ['jpg']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: continue# 處理圖片數據。for file_name in file_list:# 讀取并解析圖片，將圖片轉化為299×299以便inception-v3模型來處理。image_raw_data = gfile.FastGFile(file_name, 'rb').read()image = tf.image.decode_jpeg(image_raw_data)if image.dtype != tf.float32:image = tf.image.convert_image_dtype(image, dtype=tf.float32)image = tf.image.resize_images(image, [229, 229])image_value = sess.run(image)# 隨機劃分數據集chance = np.random.randint(100)if chance < valiation_percentage:valiation_images.append(image_value)valiation_labels.append(current_label)elif chance < (testing_percentage + valiation_percentage):testing_images.append(image_value)testing_labels.append(current_label)else:training_images.append(image_value)training_labels.append(current_label)count = count + 1print('count: ', count)current_label += 1# 將訓練數據隨機打亂以獲得更好的訓練效果。state = np.random.get_state()np.random.shuffle(training_images)np.random.set_state(state)np.random.shuffle(training_labels)return np.asarray([training_images, training_labels,valiation_images,valiation_labels,testing_images, testing_labels])# 數據整理主函數。 def main():with tf.Session() as sess:processed_data = create_image_lists(sess, TEST_PERCENTAGE, VALIDATION_PERCENTAGE)np.save(OUTPUT_FILE, processed_data)if __name__ == '__main__':main()

（３）獲取預訓練模型

wget https://storage.googleapis.com/download.tensorflow.org/models/inception_v3_2016_08_28.tar.gz tar xzf inception_v3_2016_08_28.tar.gz

（４）遷移學習代碼實現

INPUT_DATA = './datasets/flower_photos/flower_processed_data.npy' TRAIN_FILE = './model/transfer' CKPT_FILE = './model/inception_v3_2016_08_28/inception_v3.ckpt'LEARNING_RATE = 0.0001 STEPS = 300 BATCH = 32 N_CLASSES = 5# 不需要從預訓練好的模型中加載的參數。（最后的全連接層） CHECKPOINT_EXCLUDE_SCOPES = 'InceptionV3/Logits, InceptionV3/AuxLogits' # 需要訓練的網絡層參數名稱，在fine-tuning過程中就是最后的全連接層 TRAINABLE_SCOPES='InceptionV3/Logits, InceptionV3/AuxLogits'# 獲取所有需要從預訓練模型中加載的參數 def get_tuned_variables():exclusions = [scope.strip() for scope in CHECKPOINT_EXCLUDE_SCOPES.split(',')]variables_to_restore = []# 枚舉inception-v3模型中所有的參數，然后判斷是否滿要從加載列表中移除。for var in slim.get_model_variables():excluded = Falsefor extension in exclusions:if var.op.name.startswith(extension):excluded = Truebreakif not excluded:variables_to_restore.append(var)return variables_to_restore# 獲取所有需要訓練的變量列表。 def get_trainable_variables():scopes = [scope.strip() for scope in TRAINABLE_SCOPES.split(',')]variables_to_train = []# 枚舉所有需要訓練的參數前綴，并通過這些前綴找到所有的參for scope in scopes:variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope)variables_to_train.extend(variables)return variables_to_traindef main():# 加載預處理好的數據。processed_data = np.load(INPUT_DATA)training_images = processed_data[0]n_training_example = len(training_images)training_labels = processed_data[1]valiation_images = processed_data[2]valiation_labels = processed_data[3]testing_images = processed_data[4]testing_labels = processed_data[5]print("%d training examples, %d valiation examples and %d testing examples."% (n_training_example, len(valiation_labels), len(testing_labels)))# 定義inception-v3的輸入，images為輸入圖片，labels為每一張圖片對應的標簽。images = tf.placeholder(tf.float32, [None, 299, 299, 3], name='input_image')labels = tf.placeholder(tf.int64, [None], name='labels')# 定義 inception-v3 模型。# 預訓練模型只有模型參數取值，所以代碼中需定義inception-v3的模型結構。# 雖然理論上需要區分訓練和測試中使用的模型，也就是說在測試時應該使用 is training=False，# 但是因為預先訓練好的 inception-v3 模型中使用的 batch normalization # 參數與新的數據會有差異，導致結果很差，所以這里直接使用同一個模型來進行測試。with slim.arg_scope(inception_v3.inception_v3_arg_scope()):logits, _ = inception_v3.inception_v3(images, num_classes=N_CLASSES)# 獲取需要訓練的變量。trainable_variables = get_trainable_variables()# 定義交叉熵損失。注意在模型定義的時候己經將正則化損失加入損失集合了。tf.losses.softmax_cross_entropy(tf.one_hot(labels, N_CLASSES), logits, weights=1.0)# 定義訓練過程。這里 minimize 的過程中指定了需要優化的變量集合。train_step = tf.train.RMSPropOptimizer(LEARNING_RATE).minimize(tf.losses.get_total_loss())# accuracywith tf.name_scope('evaluation'):correct_prediction = tf.equal(tf.argmax(logits, 1), labels)evaluation_step = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))# 定義加載模型的函數。load_fn = slim.assign_from_checkpoint_fn(CKPT_FILE,get_tuned_variables(),ignore_missing_vars=True)# 定義保存新的訓練好的模型的函數saver = tf.train.Saver()with tf.Session() as sess:# 初始化沒有加載進來的變量。注意這個過程一定要在模型加載之前，# 否則初始化過程會將已經加載好的變量重新賦值init = tf.global_variables_initializer()sess.run(init)# 加載預訓練模型print("Loading tuned variables from %s" % CKPT_FILE)load_fn(sess)start = 0end = BATCHfor i in range(STEPS):# 運行訓練過程，這里不會更新全部的參數，只會更新指定的部分參數。sess.run(train_step, feed_dict={images:training_images[start:end],labels:training_labels[start:end] })# 輸出日志if i % 30 == 0 or i + 1 == STEPS:saver.save(sess, TRAIN_FILE, global_step = i)valiation_accuracy = sess.run(evaluation_step,feed_dict={images:valiation_images,labels:valiation_labels })print("Step %d: Validation accuracy = %.1f%%" % (i, valiation_accuracy*100.0))# 因為在數據預處理時做了打亂數據的操作，所以這里需順序使用訓練數據就好。start = endif start == n_training_example:start = 0end = start + batchif end > n_training_example:end = n_training_example# testingtest_accuracy = sess.run(evaluation_step, feed_dict={images:testing_images, labels:testing_labels })print('Final test accuracy = %.1f%%' % (test_accuracy * 100))if __name__ == '__main__':main()

輸出結果

Step 0: Validation accuracy = 26.4% Step 30: Validation accuracy = 29.5% Step 60: Validation accuracy = 43.5% Step 90: Validation accuracy = 77.7% Step 120: Validation accuracy = 89.6% Step 150: Validation accuracy = 90.2% Step 180: Validation accuracy = 94.8% Step 210: Validation accuracy = 94.3% Step 240: Validation accuracy = 95.3% Step 270: Validation accuracy = 95.3% Step 299: Validation accuracy = 93.8% 2019-03-21 10:37:45.608084: W tensorflow/core/common_runtime/bfc_allocator.cc:219] Allocator (GPU_0_bfc) ran out of memory trying to allocate 3.67GiB. The caller indicates that this is not a failure, but may mean that there could be performance gains if more memory were available. 2019-03-21 10:37:46.101814: W tensorflow/core/common_runtime/bfc_allocator.cc:219] Allocator (GPU_0_bfc) ran out of memory trying to allocate 3.67GiB. The caller indicates that this is not a failure, but may mean that there could be performance gains if more memory were available. Final test accuracy = 92.0%

總結

以上是生活随笔為你收集整理的【TensorFlow】笔记４：图像识别与CNN的全部內容，希望文章能夠幫你解決所遇到的問題。

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