06.圖像識别與卷積神經網絡------《Tensorflow實戰Google深度學習架構》筆記

一、圖像識别問題簡介及經典資料集

圖像識别問題希望借助計算機程式來處理、分析和了解圖檔中的内容，使得計算機可以從圖檔中自動識别各種不同模式的目标和對象。圖像識别問題作為人工智能的一個重要領域，在最近幾年已經取得了很多突破性的進展，其中，卷積神經網絡就是這些突破性進展背後最主要的技術支援。

如下為一些經典的資料集介紹：

ImageNet

         ImageNet是一個計算機視覺系統識别項目，是目前世界上圖像識别最大的資料庫。是美國斯坦福的計算機科學家李飛飛模拟人類的識别系統建立的。能夠從圖檔識别物體。目前已經包含14197122張圖像，是已知的最大的圖像資料庫。每年的ImageNet大賽更是魂萦夢牽着國内外各個名校和大型IT公司以及網絡巨頭的心。圖像如下圖所示，需要注冊ImageNet帳号才可以下載下傳，下載下傳連結為http://www.image-net.org/

PASCAL VOC

         PASCALVOC 資料集是視覺對象的分類識别和檢測的一個基準測試，提供了檢測算法和學習性能的标準圖像注釋資料集和标準的評估系統。圖像如下圖所示，包含VOC2007（430M），VOC2012（1.9G）兩個下載下傳版本。下載下傳連結為http://pjreddie.com/projects/pascal-voc-dataset-mirror/

Labelme

         Labelme是斯坦福一個學生的母親利用休息時間幫兒子做的标注，後來便發展為一個資料集。該資料集的主要特點包括

（1）專門為物體分類識别設計，而非僅僅是執行個體識别

（2）專門為學習嵌入在一個場景中的對象而設計

（3）高品質的像素級别标注，包括多邊形框（polygons）和背景标注（segmentation masks）

（4）物體類别多樣性大，每種物體的差異性，多樣性也大。

（5）所有圖像都是自己通過相機拍攝，而非copy

（6）公開的，免費的

         圖像如下圖所示，需要通過matlab來下載下傳，一種奇特的下載下傳方式，下載下傳連結為http://labelme2.csail.mit.edu/Release3.0/index.php

COCO

       COCO是一種新的圖像識别，分割和加字幕标注的資料集。主要由Tsung-Yi Lin（Cornell Tech），Genevieve Patterson （Brown），MatteoRuggero Ronchi （Caltech），Yin Cui （Cornell Tech），Michael Maire （TTI Chicago），Serge Belongie （Cornell Tech），Lubomir Bourdev （UC Berkeley），Ross Girshick （Facebook AI), James Hays (Georgia Tech),PietroPerona (Caltech)，Deva Ramanan (CMU），Larry Zitnick （Facebook AI）， Piotr Dollár （Facebook AI）等人收集而成。其主要特征如下

（1）目标分割

（2）通過上下文進行識别

（3）每個圖像包含多個目标對象

（4）超過300000個圖像

（5）超過2000000個執行個體

（6）80種對象

（7）每個圖像包含5個字幕

（8）包含100000個人的關鍵點

         圖像如下圖所示，支援Matlab和Python兩種下載下傳方式，下載下傳連結為http://mscoco.org/

SUN

         SUN資料集包含131067個圖像，由908個場景類别和4479個物體類别組成，其中背景标注的物體有313884個。圖像如下圖所示，下載下傳連結為http://groups.csail.mit.edu/vision/SUN/

Caltech

         Caltech是加州理工學院的圖像資料庫，包含Caltech101和Caltech256兩個資料集。該資料集是由Fei-FeiLi, Marco Andreetto, Marc 'Aurelio Ranzato在2003年9月收集而成的。Caltech101包含101種類别的物體，每種類别大約40到800個圖像，大部分的類别有大約50個圖像。Caltech256包含256種類别的物體，大約30607張圖像。圖像如下圖所示，下載下傳連結為http://www.vision.caltech.edu/Image_Datasets/Caltech101/

Corel5k

         這是Corel5K圖像集，共包含科雷爾（Corel）公司收集整理的5000幅圖檔，故名：Corel5K，可以用于科學圖像實驗：分類、檢索等。Corel5k資料集是圖像實驗的事實标準資料集。請勿用于商業用途。私底下學習交流使用。Corel圖像庫涵蓋多個主題，由若幹個CD組成，每個CD包含100張大小相等的圖像，可以轉換成多種格式。每張CD代表一個語義主題，例如有公共汽車、恐龍、海灘等。Corel5k自從被提出用于圖像标注實驗後，已經成為圖像實驗的标準資料集，被廣泛應用于标注算法性能的比較。Corel5k由50張CD組成，包含50個語義主題。

         Corel5k圖像庫通常被分成三個部分：4000張圖像作為訓練集，500張圖像作為驗證集用來估計模型參數，其餘500張作為測試集評價算法性能。使用驗證集尋找到最優模型參數後4000張訓練集和500張驗證集混合起來組成新的訓練集。

         該圖像庫中的每張圖檔被标注1~5個标注詞，訓練集中總共有374個标注詞，在測試集中總共使用了263個标注詞。圖像如下圖所示，很遺憾本人也未找到官方下載下傳路徑，于是github上傳了一份，下載下傳連結為https://github.com/watersink/Corel5K

CIFAR（Canada Institude For Advanced Research）

      CIFAR是由加拿大先進技術研究院的AlexKrizhevsky, Vinod Nair和Geoffrey Hinton收集而成的80百萬小圖檔資料集。包含CIFAR-10和CIFAR-100兩個資料集。 Cifar-10由60000張32*32的RGB彩色圖檔構成，共10個分類。50000張訓練，10000張測試（交叉驗證）。這個資料集最大的特點在于将識别遷移到了普适物體，而且應用于多分類。CIFAR-100由60000張圖像構成，包含100個類别，每個類别600張圖像，其中500張用于訓練，100張用于測試。其中這100個類别又組成了20個大的類别，每個圖像包含小類别和大類别兩個标簽。官網提供了Matlab,C，Python三個版本的資料格式。圖像如下圖所示，下載下傳連結為http://www.cs.toronto.edu/~kriz/cifar.html

人臉資料庫:

AFLW（Annotated Facial Landmarks in the Wild）

       AFLW人臉資料庫是一個包括多姿态、多視角的大規模人臉資料庫，而且每個人臉都被标注了21個特征點。此資料庫資訊量非常大，包括了各種姿态、表情、光照、種族等因素影響的圖檔。AFLW人臉資料庫大約包括25000萬已手工标注的人臉圖檔，其中59%為女性，41%為男性，大部分的圖檔都是彩色，隻有少部分是灰色圖檔。該資料庫非常适合用于人臉識别、人臉檢測、人臉對齊等方面的研究，具有很高的研究價值。圖像如下圖所示，需要申請帳号才可以下載下傳，下載下傳連結為http://lrs.icg.tugraz.at/research/aflw/

LFW（Labeled Faces in the Wild）

       LFW是一個用于研究無限制的人臉識别的資料庫。該資料集包含了從網絡收集的13000張人臉圖像，每張圖像都以被拍攝的人名命名。其中，有1680個人有兩個或兩個以上不同的照片。這些資料集唯一的限制就是它們可以被經典的Viola-Jones檢測器檢測到（a hummor）。圖像如下圖所示，下載下傳連結為http://vis-www.cs.umass.edu/lfw/index.html#download

AFW（Annotated Faces in the Wild）

       AFW資料集是使用Flickr（雅虎旗下圖檔分享網站）圖像建立的人臉圖像庫，包含205個圖像，其中有473個标記的人臉。對于每一個人臉都包含一個長方形邊界框，6個地标和相關的姿勢角度。資料庫雖然不大，額外的好處是作者給出了其2012 CVPR的論文和程式以及訓練好的模型。圖像如下圖所示，下載下傳連結為http://www.ics.uci.edu/~xzhu/face/

FDDB（Face Detection Data Set and Benchmark）

       FDDB資料集主要用于限制人臉檢測研究，該資料集選取野外環境中拍攝的2845個圖像，從中選擇5171個人臉圖像。是一個被廣泛使用的權威的人臉檢測平台。圖像如下圖所示，下載下傳連結為http://vis-www.cs.umass.edu/fddb/

WIDER FACE

   WIDER FACE是香港中文大學的一個提供更廣泛人臉資料的人臉檢測基準資料集，由YangShuo， Luo Ping ，Loy ，Chen Change ，Tang Xiaoou收集。它包含32203個圖像和393703個人臉圖像，在尺度，姿勢，閉塞，表達，裝扮，關照等方面表現出了大的變化。WIDER FACE是基于61個事件類别組織的，對于每一個事件類别，選取其中的40%作為訓練集，10%用于交叉驗證（cross validation），50%作為測試集。和PASCAL VOC資料集一樣，該資料集也采用相同的名額。和MALF和Caltech資料集一樣，對于測試圖像并沒有提供相應的背景邊界框。圖像如下圖所示，下載下傳連結為http://mmlab.ie.cuhk.edu.hk/projects/WIDERFace/

CMU-MIT

     CMU-MIT是由卡内基梅隆大學和麻省理工學院一起收集的資料集，所有圖檔都是黑白的gif格式。裡面包含511個閉合的人臉圖像，其中130個是正面的人臉圖像。圖像如下圖所示，沒有找到官方連結，Github下載下傳連結為 https://github.com/watersink/CMU-MIT

GENKI

         GENKI資料集是由加利福尼亞大學的機器概念實驗室收集。該資料集包含GENKI-R2009a,GENKI-4K,GENKI-SZSL三個部分。GENKI-R2009a包含11159個圖像，GENKI-4K包含4000個圖像，分為“笑”和“不笑”兩種，每個圖檔的人臉的尺度大小，姿勢，光照變化，頭的轉動等都不一樣，專門用于做笑臉識别。GENKI-SZSL包含3500個圖像，這些圖像包括廣泛的背景，光照條件，地理位置，個人身份和種族等。圖像如下圖所示，下載下傳連結為http://mplab.ucsd.edu，如果進不去可以，同樣可以去下面的github下載下傳，連結https://github.com/watersink/GENKI

IJB-A (IARPA JanusBenchmark A)

       IJB-A是一個用于人臉檢測和識别的資料庫，包含24327個圖像和49759個人臉。圖像如下圖所示，需要郵箱申請相應帳号才可以下載下傳，下載下傳連結為http://www.nist.gov/itl/iad/ig/ijba_request.cfm

MALF (Multi-Attribute Labelled Faces)

       MALF是為了細粒度的評估野外環境中人臉檢測模型而設計的資料庫。資料主要來源于Internet，包含5250個圖像，11931個人臉。每一幅圖像包含正方形邊界框，俯仰、蜷縮等姿勢等。該資料集忽略了小于20*20的人臉，大約838個人臉，占該資料集的7%。同時，該資料集還提供了性别，是否帶眼鏡，是否遮擋，是否是誇張的表情等資訊。圖像如下圖所示，需要申請才可以得到官方的下載下傳連結，連結為 http://www.cbsr.ia.ac.cn/faceevaluation/

MegaFace

    MegaFace資料集包含一百萬張圖檔，代表690000個獨特的人。所有資料都是華盛頓大學從Flickr（雅虎旗下圖檔分享網站）組織收集的。這是第一個在一百萬規模級别的面部識别算法測試基準。 現有臉部識别系統仍難以準确識别超過百萬的資料量。為了比較現有公開臉部識别算法的準确度，華盛頓大學在去年年底開展了一個名為“MegaFace Challenge”的公開競賽。這個項目旨在研究當資料庫規模提升數個量級時，現有的臉部識别系統能否維持可靠的準确率。圖像如下圖所示，需要郵箱申請才可以下載下傳，下載下傳連結為http://megaface.cs.washington.edu/dataset/download.html

300W

       300W資料集是由AFLW，AFW，Helen，IBUG，LFPW，LFW等資料集組成的資料庫。圖像如下圖所示，需要郵箱申請才可以下載下傳，下載下傳連結為 http://ibug.doc.ic.ac.uk/resources/300-W/

IMM Data Sets

       IMM人臉資料庫包括了240張人臉圖檔和240個asf格式檔案（可以用UltraEdit打開，記錄了58個點的地标），共40個人（7女33男），每人6張人臉圖檔，每張人臉圖檔被标記了58個特征點。所有人都未戴眼鏡,圖像如下圖所示，下載下傳連結為http://www2.imm.dtu.dk/~aam/datasets/datasets.html

MUCT Data Sets

         MUCT人臉資料庫由3755個人臉圖像組成，每個人臉圖像有76個點的地标（landmark），圖檔為jpg格式，地标檔案包含csv,rda,shape三種格式。該圖像庫在種族、關照、年齡等方面表現出更大的多樣性。具體圖像如下圖所示，下載下傳連結為 http://www.milbo.org/muct/

ORL  (AT&T Dataset)

         ORL資料集是劍橋大學AT&T實驗室收集的一個人臉資料集。包含了從1992.4到1994.4該實驗室的成員。該資料集中圖像分為40個不同的主題，每個主題包含10幅圖像。對于其中的某些主題，圖像是在不同的時間拍攝的。在關照，面部表情（張開眼睛，閉合眼睛，笑，非笑），面部細節（眼鏡）等方面都變現出了差異性。所有圖像都是以黑色均勻背景，并且從正面向上方向拍攝。

         其中圖檔都是PGM格式，圖像大小為92*102，包含256個灰色通道。具體圖像如下圖所示，下載下傳連結為http://www.cl.cam.ac.uk/research/dtg/attarchive/facedatabase.html

行人檢測資料庫

INRIA Person Dataset

         Inria資料集是最常使用的行人檢測資料集。其中正樣本（行人）為png格式，負樣本為jpg格式。裡面的圖檔分為隻有車，隻有人，有車有人，無車無人四個類别。圖檔像素為70*134，96*160，64*128等。具體圖像如下圖所示，下載下傳連結為http://pascal.inrialpes.fr/data/human/

CaltechPedestrian Detection Benchmark

         加州理工學院的步行資料集包含大約包含10個小時640x480 30Hz的視訊。其主要是在一個在行駛在鄉村街道的小車上拍攝。視訊大約250000幀（在137個約分鐘的長段），共有350000個邊界框和2300個獨特的行人進行了注釋。注釋包括包圍盒和詳細的閉塞标簽之間的時間對應關系。更多資訊可在其PAMI 2012 CVPR 2009标杆的論文獲得。具體圖像如下圖所示，下載下傳連結為http://www.vision.caltech.edu/Image_Datasets/CaltechPedestrians/

MIT cbcl (center for biological and computational learning)Pedestrian Data 

         該資料集主要包含2個部分，一部分為128*64的包含924個圖檔的ppm格式的圖檔，另一部分為從打圖中分别切割而出的小圖，主要包含胳膊，腦袋，腳，腿，頭肩，身體等。具體圖像如下圖所示，下載下傳連結為http://cbcl.mit.edu/software-datasets/PedestrianData.html，需要翻牆才可以。

年齡，性别資料庫

Adience

         該資料集來源為Flickr相冊，由使用者使用iPhone5或者其它智能手機裝置拍攝，同時具有相應的公衆許可。該資料集主要用于進行年齡和性别的未經過濾的面孔估計。同時，裡面還進行了相應的landmark的标注。是做性别年齡估計和人臉對齊的一個資料集。圖檔包含2284個類别和26580張圖檔。具體圖像如下圖所示，下載下傳連結為http://www.openu.ac.il/home/hassner/Adience/data.html#agegender

車輛資料庫

KITTI（Karlsruhe Institute ofTechnology and Toyota Technological Institute）

         KITTI包含7481個訓練圖檔和7518個測試圖檔。所有圖檔都是真彩色png格式。該資料集中标注了車輛的類型，是否截斷，遮擋情況，角度值，2維和3維box框，位置，旋轉角度，分數等重要的資訊，絕對是做車載導航的不可多得的資料集。具體圖像如下圖所示，下載下傳連結為http://www.cvlibs.net/datasets/kitti/

字元資料庫

MNIST（Mixed National Instituteof Standards and Technology）

         MNIST是一個大型的手寫數字資料庫，廣泛用于機器學習領域的訓練和測試，由紐約大學的Yann LeCun整理。MNIST包含60000個訓練集，10000個測試集，每張圖都進行了尺度歸一化和數字居中處理，固定尺寸大小為28*28。具體圖像如下圖所示，下載下傳連結為http://yann.lecun.com/exdb/mnist/

二、卷積神經網絡簡介

全連接配接網絡 VS 卷積網絡  

全連接配接神經網絡之是以不太适合圖像識别任務，主要有以下幾個方面的問題：

• 參數數量太多

考慮一個輸入1000*1000像素的圖檔(一百萬像素，現在已經不能算大圖了)，輸入層有1000*1000=100萬節點。假設第一個隐藏層有100個節點(這個數量并不多)，那麼僅這一層就有(1000*1000+1)*100=1億參數，這實在是太多了！我們看到圖像隻擴大一點，參數數量就會多很多，是以它的擴充性很差。

• 沒有利用像素之間的位置資訊 

對于圖像識别任務來說，每個像素和其周圍像素的聯系是比較緊密的，和離得很遠的像素的聯系可能就很小了。如果一個神經元和上一層所有神經元相連，那麼就相當于對于一個像素來說，把圖像的所有像素都等同看待，這不符合前面的假設。當我們完成每個連接配接權重的學習之後，最終可能會發現，有大量的權重，它們的值都是很小的(也就是這些連接配接其實無關緊要)。努力學習大量并不重要的權重，這樣的學習必将是非常低效的。

• 網絡層數限制 

我們知道網絡層數越多其表達能力越強，但是通過梯度下降方法訓練深度全連接配接神經網絡很困難，因為全連接配接神經網絡的梯度很難傳遞超過3層。是以，我們不可能得到一個很深的全連接配接神經網絡，也就限制了它的能力。

那麼，卷積神經網絡又是怎樣解決這個問題的呢？主要有三個思路：

• 局部連接配接：這個是最容易想到的，每個神經元不再和上一層的所有神經元相連，而隻和一小部分神經元相連。這樣就減少了很多參數。
• 權值共享：一組連接配接可以共享同一個權重，而不是每個連接配接有一個不同的權重，這樣又減少了很多參數。
• 下采樣：可以使用Pooling來減少每層的樣本數，進一步減少參數數量，同時還可以提升模型的魯棒性。

對于圖像識别任務來說，卷積神經網絡通過盡可能保留重要的參數，去掉大量不重要的參數，來達到更好的學習效果。

卷積神經網絡的基本結構如圖所示：

       一個卷積神經網絡主要由以下五種結構組成：

    1、輸入層：輸入層是整個神經網絡的輸入，在處理圖像的卷積神經網絡中，它一般代表了一張圖檔的像素矩陣。從輸入層開始，卷積神經網絡通過不同的神經網絡結構将上一層的三維矩陣轉化為下一層的三維矩陣，直到最後的全連接配接層。

    2、卷積層：和傳統全連接配接層不同，卷積層中每一個節點的輸入隻是上一層神經網絡的一小塊，這個小塊常用的大小有3x3或者5x5.卷積層試圖将神經網絡中的每一小塊進行更加深入地分析進而得到抽象程度更高的特征。

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

    4、全連接配接層：在經過多輪卷積層和池化層的處理之後，在卷積神經網絡的最後一般會是由1到2個全連接配接層來給出最後的分類結果。經過幾輪卷積層和池化層的處理之後，可以認為圖像中的資訊已經被抽象成了資訊含量更高的特征。我們可以将卷積層和池化層看成自動圖像特征提取的過程。在特征提取完成後，仍然需要使用全連接配接層來完成分類任務。

    5、Softmax層：這一層主要用于分類問題，通過Softmax層，可以得到目前樣例屬于不同種類的機率分布情況。

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

     卷積神經網絡輸出值的計算  

卷積層輸出值的計算

我們用一個簡單的例子來講述如何計算卷積，然後，我們抽象出卷積層的一些重要概念和計算方法。

假設有一個5*5的圖像，使用一個3*3的filter進行卷積，想得到一個3*3的Feature Map，如下所示：

為了清楚的描述卷積計算過程，我們首先對圖像的每個像素進行編号，用Xi,j表示圖像的第行第列元素；對filter的每個權重進行編号，用Wm,n表示第m行第n列權重，用Wb表示filter的偏置項；對Feature Map的每個元素進行編号，用ai,j表示Feature Map的第i行第j列元素；用f表示激活函數(這個例子選擇relu函數作為激活函數)。然後，使用下列公式計算卷積：

例如，對于Feature Map左上角元素來說，其卷積計算方法為：

計算結果如下圖所示：

接下來，Feature Map的元素的卷積計算方法為：

計算結果如下圖所示：

可以依次計算出Feature Map中所有元素的值。下面的動畫顯示了整個Feature Map的計算過程：

上面的計算過程中，步幅(stride)為1。步幅可以設為大于1的數。例如，當步幅為2時，Feature Map計算如下：

我們注意到，當步幅設定為2的時候，Feature Map就變成2*2了。這說明圖像大小、步幅和卷積後的Feature Map大小是有關系的。事實上，它們滿足下面的關系：

在上面兩個公式中，W2是卷積後Feature Map的寬度；W1是卷積前圖像的寬度；F是filter的寬度；P是Zero Padding數量，Zero Padding是指在原始圖像周圍補幾圈0，如果P的值是1，那麼就補1圈0；S是步幅；H2是卷積後Feature Map的高度；H1是卷積前圖像的寬度。式2和式3本質上是一樣的。

以前面的例子來說，圖像寬度W1=5，filter寬度F=3，Zero PaddingP=0，步幅S=2，則

說明Feature Map寬度是2。同樣，我們也可以計算出Feature Map高度也是2。

前面我們已經講了深度為1的卷積層的計算方法，如果深度大于1怎麼計算呢？其實也是類似的。如果卷積前的圖像深度為D，那麼相應的filter的深度也必須為D。我們擴充一下式1，得到了深度大于1的卷積計算公式：

在式4中，D是深度；F是filter的大小(寬度或高度，兩者相同)；Wd,m,n表示filter的第層第m行第n列權重；ad,I,j表示圖像的第d層第i行第j列像素；其它的符号含義和式1是相同的，不再贅述。

我們前面還曾提到，每個卷積層可以有多個filter。每個filter和原始圖像進行卷積後，都可以得到一個Feature Map。是以，卷積後Feature Map的深度(個數)和卷積層的filter個數是相同的。

下面的動畫顯示了包含兩個filter的卷積層的計算。我們可以看到7*7*3輸入，經過兩個3*3*3filter的卷積(步幅為2)，得到了3*3*2的輸出。另外我們也會看到下圖的Zero padding是1，也就是在輸入元素的周圍補了一圈0。Zero padding對于圖像邊緣部分的特征提取是很有幫助的。

以上就是卷積層的計算方法。這裡面展現了局部連接配接和權值共享：每層神經元隻和上一層部分神經元相連(卷積計算規則)，且filter的權值對于上一層所有神經元都是一樣的。對于包含兩個3*3*3的fitler的卷積層來說，其參數數量僅有(3*3*3+1)*2=56個，且參數數量與上一層神經元個數無關。與全連接配接神經網絡相比，其參數數量大大減少了。

用卷積公式來表達卷積層計算

不想了解太多數學細節的讀者可以跳過這一節，不影響對全文的了解。

式4的表達很是繁冗，最好能簡化一下。就像利用矩陣可以簡化表達全連接配接神經網絡的計算一樣，我們利用卷積公式可以簡化卷積神經網絡的表達。

下面我們介紹二維卷積公式。

設矩陣A，B，其行、列數分别為ma、na、mb、nb，則二維卷積公式如下：

且s,t滿足條件：

我們可以把上式寫成

如果我們按照式5來計算卷積，我們可以發現矩陣A實際上是filter，而矩陣B是待卷積的輸入，位置關系也有所不同：

從上圖可以看到，A左上角的值a0,0與B對應區塊中右下角的值b1,1相乘，而不是與左上角的相乘。是以，數學中的卷積和卷積神經網絡中的『卷積』還是有差別的，為了避免混淆，我們把卷積神經網絡中的『卷積』操作叫做互相關(cross-correlation)操作。

卷積和互相關操作是可以轉化的。首先，我們把矩陣A翻轉180度，然後再交換A和B的位置（即把B放在左邊而把A放在右邊。卷積滿足交換率，這個操作不會導緻結果變化），那麼卷積就變成了互相關。

如果我們不去考慮兩者這麼一點點的差別，我們可以把式5代入到式4：

其中，A是卷積層輸出的feature map。同式4相比，式6就簡單多了。然而，這種簡潔寫法隻适合步長為1的情況。

Pooling層輸出值的計算

Pooling層主要的作用是下采樣，通過去掉Feature Map中不重要的樣本，進一步減少參數數量。Pooling的方法很多，最常用的是Max Pooling。Max Pooling實際上就是在n*n的樣本中取最大值，作為采樣後的樣本值。下圖是2*2 max pooling：

除了Max Pooing之外，常用的還有Mean Pooling——取各樣本的平均值。

對于深度為D的Feature Map，各層獨立做Pooling，是以Pooling後的深度仍然為D。

四、經典卷積網絡模型

1、LeNet-5模型

7層結構分别是： 

卷積層-池化層-卷積層-池化層-全連接配接層-全連接配接層-輸出層 

1. C1層是一個卷積層

輸入圖檔：32*32

卷積核大小：5*5

卷積核種類：6

輸出featuremap大小：28*28 （32-5+1）

神經元數量：28*28*6

可訓練參數：（5*5+1）*6（每個濾波器5*5=25個unit參數和一個bias參數，一共6個濾波器）

連接配接數：（5*5+1）*6*28*28

2. S2層是一個下采樣層

輸入：28*28

采樣區域：2*2

采樣方式：4個輸入相加，乘以一個可訓練參數，再加上一個可訓練偏置。結果通過sigmoid

采樣種類：6

輸出featureMap大小：14*14（28/2）

神經元數量：14*14*6

可訓練參數：2*6（和的權+偏置）

連接配接數：（2*2+1）*6*14*14

S2中每個特征圖的大小是C1中特征圖大小的1/4

3. C3層也是一個卷積層

輸入：S2中所有6個或者幾個特征map組合

卷積核大小：5*5

卷積核種類：16

輸出featureMap大小：10*10

C3中的每個特征map是連接配接到S2中的所有6個或者幾個特征map的，表示本層的特征map是上一層提取到的特征map的不同組合

存在的一個方式是：C3的前6個特征圖以S2中3個相鄰的特征圖子集為輸入。接下來6個特征圖以S2中4個相鄰特征圖子集為輸入。然後的3個以不相鄰的4個特征圖子集為輸入。最後一個将S2中所有特征圖為輸入。

則：可訓練參數：6*（3*25+1）+6*（4*25+1）+3*（4*25+1）+（25*6+1）=1516

連接配接數：10*10*1516=151600

4. S4層是一個下采樣層

輸入：10*10

采樣區域：2*2

采樣方式：4個輸入相加，乘以一個可訓練參數，再加上一個可訓練偏置。結果通過sigmoid

采樣種類：16

輸出featureMap大小：5*5（10/2）

神經元數量：5*5*16=400

可訓練參數：2*16=32（和的權+偏置）

連接配接數：16*（2*2+1）*5*5=2000

S4中每個特征圖的大小是C3中特征圖大小的1/4�

5. C5層是一個卷積層

輸入：S4層的全部16個單元特征map（與s4全相連）

卷積核大小：5*5

卷積核種類：120

輸出featureMap大小：1*1（5-5+1）

可訓練參數/連接配接：120*（16*5*5+1）=48120

6. F6層全連接配接層

輸入：c5 120維向量

計算方式：計算輸入向量和權重向量之間的點積，再加上一個偏置，結果通過sigmoid函數

可訓練參數:84*(120+1)=10164

2、Inception-v3模型

将一個3´3卷積拆成1´3卷積和3´1卷積

一是引入了 Factorization into small convolutions 的思想，将一個較大的二維卷積拆成兩個較小的一維卷積，比如将7´7卷積拆成1´7卷積和7´1卷積，或者将3´3卷積拆成1´3卷積和3´1卷積，如上圖所示。一方面節約了大量參數，加速運算并減輕了過拟合（比将7´7卷積拆成1´7卷積和7´1卷積，比拆成3個3´3卷積更節約參數），同時增加了一層非線性擴充模型表達能力。論文中指出，這種非對稱的卷積結構拆分，其結果比對稱地拆為幾個相同的小卷積核效果更明顯，可以處理更多、更豐富的空間特征，增加特征多樣性。

另一方面，Inception V3 優化了 Inception Module 的結構，現在 Inception Module 有35´35、17´17和8´8三種不同結構。這些 Inception Module 隻在網絡的後部出現，前部還是普通的卷積層。并且 Inception V3 除了在 Inception Module 中使用分支，還在分支中使用了分支（8´8的結構中），可以說是Network In Network In Network。最終取得 top-5 錯誤率 3.5%。

五、卷積神經網絡遷移學習

簡單的講就是将一個在資料集上訓練好的卷積神經網絡模型通過簡單的調整快速移動到另外一個資料集上。

随着模型的層數及模型的複雜度的增加，模型的錯誤率也随着降低。但是要訓練一個複雜的卷積神經網絡需要非常多的标注資訊，同時也需要幾天甚至幾周的時間，為了解決标注資料和訓練時間的問題，就可以使用遷移學習。

下面的代碼就是介紹如何利用ImageNet資料集訓練好的inception-v3模型來解決一個新的圖像分類問題。其中有論文依據表明可以保留訓練好的inception-v3模型中所有卷積層的參數，隻替換最後一層全連接配接層。在最後這一層全連接配接層之前的網絡稱為瓶頸層。

原理：在訓練好的inception-v3模型中，因為将瓶頸層的輸出再通過一個單層的全連接配接層神經網絡可以很好的區分1000種類别的圖像，是以可以認為瓶頸層輸出的節點向量可以被作為任何圖像的一個更具有表達能力的特征向量。于是在新的資料集上可以直接利用這個訓練好的神經網絡對圖像進行特征提取，然後将提取得到的特征向量作為輸入來訓練一個全新的單層全連接配接神經網絡處理新的分類問題。

一般來說在資料量足夠的情況下，遷移學習的效果不如完全重新訓練。但是遷移學習所需要的訓練時間和訓練樣本要遠遠小于訓練完整的模型。

這其中說到inception-v3模型，其實它是和LeNet-5結構完全不同的卷積神經網絡。在LeNet-5模型中，不同卷積層通過串聯的方式連接配接在一起，而inception-v3模型中的inception結構是将不同的卷積層通過并聯的方式結合在一起。 

具體細節請參考别處。

案例來源于 《TensorFlow實戰Google深度學習架構》

谷歌提供的訓練好的Inception-v3模型： https://storage.googleapis.com/download.tensorflow.org/models/inception_dec_2015.zip

案例使用的資料集： http://download.tensorflow.org/example_images/flower_photos.tgz

資料集檔案解壓後，包含5個子檔案夾，子檔案夾的名稱為花的名稱，代表了不同的類别。平均每一種花有734張圖檔，圖檔是RGB色彩模式，大小也不相同。

[python]  view plain  copy

1. # -*- coding: utf-8 -*-  
2. """ 
3. @author: tz_zs 
4. 卷積神經網絡 Inception-v3模型 遷移學習 
5. """  
6. import glob  
7. import os.path  
8. import random  
9. import numpy as np  
10. import tensorflow as tf  
11. from tensorflow.python.platform import gfile  
12. # inception-v3 模型瓶頸層的節點個數  
13. BOTTLENECK_TENSOR_SIZE = 2048  
14. # inception-v3 模型中代表瓶頸層結果的張量名稱  
15. BOTTLENECK_TENSOR_NAME = 'pool_3/_reshape:0'  
16. # 圖像輸入張量所對應的名稱  
17. JPEG_DATA_TENSOR_NAME = 'DecodeJpeg/contents:0'  
18. # 下載下傳的谷歌訓練好的inception-v3模型檔案目錄  
19. MODEL_DIR = '/path/to/model/google2015-inception-v3'  
20. # 下載下傳的谷歌訓練好的inception-v3模型檔案名  
21. MODEL_FILE = 'tensorflow_inception_graph.pb'  
22. # 儲存訓練資料通過瓶頸層後提取的特征向量  
23. CACHE_DIR = 'tmp/bottleneck'  
24. # 圖檔資料的檔案夾  
25. INPUT_DATA = '/path/to/flower_data'  
26. # 驗證的資料百分比  
27. VALIDATION_PERCENTAGE = 10  
28. # 測試的資料百分比  
29. TEST_PERCENTACE = 10  
30. # 定義神經網路的設定  
31. LEARNING_RATE = 0.01  
32. STEPS = 4000  
33. BATCH = 100  
34. # 這個函數把資料集分成訓練，驗證，測試三部分  
35. def create_image_lists(testing_percentage, validation_percentage):  
36.     """ 
37.     這個函數把資料集分成訓練，驗證，測試三部分 
38.     :param testing_percentage:測試的資料百分比 10 
39.     :param validation_percentage:驗證的資料百分比 10 
40.     :return: 
41.     """  
42.     result = {}  
43.     # 擷取目錄下所有子目錄  
44.     sub_dirs = [x[0] for x in os.walk(INPUT_DATA)]  
45.     # ['/path/to/flower_data', '/path/to/flower_data\\daisy', '/path/to/flower_data\\dandelion',  
46.     # '/path/to/flower_data\\roses', '/path/to/flower_data\\sunflowers', '/path/to/flower_data\\tulips']  
47.     # 數組中的第一個目錄是目前目錄，這裡設定标記，不予處理  
48.     is_root_dir = True  
49.     for sub_dir in sub_dirs:  # 周遊目錄數組，每次處理一種  
50.         if is_root_dir:  
51.             is_root_dir = False  
52.             continue  
53.         # 擷取目前目錄下所有的有效圖檔檔案  
54.         extensions = ['jpg', 'jepg', 'JPG', 'JPEG']  
55.         file_list = []  
56.         dir_name = os.path.basename(sub_dir)  # 傳回路徑名路徑的基本名稱，如：daisy|dandelion|roses|sunflowers|tulips  
57.         for extension in extensions:  
58.             file_glob = os.path.join(INPUT_DATA, dir_name, '*.' + extension)  # 将多個路徑組合後傳回  
59.             file_list.extend(glob.glob(file_glob))  # glob.glob傳回所有比對的檔案路徑清單，extend往清單中追加另一個清單  
60.         if not file_list: continue  
61.         # 通過目錄名擷取類别名稱  
62.         label_name = dir_name.lower()  # 傳回其小寫  
63.         # 初始化目前類别的訓練資料集、測試資料集、驗證資料集  
64.         training_images = []  
65.         testing_images = []  
66.         validation_images = []  
67.         for file_name in file_list:  # 周遊此類圖檔的每張圖檔的路徑  
68.             base_name = os.path.basename(file_name)  # 路徑的基本名稱也就是圖檔的名稱，如：102841525_bd6628ae3c.jpg  
69.             # 随機講資料分到訓練資料集、測試集和驗證集  
70.             chance = np.random.randint(100)  
71.             if chance < validation_percentage:  
72.                 validation_images.append(base_name)  
73.             elif chance < (testing_percentage + validation_percentage):  
74.                 testing_images.append(base_name)  
75.             else:  
76.                 training_images.append(base_name)  
77.         result[label_name] = {  
78.             'dir': dir_name,  
79.             'training': training_images,  
80.             'testing': testing_images,  
81.             'validation': validation_images  
82.         }  
83.     return result  
84. # 這個函數通過類别名稱、所屬資料集和圖檔編号擷取一張圖檔的位址  
85. def get_image_path(image_lists, image_dir, label_name, index, category):  
86.     """ 
87.     :param image_lists:所有圖檔資訊 
88.     :param image_dir:根目錄 （ 圖檔特征向量根目錄 CACHE_DIR | 圖檔原始路徑根目錄 INPUT_DATA ） 
89.     :param label_name:類别的名稱（ daisy|dandelion|roses|sunflowers|tulips ） 
90.     :param index:編号 
91.     :param category:所屬的資料集（ training|testing|validation ） 
92.     :return: 一張圖檔的位址 
93.     """  
94.     # 擷取給定類别的圖檔集合  
95.     label_lists = image_lists[label_name]  
96.     # 擷取這種類别的圖檔中，特定的資料集(base_name的一維數組)  
97.     category_list = label_lists[category]  
98.     mod_index = index % len(category_list)  # 圖檔的編号%此資料集中圖檔數量  
99.     # 擷取圖檔檔案名  
100.     base_name = category_list[mod_index]  
101.     sub_dir = label_lists['dir']  
102.     # 拼接位址  
103.     full_path = os.path.join(image_dir, sub_dir, base_name)  
104.     return full_path  
105. # 圖檔的特征向量的檔案位址  
106. def get_bottleneck_path(image_lists, label_name, index, category):  
107.     return get_image_path(image_lists, CACHE_DIR, label_name, index, category) + '.txt'  # CACHE_DIR 特征向量的根位址  
108. # 計算特征向量  
109. def run_bottleneck_on_image(sess, image_data, image_data_tensor, bottleneck_tensor):  
110.     """ 
111.     :param sess: 
112.     :param image_data:圖檔内容 
113.     :param image_data_tensor: 
114.     :param bottleneck_tensor: 
115.     :return: 
116.     """  
117.     bottleneck_values = sess.run(bottleneck_tensor, {image_data_tensor: image_data})  
118.     bottleneck_values = np.squeeze(bottleneck_values)  
119.     return bottleneck_values  
120. # 擷取一張圖檔對應的特征向量的路徑  
121. def get_or_create_bottleneck(sess, image_lists, label_name, index, category, jpeg_data_tensor, bottleneck_tensor):  
122.     """ 
123.     :param sess: 
124.     :param image_lists: 
125.     :param label_name:類别名 
126.     :param index:圖檔編号 
127.     :param category: 
128.     :param jpeg_data_tensor: 
129.     :param bottleneck_tensor: 
130.     :return: 
131.     """  
132.     label_lists = image_lists[label_name]  
133.     sub_dir = label_lists['dir']  
134.     sub_dir_path = os.path.join(CACHE_DIR, sub_dir)  # 到類别的檔案夾  
135.     if not os.path.exists(sub_dir_path): os.makedirs(sub_dir_path)  
136.     bottleneck_path = get_bottleneck_path(image_lists, label_name, index, category)  # 擷取圖檔特征向量的路徑  
137.     if not os.path.exists(bottleneck_path):  # 如果不存在  
138.         # 擷取圖檔原始路徑  
139.         image_path = get_image_path(image_lists, INPUT_DATA, label_name, index, category)  
140.         # 擷取圖檔内容  
141.         image_data = gfile.FastGFile(image_path, 'rb').read()  
142.         # 計算圖檔特征向量  
143.         bottleneck_values = run_bottleneck_on_image(sess, image_data, jpeg_data_tensor, bottleneck_tensor)  
144.         # 将特征向量存儲到檔案  
145.         bottleneck_string = ','.join(str(x) for x in bottleneck_values)  
146.         with open(bottleneck_path, 'w') as bottleneck_file:  
147.             bottleneck_file.write(bottleneck_string)  
148.     else:  
149.         # 讀取儲存的特征向量檔案  
150.         with open(bottleneck_path, 'r') as bottleneck_file:  
151.             bottleneck_string = bottleneck_file.read()  
152.         # 字元串轉float數組  
153.         bottleneck_values = [float(x) for x in bottleneck_string.split(',')]  
154.     return bottleneck_values  
155. # 随機擷取一個batch的圖檔作為訓練資料（特征向量，類别）  
156. def get_random_cached_bottlenecks(sess, n_classes, image_lists, how_many, category, jpeg_data_tensor,  
157.                                   bottleneck_tensor):  
158.     """ 
159.     :param sess: 
160.     :param n_classes: 類别數量 
161.     :param image_lists: 
162.     :param how_many: 一個batch的數量 
163.     :param category: 所屬的資料集 
164.     :param jpeg_data_tensor: 
165.     :param bottleneck_tensor: 
166.     :return: 特征向量清單，類别清單 
167.     """  
168.     bottlenecks = []  
169.     ground_truths = []  
170.     for _ in range(how_many):  
171.         # 随機一個類别和圖檔編号加入目前的訓練資料  
172.         label_index = random.randrange(n_classes)  
173.         label_name = list(image_lists.keys())[label_index]  # 随機圖檔的類别名  
174.         image_index = random.randrange(65536)  # 随機圖檔的編号  
175.         bottleneck = get_or_create_bottleneck(sess, image_lists, label_name, image_index, category, jpeg_data_tensor,  
176.                                               bottleneck_tensor)  # 計算此圖檔的特征向量  
177.         ground_truth = np.zeros(n_classes, dtype=np.float32)  
178.         ground_truth[label_index] = 1.0  
179.         bottlenecks.append(bottleneck)  
180.         ground_truths.append(ground_truth)  
181.     return bottlenecks, ground_truths  
182. # 擷取全部的測試資料  
183. def get_test_bottlenecks(sess, image_lists, n_classes, jpeg_data_tensor, bottleneck_tensor):  
184.     bottlenecks = []  
185.     ground_truths = []  
186.     label_name_list = list(image_lists.keys())  # ['dandelion', 'daisy', 'sunflowers', 'roses', 'tulips']  
187.     for label_index, label_name in enumerate(label_name_list):  # 枚舉每個類别,如:0 sunflowers  
188.         category = 'testing'  
189.         for index, unused_base_name in enumerate(image_lists[label_name][category]):  # 枚舉此類别中的測試資料集中的每張圖檔  
190.             ''''' 
191.             print(index, unused_base_name) 
192.             0 10386503264_e05387e1f7_m.jpg 
193.             1 1419608016_707b887337_n.jpg 
194.             2 14244410747_22691ece4a_n.jpg 
195.             ... 
196.             105 9467543719_c4800becbb_m.jpg 
197.             106 9595857626_979c45e5bf_n.jpg 
198.             107 9922116524_ab4a2533fe_n.jpg 
199.             '''  
200.             bottleneck = get_or_create_bottleneck(  
201.                 sess, image_lists, label_name, index, category, jpeg_data_tensor, bottleneck_tensor)  
202.             ground_truth = np.zeros(n_classes, dtype=np.float32)  
203.             ground_truth[label_index] = 1.0  
204.             bottlenecks.append(bottleneck)  
205.             ground_truths.append(ground_truth)  
206.     return bottlenecks, ground_truths  
207. def main(_):  
208.     image_lists = create_image_lists(TEST_PERCENTACE, VALIDATION_PERCENTAGE)  
209.     n_classes = len(image_lists.keys())  
210.     # 讀取模型  
211.     with gfile.FastGFile(os.path.join(MODEL_DIR, MODEL_FILE), 'rb') as f:  
212.         graph_def = tf.GraphDef()  
213.         graph_def.ParseFromString(f.read())  
214.     # 加載模型，傳回對應名稱的張量  
215.     bottleneck_tensor, jpeg_data_tensor = tf.import_graph_def(graph_def, return_elements=[BOTTLENECK_TENSOR_NAME,  
216.                                                                                           JPEG_DATA_TENSOR_NAME])  
217.     # 輸入  
218.     bottleneck_input = tf.placeholder(tf.float32, [None, BOTTLENECK_TENSOR_SIZE], name='BottleneckInputPlaceholder')  
219.     ground_truth_input = tf.placeholder(tf.float32, [None, n_classes], name='GroundTruthInput')  
220.     # 全連接配接層  
221.     with tf.name_scope('final_training_ops'):  
222.         weights = tf.Variable(tf.truncated_normal([BOTTLENECK_TENSOR_SIZE, n_classes], stddev=0.001))  
223.         biases = tf.Variable(tf.zeros([n_classes]))  
224.         logits = tf.matmul(bottleneck_input, weights) + biases  
225.         final_tensor = tf.nn.softmax(logits)  
226.     # 損失  
227.     cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=ground_truth_input)  
228.     cross_entropy_mean = tf.reduce_mean(cross_entropy)  
229.     # 優化  
230.     train_step = tf.train.GradientDescentOptimizer(LEARNING_RATE).minimize(cross_entropy_mean)  
231.     # 正确率  
232.     with tf.name_scope('evaluation'):  
233.         correct_prediction = tf.equal(tf.argmax(final_tensor, 1), tf.argmax(ground_truth_input, 1))  
234.         evaluation_step = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))  
235.     with tf.Session() as sess:  
236.         # 初始化參數  
237.         init = tf.global_variables_initializer()  
238.         sess.run(init)  
239.         for i in range(STEPS):  
240.             # 每次擷取一個batch的訓練資料  
241.             train_bottlenecks, train_ground_truth = get_random_cached_bottlenecks(sess, n_classes, image_lists, BATCH,  
242.                                                                                   'training', jpeg_data_tensor,  
243.                                                                                   bottleneck_tensor)  
244.             # 訓練  
245.             sess.run(train_step,  
246.                      feed_dict={bottleneck_input: train_bottlenecks, ground_truth_input: train_ground_truth})  
247.             # 驗證  
248.             if i % 100 == 0 or i + 1 == STEPS:  
249.                 validation_bottlenecks, validation_ground_truth = get_random_cached_bottlenecks(sess, n_classes,  
250.                                                                                                 image_lists, BATCH,  
251.                                                                                                 'validation',  
252.                                                                                                 jpeg_data_tensor,  
253.                                                                                                 bottleneck_tensor)  
254.                 validation_accuracy = sess.run(evaluation_step, feed_dict={bottleneck_input: validation_bottlenecks,  
255.                                                                            ground_truth_input: validation_ground_truth})  
256.                 print('Step %d: Validation accuracy on random sampled %d examples = %.1f%%' % (  
257.                     i, BATCH, validation_accuracy * 100))  
258.         # 測試  
259.         test_bottlenecks, test_ground_truth = get_test_bottlenecks(sess, image_lists, n_classes, jpeg_data_tensor,  
260.                                                                    bottleneck_tensor)  
261.         test_accuracy = sess.run(evaluation_step,  
262.                                  feed_dict={bottleneck_input: test_bottlenecks, ground_truth_input: test_ground_truth})  
263.         print('Final test accuracy = %.1f%%' % (test_accuracy * 100))  
264. if __name__ == '__main__':  
265.     tf.app.run()  
266. ''''' 
267. Step 0: Validation accuracy on random sampled 100 examples = 40.0% 
268. Step 100: Validation accuracy on random sampled 100 examples = 81.0% 
269. Step 200: Validation accuracy on random sampled 100 examples = 79.0% 
270. Step 300: Validation accuracy on random sampled 100 examples = 92.0% 
271. Step 400: Validation accuracy on random sampled 100 examples = 90.0% 
272. Step 500: Validation accuracy on random sampled 100 examples = 88.0% 
273. Step 600: Validation accuracy on random sampled 100 examples = 89.0% 
274. Step 700: Validation accuracy on random sampled 100 examples = 94.0% 
275. Step 800: Validation accuracy on random sampled 100 examples = 91.0% 
276. Step 900: Validation accuracy on random sampled 100 examples = 88.0% 
277. Step 1000: Validation accuracy on random sampled 100 examples = 84.0% 
278. Step 1100: Validation accuracy on random sampled 100 examples = 92.0% 
279. Step 1200: Validation accuracy on random sampled 100 examples = 86.0% 
280. Step 1300: Validation accuracy on random sampled 100 examples = 91.0% 
281. Step 1400: Validation accuracy on random sampled 100 examples = 96.0% 
282. Step 1500: Validation accuracy on random sampled 100 examples = 89.0% 
283. Step 1600: Validation accuracy on random sampled 100 examples = 94.0% 
284. Step 1700: Validation accuracy on random sampled 100 examples = 90.0% 
285. Step 1800: Validation accuracy on random sampled 100 examples = 94.0% 
286. Step 1900: Validation accuracy on random sampled 100 examples = 94.0% 
287. Step 2000: Validation accuracy on random sampled 100 examples = 94.0% 
288. Step 2100: Validation accuracy on random sampled 100 examples = 93.0% 
289. Step 2200: Validation accuracy on random sampled 100 examples = 92.0% 
290. Step 2300: Validation accuracy on random sampled 100 examples = 96.0% 
291. Step 2400: Validation accuracy on random sampled 100 examples = 92.0% 
292. Step 2500: Validation accuracy on random sampled 100 examples = 92.0% 
293. Step 2600: Validation accuracy on random sampled 100 examples = 93.0% 
294. Step 2700: Validation accuracy on random sampled 100 examples = 90.0% 
295. Step 2800: Validation accuracy on random sampled 100 examples = 92.0% 
296. Step 2900: Validation accuracy on random sampled 100 examples = 91.0% 
297. Step 3000: Validation accuracy on random sampled 100 examples = 96.0% 
298. Step 3100: Validation accuracy on random sampled 100 examples = 90.0% 
299. Step 3200: Validation accuracy on random sampled 100 examples = 94.0% 
300. Step 3300: Validation accuracy on random sampled 100 examples = 97.0% 
301. Step 3400: Validation accuracy on random sampled 100 examples = 95.0% 
302. Step 3500: Validation accuracy on random sampled 100 examples = 92.0% 
303. Step 3600: Validation accuracy on random sampled 100 examples = 94.0% 
304. Step 3700: Validation accuracy on random sampled 100 examples = 94.0% 
305. Step 3800: Validation accuracy on random sampled 100 examples = 95.0% 
306. Step 3900: Validation accuracy on random sampled 100 examples = 95.0% 
307. Step 3999: Validation accuracy on random sampled 100 examples = 94.0% 
308. Final test accuracy = 95.4% 
309. '''  

将一個3´3卷積拆成1´3卷積和3´1卷積

一是引入了 Factorization into small convolutions 的思想，将一個較大的二維卷積拆成兩個較小的一維卷積，比如将7´7卷積拆成1´7卷積和7´1卷積，或者将3´3卷積拆成1´3卷積和3´1卷積，如上圖所示。一方面節約了大量參數，加速運算并減輕了過拟合（比将7´7卷積拆成1´7卷積和7´1卷積，比拆成3個3´3卷積更節約參數），同時增加了一層非線性擴充模型表達能力。論文中指出，這種非對稱的卷積結構拆分，其結果比對稱地拆為幾個相同的小卷積核效果更明顯，可以處理更多、更豐富的空間特征，增加特征多樣性。

另一方面，Inception V3 優化了 Inception Module 的結構，現在 Inception Module 有35´35、17´17和8´8三種不同結構。這些 Inception Module 隻在網絡的後部出現，前部還是普通的卷積層。并且 Inception V3 除了在 Inception Module 中使用分支，還在分支中使用了分支（8´8的結構中），可以說是Network In Network In Network。最終取得 top-5 錯誤率 3.5%。