介紹

隨著越來越多的高效體系結構出現在世界各地的研究論文中，深度學習體系結構正在迅速發展。這些研究論文不僅包含了大量的信息，而且為新的深度學習體系結構的誕生提供了一條新的途徑，它們通常難以解析。為了理解這些論文，人們可能需要多次閱讀那篇論文，甚至可能需要閱讀其他相關論文。Inception 就是其中之一。

Inception 網絡是 CNN 圖像分類器發展過程中的一個重要里程碑。在此架構之前，大多數流行的 CNN 或分類器只是使用越來越深的堆疊卷積層以獲得更好的性能。

另一方面，Inception 網絡經過精心設計，非常深入和復雜。它使用了許多不同的技術來推動其性能；無論是速度還是準確性。

什么是Inception？

Inception Network（ResNet）是Christian Szegedy、Wei Liu、Yangqing Jia介紹的著名深度學習模型之一。Pierre Sermanet、Scott Reed、Dragomir Anguelov、Dumitru Erhan、Vincent Vanhoucke 和 Andrew Rabinovich在 2014 年的論文“Going deeper with convolutions” ［1］中。

后來演化出了不同版本的 Inception 網絡。這是 Sergey Ioffe、Christian Szegedy、Jonathon Shlens、Vincent Vanhouck 和 Zbigniew Wojna在 2015 年題為“Rethinking the Inception Architecture for Computer Vision” ［2］ 的論文中提出的。Inception模型被歸類為最受歡迎和最常用的深度學習模型之一。

設計原則

–少數通用設計原則和優化技術的提議被證明對有效地擴展卷積網絡很有用。

–在網絡體系結構的早期，避免代表性瓶頸。

–如果網絡具有更多不同的過濾器，這些過濾器將具有更多不同的特征圖，則網絡將學習得更快。

–降維的空間聚合可以在低維嵌入上完成，而不會損失太多表示能力。

–通過寬度和深度之間的平衡，可以實現網絡的最佳性能。

初始模塊

初始模塊（naive）

資料來源：＇Going Deeper with Convolution ＇ 論文

最優局部稀疏結構的近似

處理各種尺度的視覺／空間信息，然后聚合

從計算上看，這有點樂觀

5×5 卷積非常花費開銷

Inception 模塊（降維）

來源：＇Going Deeper with Convolution＇ 論文

降維是必要和有動力的（網絡中的網絡）

通過 1×1 卷積實現

深入思考學習池化，而不是高度／寬度的最大／平均池化。

初始架構

使用降維的inception模塊，構建了深度神經網絡架構（Inception v1）。架構如下圖所示：

Inception 網絡線性堆疊了 9 個這樣的 Inception 模塊。它有 22 層深（如果包括池化層，則為 27 層）。在最后一個 inception 模塊的最后，它使用了全局平均池化。

對于降維和修正線性激活，使用了 128 個濾波器的 1×1 卷積。

具有 1024 個單元的全連接層的修正線性激活。

使用 dropout 層丟棄輸出的比例為 70％。

使用線性層作為分類器的 softmax 損失。

Inception 網絡的流行版本如下：

Inception v1

Inception v2

Inception v3

Inception v4

Inception－ResNet

讓我們從頭開始構建 Inception v1（GoogLeNet）：

Inception 架構多次使用 CNN 塊和 1×1、3×3、5×5 等不同的過濾器，所以讓我們為 CNN 塊創建一個類，它采用輸入通道和輸出通道以及 batchnorm2d 和 ReLu 激活．

class conv＿block（nn．Module）：
   def ＿＿init＿＿（self， in＿channels， out＿channels， ＊＊kwargs）：
       super（conv＿block， self）．＿＿init＿＿（）
       self．relu ＝ nn．ReLU（）
       self．conv ＝ nn．Conv2d（in＿channels， out＿channels， ＊＊kwargs）
       self．batchnorm ＝ nn．BatchNorm2d（out＿channels）
  def forward（self， x）：
      return self．relu（self．batchnorm（self．conv（x）））

然后為inception module創建一個降維的類，參考上圖，從1×1 filter輸出，reduction 3×3，然后從3×3 filter輸出，reduction 5×5，然后從5×5輸出 和 1×1 池中輸出。

class Inception＿block（nn．Module）：
   def ＿＿init＿＿（
       self， in＿channels， out＿1x1， red＿3x3， out＿3x3， red＿5x5， out＿5x5， out＿1x1pool
   ）：
       super（Inception＿block， self）．＿＿init＿＿（）
       self．branch1 ＝ conv＿block（in＿channels， out＿1x1， kernel＿size＝（1， 1））
self．branch2 ＝ nn．Sequential（
conv＿block（in＿channels， red＿3x3， kernel＿size＝（1， 1）），
conv＿block（red＿3x3， out＿3x3， kernel＿size＝（3， 3）， padding＝（1， 1）），
）
self．branch3 ＝ nn．Sequential（
conv＿block（in＿channels， red＿5x5， kernel＿size＝（1， 1）），
conv＿block（red＿5x5， out＿5x5， kernel＿size＝（5， 5）， padding＝（2， 2）），
）
self．branch4 ＝ nn．Sequential（
nn．MaxPool2d（kernel＿size＝（3， 3）， stride＝（1， 1）， padding＝（1， 1）），
conv＿block（in＿channels， out＿1x1pool， kernel＿size＝（1， 1）），
）
def forward（self， x）：
return torch．cat（
［self．branch1（x）， self．branch2（x）， self．branch3（x）， self．branch4（x）］， 1
）

讓我們保留下圖作為參考并開始構建網絡。

來源：＇Going Deeper with Convolution＇ 論文

創建一個類作為 GoogLeNet

class GoogLeNet（nn．Module）：
   def ＿＿init＿＿（self， aux＿logits＝True， num＿classes＝1000）：
       super（GoogLeNet， self）．＿＿init＿＿（）
       assert aux＿logits ＝＝ True or aux＿logits ＝＝ False
       self．aux＿logits ＝ aux＿logits
＃ Write in＿channels， etc， all explicit in self．conv1， rest will write to
＃ make everything as compact as possible， kernel＿size＝3 instead of （3，3）
self．conv1 ＝ conv＿block（
in＿channels＝3，
out＿channels＝64，
kernel＿size＝（7， 7），
stride＝（2， 2），
padding＝（3， 3），
）
self．maxpool1 ＝ nn．MaxPool2d（kernel＿size＝3， stride＝2， padding＝1）
self．conv2 ＝ conv＿block（64， 192， kernel＿size＝3， stride＝1， padding＝1）
self．maxpool2 ＝ nn．MaxPool2d（kernel＿size＝3， stride＝2， padding＝1）
＃ In this order： in＿channels， out＿1x1， red＿3x3， out＿3x3， red＿5x5， out＿5x5， out＿1x1pool
self．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， 3）， stride＝2， padding＝1）
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， 160， 320， 32， 128， 128）
self．maxpool4 ＝ nn．MaxPool2d（kernel＿size＝3， stride＝2， padding＝1）
self．inception5a ＝ Inception＿block（832， 256， 160， 320， 32， 128， 128）
self．inception5b ＝ Inception＿block（832， 384， 192， 384， 48， 128， 128）
self．avgpool ＝ nn．AvgPool2d（kernel＿size＝7， stride＝1）
self．dropout ＝ nn．Dropout（p＝0．4）
self．fc1 ＝ nn．Linear（1024， num＿classes）
if self．aux＿logits：
self．aux1 ＝ InceptionAux（512， num＿classes）
self．aux2 ＝ InceptionAux（528， num＿classes）
else：
self．aux1 ＝ self．aux2 ＝ None
def forward（self， x）：
x ＝ self．conv1（x）
x ＝ self．maxpool1（x）
x ＝ self．conv2（x）
＃ x ＝ self．conv3（x）
x ＝ self．maxpool2（x）
x ＝ self．inception3a（x）
x ＝ self．inception3b（x）
x ＝ self．maxpool3（x）
x ＝ self．inception4a（x）
＃ Auxiliary Softmax classifier 1
if self．aux＿logits and self．training：
aux1 ＝ self．aux1（x）
x ＝ self．inception4b（x）
x ＝ self．inception4c（x）
x ＝ self．inception4d（x）
＃ Auxiliary Softmax classifier 2
if self．aux＿logits and self．training：
aux2 ＝ self．aux2（x）
x ＝ self．inception4e（x）
x ＝ self．maxpool4（x）
x ＝ self．inception5a（x）
x ＝ self．inception5b（x）
x ＝ self．avgpool（x）
x ＝ x．reshape（x．shape［0］， －1）
x ＝ self．dropout（x）
x ＝ self．fc1（x）
if self．aux＿logits and self．training：
return aux1， aux2， x
else：
return x

然后為輸出層定義一個類，如論文中提到的 dropout＝0．7 和一個帶有 softmax 的線性層來輸出 n＿classes。

class InceptionAux（nn．Module）：
   def ＿＿init＿＿（self， in＿channels， num＿classes）：
       super（InceptionAux， self）．＿＿init＿＿（）
       self．relu ＝ nn．ReLU（）
       self．dropout ＝ nn．Dropout（p＝0．7）
       self．pool ＝ nn．AvgPool2d（kernel＿size＝5， stride＝3）
       self．conv ＝ conv＿block（in＿channels， 128， kernel＿size＝1）
       self．fc1 ＝ nn．Linear（2048， 1024）
       self．fc2 ＝ nn．Linear（1024， num＿classes）

   def forward（self， x）：
       x ＝ self．pool（x）
       x ＝ self．conv（x）
       x ＝ x．reshape（x．shape［0］， －1）
       x ＝ self．relu（self．fc1（x））
       x ＝ self．dropout（x）
       x ＝ self．fc2（x）
       return x

然后程序應該如下所示對齊。

– Class GoogLeNet

– Class Inception＿block

– Class InceptionAux

– Class conv＿block

然后最后讓我們寫一小段測試代碼來檢查我們的模型是否工作正常。

if ＿＿name＿＿ ＝＝ ＂＿＿main＿＿＂：
   ＃ N ＝ 3 （Mini batch size）
   x ＝ torch．randn（3， 3， 224， 224）
   model ＝ GoogLeNet（aux＿logits＝True， num＿classes＝1000）
   print（model（x）［2］．shape）

輸出應如下所示