在深度學習的領域，最前沿、最先進的架構被稱為state-of-the-art models，簡寫為SOTA，我將其翻譯為“前沿網絡”。每個學者都希望自己論文中的模型是SOTA model，也有不少人聲稱自己的工作成功達到了SOTA level，甚至為了達到SOTA level對數據進行一些微妙的操作，但真正能夠進入人們的視野、并被廣泛認可為優質架構的架構其實只是鳳毛麟角。我們之前提到的VGG可以算是準SOTA level的架構，也是所有接近或達到SOTA level的架構中唯一一個只使用普通卷積層的架構，可以說是將思路的簡潔性發揮到了極致。當然，簡單的思路也導致VGG的參數量過于巨大，在VGG誕生的同時，學者們本著“網絡更深、參數更少”的基本思路，創造了眾多優質架構和模型，我們將在本節中仔細介紹他們。

1 GoogLeNet（Inception V1）

1.1 動機與思路

VGG非常優秀，但它在ILSVRC上拿到的最高名次是亞軍，在VGG登場的2014年，力壓群雄拿到冠軍的是在ImageNet數據集上達到6.7%錯誤率的GoogLeNet。GoogLeNet由谷歌團隊與眾多大學合作研發，發表于論文《Going deeper with convolutions》，整篇論文語言精練簡單，從標題到內容都彰顯著谷歌團隊加深卷積網絡結構的決心，讀起來非常有趣。受到NiN網絡的啟發，谷歌引入了一種全新的網絡架構：Inception block，并將使用Inception V1的網絡架構稱為GoogLeNet（雖然從名字上來看致敬了LeNet5算法，但GoogLeNet已經基本看不出LeNet那種經典的卷積+池化+全連接的結構了）。

Inception直譯是“起始時間”，也是電影《盜夢空間》的英文名稱。或許谷歌團隊是無心插柳，但Inception塊的出現成為了深度視覺發展歷史上的一個新的起點。從2014年的競賽結果來看，Inception V1的效果只比VGG19好一點點（只比VGG降低了0.6%的錯誤率），兩個架構在深度上也沒有差太多，但在之后的研究中，Inception展現出比VGG強大許多的潛力——不僅需要的參數量少很多，架構可以達到的上限也更高。隨著架構的迭代更新，Inception V3和V4已經是典型的SOTA模型，可以在ImageNet數據集上達到3%的錯誤率，但VGG在ILSVRC上的表現基本就是模型的極限了。
接下來，讓我們來認識一下GoogLeNet和Inception V1。GoogLeNet在設計之初就采用了一種與傳統CNN完全不同的構建思路。自從LeNet5定下了卷積、池化、線性層串聯的基本基調，研究者們在相當長的一段時間內都在這條道路上探索，最終抵達的終點就是VGG。VGG找出了能夠最大程度加大模型深度、增強模型學習能力的架構，并且利用巧妙的參數設計讓特征圖的尺寸得以控制，但VGG以及其他串聯架構的缺點也是顯而易見的，最關鍵的（甚至有些老生常談的）一點就是參數過多，各層之間的鏈接過于“稠密”（Dense），計算量過大，并且很容易過擬合。為了解決這個問題，我們之前已經提出了多種方法，其中最主流的是：

1、使用我們在上一節中提出的分組卷積、舍棄全連接層等用來消減參數量的操作，讓神經元與神經元之間、或特征圖與特征圖之間的連接數變少，從而讓網絡整體變得“稀疏”

2、引入隨機的稀疏性。例如，使用類似于Dropout的方式來隨機地讓特征矩陣或權重矩陣中的部分數據為0

3、引入GPU進行計算

在2014年之前，以上操作就是我們目前為止接觸的所有架構在減少參數量、防止過擬合上做出的努力。其中NiN主要使用方法1，AlexNet和VGG主要使用方法2和3，但這些方法其實都存在一定的問題：

首先，分組卷積等操作雖然能夠有效減少參數量，卻也會讓架構的學習水平變得不穩定。在神經網絡由稠密變得稀疏（Sparse）的過程中，網絡的學習能力會波動甚至會下降，并且網絡的稀疏性與學習能力之間的下降關系是不明確的，即我們無法精確控制稀疏的程度來把握網絡的學習能力，只能靠孜孜不倦的嘗試來測試學習能力較強的架構。

其次，隨機的稀疏性與GPU計算之間其實是存在巨大矛盾的。現代硬件不擅長處理在隨機或非均勻稀疏的數據上的計算，并且這種不擅長在矩陣計算上表現得尤其明顯。這與現代硬件查找、緩存的具體流程有關，當數據表現含有不均勻的稀疏性時（即數據中0的分布不太均勻時），即便實際需要的計算量是原來的1/100，也無法彌補數據查找(finds)和緩存缺失(cache misses)所帶來的時間延遲。簡單來說，GPU擅長的是簡單大量的計算操作，不同計算之間的相似性越高，GPU的計算性能就越能發揮出來，這種“相似性”表現在數據的分布相似（例如，都是偏態分布）、計算方式相似（例如，都是先相乘再相加）等方方面面。卷積操作本來就是一種涉及到大量矩陣運算的計算方式，當隨機的稀疏性被放入權重矩陣或特征矩陣當中，每次計算時的數據分布都會迥然不同，這會嚴重拉長權重或特征相關計算所需要的時間。

相對的，稠密的連接卻可以以更快的速度被計算。這并不是說稀疏的網絡整體計算時間會更長，而是說在相同參數量/連接數下，稠密的結構比稀疏的結構計算更快。

此時就需要權衡了——稠密結構的學習能力更強，但會因為參數量過于巨大而難以訓練。稀疏結構的參數量少，但是學習能力會變得不穩定，并且不能很好地利用現有計算資源。在2013年的時候，按分布讓權重為0的Dropout剛剛誕生（2012年發表論文），在每層輸出之后調整數據分布的Batch Normlization還沒有誕生（2015年發表論文），創造VGG架構的團隊選擇了傳統道路，即在學習能力更強的稠密架構上增加Dropout，但GoogLeNet團隊的思路是：使用普通卷積、池化層這些稠密元素組成的塊去無限逼近（approximate）一個稀疏架構，從而構造一種參數量與稀疏網絡相似的稠密網絡。這種思路的核心不是通過減少連接、減少掃描次數等“制造空隙”的方式來降低稠密網絡的參數量，而是直接在架構設計上找出一種參數量非常少的稠密網絡。

在數學中，我們常常使用稀疏的方式去逼近稠密的結構（這種操作叫做稀疏估計 sparse
approximation），但反過來用稠密結構去近似稀疏架構的情況卻幾乎沒有，因此能否真正實現這種“逼近”是不得而知的，不過這種奇思妙想正是谷歌作為一個科技公司能夠持續繁榮的根基之一。在GoogLeNet的論文中，作者們表示，在拓撲學中，幾何圖形或空間在連續改變形狀后還能保持性狀不變，這說明不同的結構可以提供相似的屬性。同時，也有論文表示，稀疏數據可以被聚類成攜帶高度相似信息的密集數據來加速硬件計算，考慮到神經元和特征圖的本質其實都是數據的組合，那稀疏的神經元應該也可以被聚類成攜帶高度相似信息的密集神經元，如果神經元可以被聚類，那這很可能說明稀疏架構在一定程度上應該可以被稠密架構所替代。雖然從數學上很難證明這種替代是否真的能“嚴格等價”，但從直覺上來說是可以說得通的。不得不說，比起之前誕生的傳統網絡，GoogLeNet的這個思路切入點是在大氣層。

基于這樣的基本理念，GoogLeNet團隊使用了一個復雜的網絡架構構造算法，并讓算法向著“使用稠密成分逼近稀疏架構”的方向進行訓練，產出了數個可能有效的密集架構。在進行了大量的實驗后，他們選出了學習能力最強的密集架構及其相關參數，這個架構就是Inception塊和GoogLeNet。鑒于Inception塊誕生的過程，我們很難以個人身份對GoogLeNet進行“改變卷積核尺寸”或“改變輸出特征圖數量”這個層面的調參。基于架構構造算法以及大量的實驗，其架構的精妙程度已經遠遠超出個人可以對卷積神經網絡做的任何操作，因此也不再需要更多的調參了。

1.2 InceptionV1

我們來看Inception V1的具體結構。與之前VGG和AlexNet中從上向下串聯卷積層的方式不同，Inception塊使用了卷積層、池化層并聯的方式。在一個Inception塊中存在4條線路，每條線路可以被叫做一個分枝（branch）：第一條線路上只有一個1x1卷積層，只負責降低通道數；第二條路線由一個1x1卷積層和一個3x3卷積層組成，本質上是希望使用3x3卷積核進行特征提取，但先使用1x1卷積核降低通道數以此來降低參數量和計算量（降低模型的復雜度）；第三條線路由一個1x1卷積層和一個5x5卷積層組成，其基本思路與第二條線路一致；最后一條線路由一個3x3池化層和一個1x1卷積層組成，將池化也當做一種特征提取的方式，并在池化后使用1x1卷積層來降低通道數。不難注意到，所有的線路都使用了巧妙的參數組合，讓特征圖的尺寸保持不變，因此在四條線路分別輸出結果之后，Inception塊將四種方式生成的特征圖拼接在一起，形成一組完整的特征圖，這組完整的特征圖與普通卷積生成的特征圖在結構、計算方式上并無區別，因此可以被輕松地輸入任意卷積、池化或全連接的結構。在論文中，GoogLeNet自然是使用了224x224的ImageNet數據集，不過在下面的架構圖中我們使用了尺寸較小的特征圖進行表示。
雖然我們不知道谷歌使用的網絡架構構造算法具體是如何得出Inception架構的，但這種架構的優勢是顯而易見的：

首先，同時使用多種卷積核可以確保各種類型和層次的信息都被提取出來。在普通的卷積網絡中，我們必須選擇不同尺寸的過濾器（卷積核、池化核）對圖像進行特征提取。1x1卷積核可以最大程度提取像素與像素之間的位置信息，尺寸較大的卷積核則更多可以提取相鄰像素之間的聯系信息，最大池化層則可以提取出局部中最關鍵的信息，但在串聯結構中，對同一張圖片/特征圖，我們只能選擇一個過濾器來使用，這意味著我們很可能會損失其他過濾器可以提取出的信息。而在Inception中，我們一次性使用了全部可能的方式，因此無需再去考慮究竟哪一種提取方式才是最好的，在輸出的時候，Inception將所有核提取出來的特征圖堆積整合，確保提取出的信息是最全面的。

其次，并聯的卷積池化層計算效率更高。串聯的卷積計算必須一層一層進行，但并聯的卷積/池化層可以同時進行計算，這種將特征提取的過程并行處理的方式可以極速加快計算的運行效率。同時，由于每個元素之間都是稠密連接，并不存在任何類似于分組卷積那樣減少連接數量的操作，使得inception可以高效利用現有硬件在稠密矩陣上的計算性能。

大量使用1x1卷積層來整合信息，既實現了“聚類信息”又實現了大規模降低參數量，讓特征圖數量實現了前所未有的增長。出現在每一條線路的1x1卷積層承擔了調整特征圖數目的作用，它可以自由將特征圖上的信息聚合為更少的特征圖，讓特征圖信息之間的聚合更加“密集”。同時，每個1x1卷積核之后都跟著ReLU激活函數，這增加了一次使用非線性方式處理數據的機會，某種程度上也是增加了網絡的“深度”。除此之外，1x1卷積層最重要的作用是控制住了整體的參數量，從而解放了特征圖的數量。這一點可以從VGG和GoogLeNet整體架構的參數量上輕松看出來。

下面分別展示了VGG16的架構和GoogLeNet的完整架構。不難發現，在VGG中，當特征圖的尺寸是14x14，輸入特征圖數量是512，輸出特征圖數量也是512時，一個卷積層的參數量大約是230萬。而在GoogLeNet中，相同特征圖尺寸、相同輸入與輸出特征圖數量下的inception的參數量大約是45萬上下，普通卷積層的1/5還少。考慮到inception中使用了5x5卷積核，而VGG中一直都是3x3卷積核，這種參數差異是不可思議的。巨大的參數量讓VGG中可以使用的最大特征圖數量是512，但在GoogLeNet中這個數量卻達到了1024，并且還有數個輸出832個特征圖的inception塊。這些差異毫無疑問都是使用1x1卷積核帶來的。
（上圖，VGG16架構；下圖，GoogLeNet主體架構）

上圖是GoogLeNet的主體架構。Inception內部是稠密部件的并聯，而整個GoogLeNet則是數個Inception塊與傳統卷積結構的串聯。這張架構圖來自GoogLeNet的原始論文，其中patch_size就是過濾器的尺寸，3x3 reduce和5x5 reduce就是指inception塊中3x3和5x5卷積層之前的1x1卷積層的輸出量，pool proj中寫的數字實際上是池化層后的1x1卷積層的輸出量。與其他架構圖相似，雖然沒有被展示出來，但在每一個卷積層之后都有ReLU激活函數；同樣的，從輸出層的特征圖尺寸來看，應該有不少卷積層中都含有padding，但無論在論文或架構中都沒有被展示出來。當我們來查看GoogLeNet的架構圖時，可能很容易就注意到以下幾點：

1、在inception的前面有著幾個傳統的卷積層，并且第一個卷積層采用了和LeNet相似的處理方法：先利用較大的卷積核大幅消減特征圖的尺寸，當特征圖尺寸下降到28x28后再使用inception進行處理。如果將卷積+池化看做一個block（塊），那inception之前已有兩個blocks了，所以Inception的編號是從3開始。其中，block3、4、和5分別有2個、5個、2個Inception。

2、Inception中雖然已經包含池化層，但inception之后還是有用來讓特征圖尺寸減半的池化層，并且和VGG一樣，讓特征圖尺寸減半的池化層也是5個，最終將特征圖尺寸縮小為7x7。不難發現，在GoogLeNet的主體架構中，Inception實際上取代了傳統架構中卷積層的地位，不過inception中有2層卷積層，因此網絡總體有22層，比VGG19多了三層。

3、在架構的最后，使用了核尺寸為7x7的平均池化層。考慮到此時的特征圖尺寸已經是7x7，這個池化層實際上一個用來替代全連接層的全局平均池化層，這和NiN中的操作一樣。在全局平均池化層的最后，又跟上了一個線性層，用于輸出softmax的結果。如果將inception看做卷積層，那GoogLeNet的主體架構也不是標新立異的類型。不過，除了主體架構之外，GoogLeNet還使用了“輔助分類器”（auxiliary classifier）以提升模型的性能。輔助分類器是除了主體架構中的softmax分類器之外，另外存在的兩個分類器。在整體架構中，這兩個分類器的輸入分別是inception4a和inception4d的輸出結果，他們的結構如下：
將主體架構與輔助分類器結合，我們可以得到GoogLeNet的完整架構（見下圖，該架構同樣來自于原始論文，注意該架構下方是輸入，上方是輸出）。如果架構圖不足夠清晰，可以看附件中的單獨的圖片文件。

在谷歌團隊測試GoogLeNet網絡性能的實驗中，他們注意到稍微淺一些的GoogLeNet也有非常好的表現，因此他們認為位于中層的inception輸出的特征應該對分類結果至關重要，如果能夠在迭代中加重這些中層inception輸出的特征的權重，就可能將模型引導向更好的反向。因此，他們將位于中間的inceptions的結果使用輔助分類器導出，并讓兩個輔助分類器和最終的分類器一共輸出三個softmax結果、依次計算三個損失函數的值，并將三個損失加權平均得到最終的損失。如此，只要基于最終的損失進行反向傳播，就可以加重在訓練過程中中層inceptions輸出結果的權重了。這種思想有點類似于傳統機器學習算法中的“集成”思想，一個GoogLeNet實際上集成了兩個淺層網絡和一個深層網絡的結果來進行學習和判斷，在一個架構中間增加集成的思想，不得不說GoogLeNet的一大亮點。

值得一提的是，在論文的架構圖中包含了一種叫做局部響應歸一化（Local Response Normalization，LRN）的功能，這個功能最初是在AlexNet的架構中被使用，但我們從來沒有說明過它的細節。主要是因為LRN是一個飽受爭議、又對模型效果提升沒有太多作用的功能，現在已基本被BN所替代（使用BN的inception被稱為Inception V2）。同時，GoogLeNet的論文中也并沒有給出LRN的具體細節，因此現在實現GoogLeNet的各個深度學習框架也基本上不考慮LRN的存在了。相對的，我們把所有的LRN層刪掉后，在每個卷積層的后面加上了BN層，以確保更好的擬合效果。

1.3 GoogLeNet的復現

現在，我們來實現一下這個完整架構。GoogLeNet是我們遇見的第一個串聯元素中含有更多復雜成分的網絡，因此我們需要先單獨定義幾個單獨的元素，之后才能夠使用我們熟悉的建立類的方式來復現架構。首先，能夠在主體網絡中省略掉所有的激活函數，我們需要定義新的基礎卷積層。這個卷積層是包含激活函數以及BN層的卷積層。這樣定義能夠幫助我們大幅度減少最后在整合好的GoogLeNet中會出現的ReLU函數以及BN層。

import torch from torch import nn from torchinfo import summaryclass BasicConv2d(nn.Module):def __init__(self,in_channels, out_channels,**kwargs):super().__init__()self.conv = nn.Sequential(nn.Conv2d(in_channels, out_channels, bias=False, **kwargs),nn.BatchNorm2d(out_channels),nn.ReLU(inplace=True))def forward(self,x):x = self.conv(x)return x BasicConv2d(2,10,kernel_size=3) #BasicConv2d( # (conv): Sequential( # (0): Conv2d(2, 10, kernel_size=(3, 3), stride=(1, 1), bias=False) # (1): BatchNorm2d(10, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) # (2): ReLU(inplace=True) # ) #)

接下來，我們需要定義Inception塊。由于Inception塊中是并聯的結構，存在4個branchs，所以我們不能使用nn.Sequential進行打包，而是要使用原始的self.的形式。在Inception塊中，所有卷積、池化層的輸入、輸出以及核大小都需要我們進行輸入，因此我們可以使用原論文中架構圖上的英文作為參數的名稱，如此，在填寫架構中具體的數字時，我們只需要照著架構圖一行一行填就可以了。

class Inception(nn.Module):def __init__(self,in_channels : int,ch1x1 : int,ch3x3red : int,ch3x3 : int,ch5x5red : int,ch5x5 : int,pool_proj : int):super().__init__()#1x1self.branch1 = BasicConv2d(in_channels,ch1x1,kernel_size=1)#1x1 + 3x3self.branch2 = nn.Sequential(BasicConv2d(in_channels, ch3x3red, kernel_size=1),BasicConv2d(ch3x3red, ch3x3, kernel_size=3,padding=1))#1x1 + 5x5self.branch3 = nn.Sequential(BasicConv2d(in_channels, ch5x5red, kernel_size=1),BasicConv2d(ch5x5red, ch5x5, kernel_size=5, padding=2))#pool + 1x1self.branch4 = nn.Sequential(nn.MaxPool2d(kernel_size=3,stride=1, padding=1,ceil_mode=True),BasicConv2d(in_channels,pool_proj,kernel_size=1))def forward(self,x):branch1 = self.branch1(x) #28x28,ch1x1branch2 = self.branch2(x) #28x28,ch3x3branch3 = self.branch3(x) #28x28,ch5x5branch4 = self.branch4(x) #28x28,pool_projoutputs = [branch1, branch2, branch3, branch4]return torch.cat(outputs, 1) #合并 #測試 ''' in_channels : int ,ch1x1 : int ,ch3x3red : int ,ch3x3 : int ,ch5x5red : int ,ch5x5 : int ,pool_proj : int ''' in3a = Inception(192,64,96,128,16,32,32) data = torch.ones(10,192,28,28) in3a(data).shape #torch.Size([10, 256, 28, 28])

接下來，還需要單獨定義的是輔助分類器（Auxiliary Classifier）的類。輔助分類器的結構其實與我們之前所寫的傳統卷積網絡很相似，因此我們可以使用nn.Sequential來進行打包，并將分類器分成.features_和.clf_兩部分來進行構建：

class AuxClf(nn.Module):def __init__(self,in_channels : int, num_classes : int, **kwargs):super().__init__()self.feature_ = nn.Sequential(nn.AvgPool2d(kernel_size=5,stride=3),BasicConv2d(in_channels,128, kernel_size=1))self.clf_ = nn.Sequential(nn.Linear(4*4*128, 1024),nn.ReLU(inplace=True),nn.Dropout(0.7),nn.Linear(1024,num_classes))def forward(self,x):x = self.feature_(x)x = x.view(-1,4*4*128)x = self.clf_(x)return x #4a后的輔助分類器 AuxClf(512,1000) #AuxClf( # (feature_): Sequential( # (0): AvgPool2d(kernel_size=5, stride=3, padding=0) # (1): BasicConv2d( # (conv): Sequential( # (0): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False) # (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) # (2): ReLU(inplace=True) # ) # ) # ) # (clf_): Sequential( # (0): Linear(in_features=2048, out_features=1024, bias=True) # (1): ReLU(inplace=True) # (2): Dropout(p=0.7, inplace=False) # (3): Linear(in_features=1024, out_features=1000, bias=True) # ) #)

在定義好三個單獨的類后，我們再依據GoogLeNet的完整架構將所有內容實現。雖然GoogLeNet的主體結構是串聯，但由于存在輔助分類器，我們無法在使用nn.Sequential時單獨將輔助分類器的結果提取出來。如果按照輔助分類器存在的地方對架構進行劃分，又會導致架構整體在層次上與GoogLeNet的架構圖有較大的區別，因此我們最終還是使用了self.的形式。在我們自己使用GoogLeNet時，我們不一定總要使用輔助分類器。如果不使用輔助分類器，我們則可以使用nn.Sequential來打包整個代碼。包含輔助分類器的具體代碼如下：

#(224 + 6 - 7)/2 + 1 = 112.5 自動向下取整數 #pool (112 - 3)/2 + 1 = 55.5 向上取整（需要調節ceil_mode）之后得到56 class GoogLeNet(nn.Module):def __init__(self,num_classes: int = 1000, blocks = None):super().__init__()if blocks is None:blocks = [BasicConv2d, Inception, AuxClf]conv_block = blocks[0]inception_block = blocks[1]aux_clf_block = blocks[2]#block1self.conv1 = conv_block(3,64,kernel_size=7,stride=2,padding = 3)self.maxpool1 = nn.MaxPool2d(kernel_size=3,stride=2,ceil_mode = True)#block2self.conv2 = conv_block(64,64,kernel_size=1)self.conv3 = conv_block(64,192,kernel_size=3, padding = 1)self.maxpool2 = nn.MaxPool2d(kernel_size=3,stride=2,ceil_mode = True)#block3self.inception3a = inception_block(192,64,96,128,16,32,32)self.inception3b = inception_block(256,128,128,192,32,96,64)self.maxpool3 = nn.MaxPool2d(kernel_size=3,stride=2,ceil_mode = True)#block4 self.inception4a = inception_block(480,192,96,208,16,48,64)self.inception4b = inception_block(512,160,112,224,24,64,64)self.inception4c = inception_block(512,128,128,256,24,64,64)self.inception4d = inception_block(512,112,144,288,32,64,64)self.inception4e = inception_block(528,256,150,320,32,128,128)self.maxpool4 = nn.MaxPool2d(kernel_size=3,stride=2,ceil_mode = True)#block5self.inception5a = inception_block(832,256,160,320,32,128,128)self.inception5b = inception_block(832,384,192,384,48,128,128)#clfself.avgpool = nn.AdaptiveAvgPool2d((1,1)) #我需要的輸出的特征圖尺寸是多少self.dropout = nn.Dropout(0.4)self.fc = nn.Linear(1024,num_classes)#auxclfself.aux1 = aux_clf_block(512, num_classes) #4aself.aux2 = aux_clf_block(528, num_classes) #4ddef forward(self,x):#block1x = self.maxpool1(self.conv1(x))#block2x = self.maxpool2(self.conv3(self.conv2(x)))#block3x = self.inception3a(x)x = self.inception3b(x)x = self.maxpool3(x)#block4x = self.inception4a(x)aux1 = self.aux1(x)x = self.inception4b(x)x = self.inception4c(x)x = self.inception4d(x)aux2 = self.aux2(x)x = self.inception4e(x)x = self.maxpool4(x)#block5x = self.inception5a(x)x = self.inception5b(x)#clfx = self.avgpool(x) #在這個全局平均池化之后，特征圖尺寸就變成了1x1x = torch.flatten(x,1)x = self.dropout(x)x = self.fc(x)return x, aux2, aux1

運行不報錯，則說明我們的架構建立成功了。使用Summary查看最后的結果，可以看到一個長得不可思議的層次結構。這個層次結構中至少有三層，最內部的是普通卷積層構成的分枝branch，然后是inception塊，然后是inception塊和其他結構組成的blocks。在這種情況下，依賴于Summary來查看架構層次已經是不太可能的事兒了，因此我們可以使用summary函數自帶的參數depth來調整顯示層次的深度：

summary(net,(10,3,224,224),device="cpu",depth=1) #測試 data = torch.ones(10,3,224,224) net = GoogLeNet(num_classes=1000) fc2, fc1, fc0 = net(data) for i in [fc2, fc1, fc0]:print(i.shape) #torch.Size([10, 1000]) #torch.Size([10, 1000]) #torch.Size([10, 1000]) summary(net,(10,3,224,224),device="cpu",depth=1) #========================================================================================== #Layer (type:depth-idx) Output Shape Param # #========================================================================================== #├─BasicConv2d: 1-1 [10, 64, 112, 112] 9,536 #├─MaxPool2d: 1-2 [10, 64, 56, 56] -- #├─BasicConv2d: 1-3 [10, 64, 56, 56] 4,224 #├─BasicConv2d: 1-4 [10, 192, 56, 56] 110,976 #├─MaxPool2d: 1-5 [10, 192, 28, 28] -- #├─Inception: 1-6 [10, 256, 28, 28] 164,064 #├─Inception: 1-7 [10, 480, 28, 28] 389,376 #├─MaxPool2d: 1-8 [10, 480, 14, 14] -- #├─Inception: 1-9 [10, 512, 14, 14] 376,800 #├─AuxClf: 1-10 [10, 1000] 3,188,968 #├─Inception: 1-11 [10, 512, 14, 14] 449,808 #├─Inception: 1-12 [10, 512, 14, 14] 510,768 #├─Inception: 1-13 [10, 528, 14, 14] 606,080 #├─AuxClf: 1-14 [10, 1000] 3,191,016 #├─Inception: 1-15 [10, 832, 14, 14] 835,276 #├─MaxPool2d: 1-16 [10, 832, 7, 7] -- #├─Inception: 1-17 [10, 832, 7, 7] 1,044,480 #├─Inception: 1-18 [10, 1024, 7, 7] 1,445,344 #├─AdaptiveAvgPool2d: 1-19 [10, 1024, 1, 1] -- #├─Dropout: 1-20 [10, 1024] -- #├─Linear: 1-21 [10, 1000] 1,025,000 #========================================================================================== #Total params: 13,351,716 #Trainable params: 13,351,716 #Non-trainable params: 0 #Total mult-adds (G): 184.06 #========================================================================================== #Input size (MB): 6.02 #Forward/backward pass size (MB): 0.08 #Params size (MB): 53.41 #Estimated Total Size (MB): 59.51 #==========================================================================================

這樣架構就清晰多了。雖然架構復雜，但這個網絡實際只有22層卷積層，加上池化層只有27層，和幾百層的網絡們比起來不算什么。并且，GoogLeNet只有1300萬參數量（并且從summary的結果可以看出，其中700萬參數都是由分類器上的全連接層帶來的，如果不使用輔助分類器，則GoogLeNet的參數量大約只有600萬左右），而16層的VGG的參數量是1.3億，兩者參數相差超過10倍。從計算量來看，GoogLeNet也全面碾壓了VGG本身。如下圖所示，GoogLeNet所需的總計算量不足一個G，而VGG卻需要15個G。在2014年的ILSVRC上，GoogLeNet只以微小的優勢打敗了VGG19，但其計算效率以及在架構上帶來的革新是VGG19無法替代的。
（上圖為GoogLeNet參數量及計算量，下圖為VGG16參數量及計算量）

GoogLeNet的架構完美地展現了谷歌團隊在設計inception時所忠于的邏輯：使用密集的成分去接近稀疏的架構，不僅能夠像稀疏架構一樣參數很少，還能夠充分利用密集成分在現代硬件上的計算效率。在2014年之后，谷歌團隊數次改進了Inception塊和GoogLeNet整體的排布。今天，這一族最強大的是InceptionV3。在經過適當訓練之后，Inception V3可以在ImageNet2012年數據集上拿到4.2%的錯誤率，我們自己手寫的一個普通的V3模型也能夠在ImageNet數據集上拿到6.5%的錯誤率，是現在視覺屆僅次于深層殘差網絡（100層以上）的架構。

總結

以上是生活随笔為你收集整理的Lesson 16.1416.15 GoogLeNet：思想与具体框架GoogLeNet复现的全部內容，希望文章能夠幫你解決所遇到的問題。

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