深刻淺出卷積神經網絡及實現！

時間 2021-04-07

標籤算法數組網絡架構 app 框架 dom ide 函數性能欄目系統網絡简体版

原文原文鏈接

卷積神經網絡CNN是深度學習中的基礎知識。本文對CNN的基礎原理及常見的CNN網絡進行了詳細解讀，並介紹了Pytorch構建深度網絡的流程。最後，以阿里天池零基礎入門CV賽事爲學習實踐，對Pytorch構建CNN模型進行實現。

數據及背景

https://tianchi.aliyun.com/competition/entrance/531795/introduction（阿里天池 - 零基礎入門CV賽事）

CNN原理

CNN，又稱卷積神經網絡，是深度學習中重要的一個分支。CNN在不少領域都表現優異，精度和速度比傳統計算學習算法高不少。特別是在計算機視覺領域，CNN是解決圖像分類、圖像檢索、物體檢測和語義分割的主流模型。算法

1. 卷積

如圖1所示，圖中的X和O不管怎麼旋轉或者縮放，人眼其實仍是很容易識別出X和O。數組

圖1
網絡

可是計算機不一樣，它看到的實際上是一個個的像素陣列，如圖2。如何對像素的陣列進行特徵的提取其實就是卷積神經網絡要乾的事情。架構

圖2app

再看圖3，咱們發現X即便進行了旋轉，可是綠、橙、紫框標記的區域在兩張圖中仍是一致的，某種程度上，這其實就是X的特徵。框架

圖3dom

所以能夠將這三個特徵的區間提取出來，就造成了三個卷積核，如圖4所示。ide

圖4函數

既然有了卷積核，那麼卷積核是如何進行卷積操做的呢？其實很簡單，能夠看一下圖5，卷積核其實就是拿着這個矩陣在圖片的矩陣上一點點的平移，就像掃地同樣。每掃到一處地方就能夠進行卷積的運算，計算方法很簡單，如圖5所示，左上角的卷積核掃到綠色框的位置，則卷積核矩陣的數字就和掃到的位置的矩陣的數字一一對應相乘而後相加，最後取一個均值，該值就是卷積核提取的特徵。性能

圖5

卷積核提取的全部的特徵組成了一個長和寬變小的矩陣，這個矩陣又稱爲feature map，如圖6。使用不一樣的卷積核也就能提取出不一樣的feature map。因此能夠想象的是，若是不斷的進行卷積操做，那麼圖片的矩陣會逐步地長寬減小，厚度增長。

圖6

能夠看到卷積操做經過卷積核是能夠分別提取到圖片的特徵的，可是如何提早知道卷積核呢？像上文的例子，很容易能夠找到3個卷積核，可是假如是人臉識別這樣成千上萬個特徵的圖片，就沒辦法提早知道什麼是合適的卷積核。其實也不必知道，由於選擇什麼樣的卷積核，徹底能夠經過訓練不斷優化。初始時只須要隨機設置一些卷積核，經過訓練，模型其實本身能夠學習到合適的卷積核，這也是卷積神經網絡模型強大的地方。

2. 池化（pooling）

池化，也叫下采樣，本質上其實就是對數據進行一個縮小。由於咱們知道，好比人臉識別，經過卷積操做獲得成千上萬個feature map，每一個feature map也有不少的像素點，這些對於後續的運算的時間會變得很長。

池化其實就是對每一個feature map進一步提煉的過程。如圖7所示，原來4X4的feature map通過池化操做以後就變成了更小的2*2的矩陣。池化的方法包括max pooling，即取最大值，以及average pooling，即取平均值。

圖7

3. Normalization

這裏的Normalization就是將矩陣中負數的值轉成0,也就是使用一個稱之爲ReLu的激活函數進行負數變爲0的操做。ReLu函數本質上就是max（0，x）。這一步其實也是爲了方便運算。

4. 卷積神經網絡理解

所以卷積、ReLu、pooling，不斷重複其實也就基本上構成了卷積神經網絡的框架，如圖8。而後將最終獲得的feaure map 排成一列（圖8），接到全鏈接層，這樣就造成了咱們的卷積神經網絡。值得注意的是，排成一列的數值，是有權重，而這些權重是經過訓練、反向傳播獲得的，經過權重的計算，能夠知道不一樣分類的機率是怎麼樣的。

圖8

卷積神經網絡

卷積神經網絡基礎：LeNet5手寫字體識別模型LeNet5誕生於1994年，是最先的卷積神經網絡之一。LeNet5經過巧妙的設計，利用卷積、參數共享、池化等操做提取特徵，避免了大量的計算成本，最後再使用全鏈接神經網絡進行分類識別，這個網絡也是最近大量神經網絡架構的起點。

以下圖所示爲LeNet網絡結構，總共有7層網絡（不含輸入層），2個卷積層、2個池化層、3個全鏈接層。

LeNet分爲卷積層塊和全鏈接層塊兩個部分。下面咱們分別介紹這兩個模塊。卷積層塊裏的基本單位是卷積層後接最大池化層：卷積層用來識別圖像裏的空間模式，如線條和物體局部，以後的最大池化層則用來下降卷積層對位置的敏感性。卷積層塊由兩個這樣的基本單位重複堆疊構成。在卷積層塊中，每一個卷積層都使用5*5的窗口，並在輸出上使用sigmoid激活函數。第一個卷積層輸出通道數爲6，第二個卷積層輸出通道數則增長到16。這是由於第二個卷積層比第一個卷積層的輸入的高和寬要小，因此增長輸出通道使兩個卷積層的參數尺寸相似。卷積層塊的兩個最大池化層的窗口形狀均爲2*2，且步幅爲2。因爲池化窗口與步幅形狀相同，池化窗口在輸入上每次滑動所覆蓋的區域互不重疊。卷積層塊的輸出形狀爲(批量大小, 通道, 高, 寬)。當卷積層塊的輸出傳入全鏈接層塊時，全鏈接層塊會將小批量中每一個樣本變平（flatten）。也就是說，全鏈接層的輸入形狀將變成二維，其中第一維是小批量中的樣本，第二維是每一個樣本變平後的向量表示，且向量長度爲通道、高和寬的乘積。全鏈接層塊含3個全鏈接層。它們的輸出個數分別是120、84和10，其中10爲輸出的類別個數。

在卷積層塊中輸入的高和寬在逐層減少。卷積層因爲使用高和寬均爲5的卷積核，從而將高和寬分別減少4，而池化層則將高和寬減半，但通道數則從1增長到16。全鏈接層則逐層減小輸出個數，直到變成圖像的類別數10。

經過屢次卷積和池化，CNN的最後一層將輸入的圖像像素映射爲具體的輸出。如在分類任務中會轉換爲不一樣類別的機率輸出，而後計算真實標籤與CNN模型的預測結果的差別，並經過反向傳播更新每層的參數，並在更新完成後再次前向傳播，如此反覆直到訓練完成。

一個數字識別的效果如圖所示：

卷積神經網絡進階

隨着網絡結構的發展，研究人員最初發現網絡模型結構越深、網絡參數越多模型的精度更優。比較典型的是AlexNet、VGG、InceptionV3和ResNet的發展脈絡。

1. AlexNet(2012)

2012年，AlexNet橫空出世。這個模型的名字來源於論文第一做者的姓名Alex Krizhevsky。AlexNet使用了8層卷積神經網絡，並以很大的優點贏得了ImageNet 2012圖像識別挑戰賽。它首次證實了學習到的特徵能夠超越手工設計的特徵，從而一舉打破計算機視覺研究的前狀。

AlexNet與LeNet的設計理念很是類似，但也有顯著的區別。

1. 與相對較小的LeNet相比，AlexNet包含8層變換，其中有5層卷積和2層全鏈接隱藏層，以及1個全鏈接輸出層。下面咱們來詳細描述這些層的設計：AlexNet第一層中的卷積窗口形狀是11*11。由於ImageNet中絕大多數圖像的高和寬均比MNIST圖像的高和寬大10倍以上，ImageNet圖像的物體佔用更多的像素，因此須要更大的卷積窗口來捕獲物體。第二層中的卷積窗口形狀減少到5*5，以後全採用3*3。此外，第1、第二和第五個卷積層以後都使用了窗口形狀爲3*三、步幅爲2的最大池化層。並且，AlexNet使用的卷積通道數也大於LeNet中的卷積通道數數十倍。緊接着最後一個卷積層的是兩個輸出個數爲4096的全鏈接層。這兩個巨大的全鏈接層帶來將近1 GB的模型參數。因爲早期顯存的限制，最先的AlexNet使用雙數據流的設計使一個GPU只須要處理一半模型。幸運的是，顯存在過去幾年獲得了長足的發展，所以一般咱們再也不須要這樣的特別設計了。2. AlexNet將sigmoid激活函數改爲了更加簡單的ReLU激活函數。一方面，ReLU激活函數的計算更簡單，例如它並無sigmoid激活函數中的求冪運算。另外一方面，ReLU激活函數在不一樣的參數初始化方法下使模型更容易訓練。這是因爲當sigmoid激活函數輸出極接近0或1時，這些區域的梯度幾乎爲0，從而形成反向傳播沒法繼續更新部分模型參數；而ReLU激活函數在正區間的梯度恆爲1。所以，若模型參數初始化不當，sigmoid函數可能在正區間獲得幾乎爲0的梯度，從而令模型沒法獲得有效訓練。3. AlexNet經過丟棄法來控制全鏈接層的模型複雜度。而LeNet並無使用丟棄法。4. AlexNet引入了大量的圖像增廣，如翻轉、裁剪和顏色變化，從而進一步擴大數據集來緩解過擬合。咱們將在後面的圖像增廣中詳細介紹這種方法。

小結：

AlexNet跟LeNet結構相似，但使用了更多的卷積層和更大的參數空間來擬合大規模數據集ImageNet。它是淺層神經網絡和深度神經網絡的分界線。
雖然看上去AlexNet的實現比LeNet的實現也就多了幾行代碼而已，但這個觀念上的轉變和真正優秀實驗結果的產生令學術界付出了不少年。

2. VGG-16(2014)

AlexNet在LeNet的基礎上增長了3個卷積層。但AlexNet做者對它們的卷積窗口、輸出通道數和構造順序均作了大量的調整。雖然AlexNet指明瞭深度卷積神經網絡能夠取得出色的結果，但並無提供簡單的規則以指導後來的研究者如何設計新的網絡。VGG，它的名字來源於論文做者所在的實驗室Visual Geometry Group。VGG提出了能夠經過重複使用簡單的基礎塊來構建深度模型的思路。VGG的結構圖以下：

VGG塊的組成規律是：連續使用數個相同的填充爲一、窗口形狀爲3*3的卷積層後接上一個步幅爲二、窗口形狀爲2*2的最大池化層。卷積層保持輸入的高和寬不變，而池化層則對其減半。咱們使用vgg_block函數來實現這個基礎的VGG塊，它能夠指定卷積層的數量和輸入輸出通道數。

對於給定的感覺野（與輸出有關的輸入圖片的局部大小），採用堆積的小卷積核優於採用大的卷積核，由於能夠增長網絡深度來保證學習更復雜的模式，並且代價還比較小（參數更少）。例如，在VGG中，使用了3個3x3卷積核來代替7x7卷積核，使用了2個3x3卷積核來代替5*5卷積核，這樣作的主要目的是在保證具備相同感知野的條件下，提高了網絡的深度，在必定程度上提高了神經網絡的效果。

與AlexNet和LeNet同樣，VGG網絡由卷積層模塊後接全鏈接層模塊構成。卷積層模塊串聯數個vgg_block，其超參數由變量conv_arch定義。該變量指定了每一個VGG塊裏卷積層個數和輸入輸出通道數。全鏈接模塊則跟AlexNet中的同樣。如今咱們構造一個VGG網絡。它有5個卷積塊，前2塊使用單卷積層，然後3塊使用雙卷積層。第一塊的輸入輸出通道分別是1（由於下面要使用的Fashion-MNIST數據的通道數爲1）和64，以後每次對輸出通道數翻倍，直到變爲512。由於這個網絡使用了8個卷積層和3個全鏈接層，因此常常被稱爲VGG-11。能夠看到，每次咱們將輸入的高和寬減半，直到最終高和寬變成7後傳入全鏈接層。與此同時，輸出通道數每次翻倍，直到變成512。由於每一個卷積層的窗口大小同樣，因此每層的模型參數尺寸和計算複雜度與輸入高、輸入寬、輸入通道數和輸出通道數的乘積成正比。VGG這種高和寬減半以及通道翻倍的設計使得多數卷積層都有相同的模型參數尺寸和計算複雜度。

VGG：經過重複使⽤簡單的基礎塊來構建深度模型。 Block: 數個相同的填充爲一、窗口形狀爲3×3的卷積層,接上一個步幅爲二、窗口形狀爲2×2的最大池化層。卷積層保持輸入的高和寬不變，而池化層則對其減半。VGG和AlexNet的網絡圖對好比下：

小結：VGG-11經過5個能夠重複使用的卷積塊來構造網絡。根據每塊裏卷積層個數和輸出通道數的不一樣能夠定義出不一樣的VGG模型。

3. 網絡中的網絡（NiN）

LeNet、AlexNet和VGG：先以由卷積層構成的模塊充分抽取空間特徵，再以由全鏈接層構成的模塊來輸出分類結果。NiN：串聯多個由卷積層和「全鏈接」層構成的小⽹絡來構建⼀個深層⽹絡。⽤了輸出通道數等於標籤類別數的NiN塊，而後使⽤全局平均池化層對每一個通道中全部元素求平均並直接用於分類。

1×1卷積核做用

放縮通道數：經過控制卷積核的數量達到通道數的放縮；
增長非線性。1×1卷積核的卷積過程至關於全鏈接層的計算過程，而且還加入了非線性激活函數，從而能夠增長網絡的非線性；
計算參數少。

NiN塊咱們知道，卷積層的輸入和輸出一般是四維數組（樣本，通道，高，寬），而全鏈接層的輸入和輸出則一般是二維數組（樣本，特徵）。若是想在全鏈接層後再接上卷積層，則須要將全鏈接層的輸出變換爲四維。回憶在多輸入通道和多輸出通道里介紹的1*1卷積層。它能夠當作全鏈接層，其中空間維度（高和寬）上的每一個元素至關於樣本，通道至關於特徵。所以，NiN使用1*1卷積層來替代全鏈接層，從而使空間信息可以天然傳遞到後面的層中去。

NiN塊是NiN中的基礎塊。它由一個卷積層加兩個充當全鏈接層的1*1卷積層串聯而成。其中第一個卷積層的超參數能夠自行設置，而第二和第三個卷積層的超參數通常是固定的。NiN是在AlexNet問世不久後提出的。它們的卷積層設定有相似之處。NiN使用卷積窗口形狀分別爲11*十一、5*5和的3*3卷積層，相應的輸出通道數也與AlexNet中的一致。每一個NiN塊後接一個步幅爲二、窗口形狀爲3*3的最大池化層。除使用NiN塊之外，NiN還有一個設計與AlexNet顯著不一樣：NiN去掉了AlexNet最後的3個全鏈接層，取而代之地，NiN使用了輸出通道數等於標籤類別數的NiN塊，而後使用全局平均池化層對每一個通道中全部元素求平均並直接用於分類。這裏的全局平均池化層即窗口形狀等於輸入空間維形狀的平均池化層。NiN的這個設計的好處是能夠顯著減少模型參數尺寸，從而緩解過擬合。然而，該設計有時會形成得到有效模型的訓練時間的增長。

小結:

NiN重複使用由卷積層和代替全鏈接層的1*1卷積層構成的NiN塊來構建深層網絡。
NiN去除了容易形成過擬合的全鏈接輸出層，而是將其替換成輸出通道數等於標籤類別數的NiN塊和全局平均池化層。
NiN的以上設計思想影響了後面一系列卷積神經網絡的設計。

4. 含並行連結的網絡（GoogLeNet）

在2014年的ImageNet圖像識別挑戰賽中，一個名叫GoogLeNet的網絡結構大放異彩。它雖然在名字上向LeNet致敬，但在網絡結構上已經很難看到LeNet的影子。GoogLeNet吸取了NiN中網絡串聯網絡的思想，並在此基礎上作了很大改進。在隨後的幾年裏，研究人員對GoogLeNet進行了數次改進，本節將介紹這個模型系列的第一個版本。

由Inception基礎塊組成。
Inception塊至關於⼀個有4條線路的⼦⽹絡。它經過不一樣窗口形狀的卷積層和最⼤池化層來並⾏抽取信息，並使⽤1×1卷積層減小通道數從而下降模型複雜度。
能夠⾃定義的超參數是每一個層的輸出通道數，咱們以此來控制模型複雜度。

Inception塊GoogLeNet中的基礎卷積塊叫做Inception塊，得名於同名電影《盜夢空間》（Inception）。與上一節介紹的NiN塊相比，這個基礎塊在結構上更加複雜。Inception塊裏有4條並行的線路。前3條線路使用窗口大小分別是1*一、3*3和5*5的卷積層來抽取不一樣空間尺寸下的信息，其中中間2個線路會對輸入先作1*1卷積來減小輸入通道數，以下降模型複雜度。第四條線路則使用3*3最大池化層，後接1*1卷積層來改變通道數。4條線路都使用了合適的填充來使輸入與輸出的高和寬一致。最後咱們將每條線路的輸出在通道維上連結，並輸入接下來的層中去。Inception塊中能夠自定義的超參數是每一個層的輸出通道數，咱們以此來控制模型複雜度。GoogLeNet跟VGG同樣，在主體卷積部分中使用5個模塊（block），每一個模塊之間使用步幅爲2的3*3最大池化層來減少輸出高寬。第一模塊使用一個64通道的7*7卷積層。第二模塊使用2個卷積層：首先是64通道的1*1卷積層，而後是將通道增大3倍的3*3卷積層。它對應Inception塊中的第二條線路。第三模塊串聯2個完整的Inception塊。第一個Inception塊的輸出通道數爲64+128+32+32=256，其中4條線路的輸出通道數比例爲64:128:32:32=2:4:1:1。其中第2、第三條線路先分別將輸入通道數減少至96/192=1/2和16/192=1/12後，再接上第二層卷積層。第二個Inception塊輸出通道數增至128+192+96+64=480，每條線路的輸出通道數之比爲128:192:96:64 = 4:6:3:2。其中第2、第三條線路先分別將輸入通道數減少至128/256=1/2和32/256=1/8。第四模塊更加複雜。它串聯了5個Inception塊，其輸出通道數分別是192+208+48+64=5十二、160+224+64+64=5十二、128+256+64+64=5十二、112+288+64+64=528和256+320+128+128=832。這些線路的通道數分配和第三模塊中的相似，首先含3*3卷積層的第二條線路輸出最多通道，其次是僅含1*1卷積層的第一條線路，以後是含5*5卷積層的第三條線路和含1*1最大池化層的第四條線路。其中第2、第三條線路都會先按比例減少通道數。這些比例在各個Inception塊中都略有不一樣。第五模塊有輸出通道數爲256+320+128+128=832和384+384+128+128=1024的兩個Inception塊。其中每條線路的通道數的分配思路和第3、第四模塊中的一致，只是在具體數值上有所不一樣。須要注意的是，第五模塊的後面緊跟輸出層，該模塊同NiN同樣使用全局平均池化層來將每一個通道的高和寬變成1。最後咱們將輸出變成二維數組後接上一個輸出個數爲標籤類別數的全鏈接層。GoogLeNet模型的計算複雜，並且不如VGG那樣便於修改通道數。

小結:

Inception塊至關於一個有4條線路的子網絡。它經過不一樣窗口形狀的卷積層和最大池化層來並行抽取信息，並使用1*1卷積層減小通道數從而下降模型複雜度。
GoogLeNet將多個設計精細的Inception塊和其餘層串聯起來。其中Inception塊的通道數分配之比是在ImageNet數據集上經過大量的實驗得來的。
GoogLeNet和它的後繼者們一度是ImageNet上最高效的模型之一：在相似的測試精度下，它們的計算複雜度每每更低。

五、殘差網絡（ResNet-50）

深度學習的問題：深度CNN網絡達到必定深度後再一味地增長層數並不能帶來進一步地分類性能提升，反而會招致網絡收斂變得更慢，準確率也變得更差。- - -殘差塊（Residual Block）恆等映射：

左邊：f(x)=x；
右邊：f(x)-x=0 （易於捕捉恆等映射的細微波動）。

ResNet沿用了VGG全3*3卷積層的設計。殘差塊裏首先有2個有相同輸出通道數的3*3卷積層。每一個卷積層後接一個批量歸一化層和ReLU激活函數。而後咱們將輸入跳過這兩個卷積運算後直接加在最後的ReLU激活函數前。這樣的設計要求兩個卷積層的輸出與輸入形狀同樣，從而能夠相加。若是想改變通道數，就須要引入一個額外的1*1卷積層來將輸入變換成須要的形狀後再作相加運算。在殘差塊中，輸⼊可經過跨層的數據線路更快地向前傳播。

ResNet的前兩層跟以前介紹的GoogLeNet中的同樣：在輸出通道數爲6四、步幅爲2的7*7卷積層後接步幅爲2的3*3的最大池化層。不一樣之處在於ResNet每一個卷積層後增長的批量歸一化層。ResNet-50網絡結構以下：

GoogLeNet在後面接了4個由Inception塊組成的模塊。ResNet則使用4個由殘差塊組成的模塊，每一個模塊使用若干個一樣輸出通道數的殘差塊。第一個模塊的通道數同輸入通道數一致。因爲以前已經使用了步幅爲2的最大池化層，因此無須減少高和寬。以後的每一個模塊在第一個殘差塊裏將上一個模塊的通道數翻倍，並將高和寬減半。

小結：

殘差塊經過跨層的數據通道從而可以訓練出有效的深度神經網絡。
ResNet深入影響了後來的深度神經網絡的設計。

Pytorch構建模型

import torchtorch.manual_seed(0)torch.backends.cudnn.deterministic= Falsetorch.backends.cudnn.benchmark = Trueimport torchvision.models as modelsimport torchvision.transforms as transformsimport torchvision.datasets as datasetsimport torch.nn as nnimport torch.nn.functional as Fimport torch.optim as optimfrom torch.autograd import Variablefrom torch.utils.data.dataset import Dataset

1. pytorch經常使用網絡

1.1 Linear介紹 [全鏈接層]

nn.Linear(input_feature,out_feature,bias=True)

1.2 卷積介紹 [2D卷積層]

nn.Conv2d(in_channels,out_channels,kernel_size,stride=1,padding=0,dilation=1,groups,bias=True,padding_mode='zeros')
##kernel_size,stride,padding 均可以是元組## dilation 爲在卷積核中插入的數量

1.3 轉置卷積介紹 [2D反捲積層]

nn.ConvTranspose2d(in_channels,out_channels,kernel_size,stride=1,padding=0,out_padding=0,groups=1,bias=True,dilation=1,padding_mode='zeros')
##padding是輸入填充，out_padding填充到輸出

1.4 最大值池化層 [2D池化層]

nn.MaxPool2d(kernel_size,stride=None,padding=0,dilation=1)

1.5 批量歸一化層 [2D歸一化層]

nn.BatchNorm2d(num_features,eps,momentum,affine=True,track_running_stats=True)
affine=True 表示批量歸一化的α，β是被學到的track_running_stats=True 表示對數據的統計特徵進行關注

2. pytorch 建立模型的四種方法

假設建立卷積層–》Relu層–》池化層–》全鏈接層–》Relu層–》全鏈接層

# 導入包import torchimport torch.nn.functional as Ffrom collections import OrderedDict

2.1.自定義型[定義在init，前向過程在forward]

class Net1(torch.nn.Module):    def __init__(self):      super(Net1, self).__init__()      self.conv1 = torch.nn.Conv2d(3, 32, 3, 1, 1)      self.dense1 = torch.nn.Linear(32 * 3 * 3, 128)      self.dense2 = torch.nn.Linear(128, 10)
    def forward(self, x):      x = F.max_pool2d(F.relu(self.conv(x)), 2)      x = x.view(x.size(0), -1)      x = F.relu(self.dense1(x))      x = self.dense2(x)    return x

2.2 序列集成型[利用nn.Squential(順序執行的層函數)]

訪問各層只能經過數字索引

class Net2(torch.nn.Module):    def __init__(self):        super(Net2, self).__init__()        self.conv = torch.nn.Sequential(        torch.nn.Conv2d(3, 32, 3, 1, 1),        torch.nn.ReLU(),        torch.nn.MaxPool2d(2))        self.dense = torch.nn.Sequential(        torch.nn.Linear(32 * 3 * 3, 128),        torch.nn.ReLU(),        torch.nn.Linear(128, 10)        )
    def forward(self, x):        conv_out = self.conv(x)        res = conv_out.view(conv_out.size(0), -1)        out = self.dense(res)        return out

2.3 序列添加型[利用Squential類add_module順序逐層添加]

給予各層的name屬性

class Net3(torch.nn.Module):    def __init__(self):        super(Net3, self).__init__()        self.conv=torch.nn.Sequential()        self.conv.add_module("conv1",torch.nn.Conv2d(3, 32, 3, 1, 1))        self.conv.add_module("relu1",torch.nn.ReLU())        self.conv.add_module("pool1",torch.nn.MaxPool2d(2))        self.dense = torch.nn.Sequential()        self.dense.add_module("dense1",torch.nn.Linear(32 * 3 * 3, 128))        self.dense.add_module("relu2",torch.nn.ReLU())        self.dense.add_module("dense2",torch.nn.Linear(128, 10))
    def forward(self, x):        conv_out = self.conv(x)        res = conv_out.view(conv_out.size(0), -1)        out = self.dense(res)        return out

2.4 序列集成字典型[OrderDict集成模型字典【‘name’:層函數】]

name爲key

lass Net4(torch.nn.Module):    def __init__(self):        super(Net4, self).__init__()        self.conv = torch.nn.Sequential(        OrderedDict(        [        ("conv1", torch.nn.Conv2d(3, 32, 3, 1, 1)),        ("relu1", torch.nn.ReLU()),        ("pool", torch.nn.MaxPool2d(2))        ]        ))
        self.dense = torch.nn.Sequential(        OrderedDict([        ("dense1", torch.nn.Linear(32 * 3 * 3, 128)),        ("relu2", torch.nn.ReLU()),        ("dense2", torch.nn.Linear(128, 10))        ])        )
    def forward(self, x):        conv_out = self.conv1(x)        res = conv_out.view(conv_out.size(0), -1)        out = self.dense(res)        return out

3. pytorch 對模型參數的訪問，初始化，共享

3.1 訪問參數

訪問層

若是採用序列集成型,序列添加型或者字典集成性，都只能使用id索引訪問層。eg:net[1]；
若是想以網絡的name訪問，eg:net.layer_name。

訪問參數【權重參數名：層名_weight/bias】

layer.params----訪問該層參數字典；
layer.weight , layer.bias-----訪問該層權重和偏置；
layer.weight.data()/grad() ------訪問該層權重的具體數值/梯度【bias也使用】；
net.collect_params() ----返回該網絡的全部參數，返回一個由參數名稱到實例的字典。

3.2 初始化[若非首次初始化，force_reinit=True]

常規初始化【網絡初始化】

init 利用各類分佈初始化

net.initialize(init=init.Normal(sigma=0.1)，force_reinit=True)

init 對網絡參數進行常數初始化

net.initialize(init=init.Constant(1))

特定參數初始化

(某參數).initialize(init=init.Xavier(),force_reinit=True)

自定義初始化

繼承init的Initialize類，並實現函數_init_weight(self,name,data)

def _init_weight(self, name, data):    print('Init', name, data.shape)    data[:] = nd.random.uniform(low=-10, high=10, shape=data.shape)    # 表示一半概率爲0，一半概率爲[-10,-5]U[5，10]的均勻分佈    data *= data.abs() >= 5# 調用自定義初始化函數1net.initialize(MyInit(), force_reinit=True)

3.3 參數共享

參數共享，梯度共享，可是梯度計算的是全部共享層的和
梯度共享，且梯度只更新一次

net = nn.Sequential()shared = nn.Dense(8, activation='relu')net.add(nn.Dense(8, activation='relu'),        shared,        nn.Dense(8, activation='relu', params=shared.params),        nn.Dense(10))net.initialize()
X = nd.random.uniform(shape=(2, 20))net(X)
net[1].weight.data()[0] == net[2].weight.data()[0]

pytorch在SVHN網絡構建實戰

構建網絡模型：繼承nn.Module函數的__init__ 函數，重定義前向傳播函數forward
構造優化器
構造損失函數
訓練肯定幾個epoch【若運用數據增廣，隨機增廣epoch次達到多樣性】
對每一個batch損失函數後向傳播，優化器更新參數

optimizer.zero_grad() 清空梯度

loss.backward()

optimizer.step()

4.1 普通自建網絡

class SVHN_model(nn.Module):  def __init__(self):    super(SVHN_model,self).__init__()    self.cnn = nn.Squential(          nn.Conv2d(3,16,kernel_size=(3,3),stride=(2,2)),   #3X64X128--> 16X31X63          nn.Relu(),          nn.MaxPool2d(2), #16X31X63--> 16X15X31          nn.Conv2d(16,32,kernel_size=(3,3),stride=(2,2)),#16X15X31--> 32X7X15          nn.Relu(),          nn.MaxPool2d(2) #32X7X15--> 32X3X7    )    # 並行五次字符預測    self.fc1 = nn.Linear(32*3*7,11)    self.fc2 = nn.Linear(32*3*7,11)    self.fc3 = nn.Linear(32*3*7,11)    self.fc4 = nn.Linear(32*3*7,11)    self.fc5 = nn.Linear(32*3*7,11)
  def forward(self,x):    cnn_result = self.cnn(x)    cnn_result = cnn_result.view(cnn_result.shape[0],-1)    f1 = fc1(cnn_result)    f2 = fc2(cnn_result)    f3 = fc3(cnn_result)    f4 = fc4(cnn_result)    f5 = fc5(cnn_result)    return f1,f2,f3,f4,f5

4.2 利用resnet預訓練模型

class SVHN_resnet_Model(nn.Module):  def __init__(self):    super(SVHN_resnet_Model,self).__init__()    resnet_conv = models.resnet18(pretrain=True)    resnet_conv.avgpool = nn.AdaptiveAvgPool2d(1)    resnet_conv = nn.Sequential(*list(resnet_conv.children()[:-1]))    self.cnn = model_conv    self.fc1 = nn.Linear(512,11)    self.fc2 = nn.Linear(512,11)    self.fc3 = nn.Linear(512,11)    self.fc4 = nn.Linear(512,11)    self.fc5 = nn.Linear(512,11)
  def forward(self):    cnn_result = cnn(x)    cnn_result.view(cnn_result.shape[0],-1)    f1 = fc1(cnn_result)    f2 = fc2(cnn_result)    f3 = fc3(cnn_result)    f4 = fc4(cnn_result)    f5 = fc5(cnn_result)    return f1,f2,f3,f4,f5