各種網(wǎng)絡模型：來源《動手學深度學習》

一，卷積神經(jīng)網(wǎng)絡（LeNet）

LeNet分為卷積層塊和全連接層塊兩個部分。下面我們分別介紹這兩個模塊。

卷積層塊里的基本單位是卷積層后接最大池化層：卷積層用來識別圖像里的空間模式，如線條和物體局部，之后的最大池化層則用來降低卷積層對位置的敏感性。卷積層塊由兩個這樣的基本單位重復堆疊構(gòu)成。在卷積層塊中，每個卷積層都使用 5×5 的窗口，并在輸出上使用sigmoid激活函數(shù)。第一個卷積層輸出通道數(shù)為6，第二個卷積層輸出通道數(shù)則增加到16。這是因為第二個卷積層比第一個卷積層的輸入的高和寬要小，所以增加輸出通道使兩個卷積層的參數(shù)尺寸類似。卷積層塊的兩個最大池化層的窗口形狀均為 2×2 ，且步幅為2。由于池化窗口與步幅形狀相同，池化窗口在輸入上每次滑動所覆蓋的區(qū)域互不重疊。

卷積層塊的輸出形狀為(批量大小, 通道, 高, 寬)。當卷積層塊的輸出傳入全連接層塊時，全連接層塊會將小批量中每個樣本變平（flatten）。也就是說，全連接層的輸入形狀將變成二維，其中第一維是小批量中的樣本，第二維是每個樣本變平后的向量表示，且向量長度為通道、高和寬的乘積。全連接層塊含3個全連接層。它們的輸出個數(shù)分別是120、84和10，其中10為輸出的類別個數(shù)。

下面我們通過Sequential類來實現(xiàn)LeNet模型。

net = nn.Sequential() net.add(nn.Conv2D(channels=6, kernel_size=5, activation='sigmoid'),nn.MaxPool2D(pool_size=2, strides=2),nn.Conv2D(channels=16, kernel_size=5, activation='sigmoid'),nn.MaxPool2D(pool_size=2, strides=2),# Dense會默認將(批量大小, 通道, 高, 寬)形狀的輸入轉(zhuǎn)換成# (批量大小, 通道 * 高 * 寬)形狀的輸入nn.Dense(120, activation='sigmoid'),nn.Dense(84, activation='sigmoid'),nn.Dense(10))

二，深度卷積神經(jīng)網(wǎng)絡（AlexNet）

AlexNet與LeNet的設計理念非常相似，但也有顯著的區(qū)別。

第一，與相對較小的LeNet相比，AlexNet包含8層變換，其中有5層卷積和2層全連接隱藏層，以及1個全連接輸出層。下面我們來詳細描述這些層的設計。

AlexNet第一層中的卷積窗口形狀是 11×11 。因為ImageNet中絕大多數(shù)圖像的高和寬均比MNIST圖像的高和寬大10倍以上，ImageNet圖像的物體占用更多的像素，所以需要更大的卷積窗口來捕獲物體。第二層中的卷積窗口形狀減小到 5×5 ，之后全采用 3×3 。此外，第一、第二和第五個卷積層之后都使用了窗口形狀為 3×3 、步幅為2的最大池化層。而且，AlexNet使用的卷積通道數(shù)也大于LeNet中的卷積通道數(shù)數(shù)十倍。

緊接著最后一個卷積層的是兩個輸出個數(shù)為4,096的全連接層。這兩個巨大的全連接層帶來將近1 GB的模型參數(shù)。由于早期顯存的限制，最早的AlexNet使用雙數(shù)據(jù)流的設計使一塊GPU只需要處理一半模型。幸運的是，顯存在過去幾年得到了長足的發(fā)展，因此通常我們不再需要這樣的特別設計了。

第二，AlexNet將sigmoid激活函數(shù)改成了更加簡單的ReLU激活函數(shù)。一方面，ReLU激活函數(shù)的計算更簡單，例如它并沒有sigmoid激活函數(shù)中的求冪運算。另一方面，ReLU激活函數(shù)在不同的參數(shù)初始化方法下使模型更容易訓練。這是由于當sigmoid激活函數(shù)輸出極接近0或1時，這些區(qū)域的梯度幾乎為0，從而造成反向傳播無法繼續(xù)更新部分模型參數(shù)；而ReLU激活函數(shù)在正區(qū)間的梯度恒為1。因此，若模型參數(shù)初始化不當，sigmoid函數(shù)可能在正區(qū)間得到幾乎為0的梯度，從而令模型無法得到有效訓練。

第三，AlexNet通過丟棄法（參見“丟棄法”一節(jié)）來控制全連接層的模型復雜度。而LeNet并沒有使用丟棄法。

第四，AlexNet引入了大量的圖像增廣，如翻轉(zhuǎn)、裁剪和顏色變化，從而進一步擴大數(shù)據(jù)集來緩解過擬合。我們將在后面的“圖像增廣”一節(jié)詳細介紹這種方法。

下面我們實現(xiàn)稍微簡化過的AlexNet。

net = nn.Sequential() # 使用較大的11 x 11窗口來捕獲物體。同時使用步幅4來較大幅度減小輸出高和寬。這里使用的輸出通 # 道數(shù)比LeNet中的也要大很多 net.add(nn.Conv2D(96, kernel_size=11, strides=4, activation='relu'),nn.MaxPool2D(pool_size=3, strides=2),# 減小卷積窗口，使用填充為2來使得輸入與輸出的高和寬一致，且增大輸出通道數(shù)nn.Conv2D(256, kernel_size=5, padding=2, activation='relu'),nn.MaxPool2D(pool_size=3, strides=2),# 連續(xù)3個卷積層，且使用更小的卷積窗口。除了最后的卷積層外，進一步增大了輸出通道數(shù)。# 前兩個卷積層后不使用池化層來減小輸入的高和寬nn.Conv2D(384, kernel_size=3, padding=1, activation='relu'),nn.Conv2D(384, kernel_size=3, padding=1, activation='relu'),nn.Conv2D(256, kernel_size=3, padding=1, activation='relu'),nn.MaxPool2D(pool_size=3, strides=2),# 這里全連接層的輸出個數(shù)比LeNet中的大數(shù)倍。使用丟棄層來緩解過擬合nn.Dense(4096, activation="relu"), nn.Dropout(0.5),nn.Dense(4096, activation="relu"), nn.Dropout(0.5),# 輸出層。由于這里使用Fashion-MNIST，所以用類別數(shù)為10，而非論文中的1000nn.Dense(10))

三，使用重復元素的網(wǎng)絡（VGG）

VGG塊

VGG塊的組成規(guī)律是：連續(xù)使用數(shù)個相同的填充為1、窗口形狀為 3×3 的卷積層后接上一個步幅為2、窗口形狀為 2×2 的最大池化層。卷積層保持輸入的高和寬不變，而池化層則對其減半。我們使用vgg_block函數(shù)來實現(xiàn)這個基礎的VGG塊，它可以指定卷積層的數(shù)量num_convs和輸出通道數(shù)num_channels。

VGG網(wǎng)絡

與AlexNet和LeNet一樣，VGG網(wǎng)絡由卷積層模塊后接全連接層模塊構(gòu)成。卷積層模塊串聯(lián)數(shù)個vgg_block，其超參數(shù)由變量conv_arch定義。該變量指定了每個VGG塊里卷積層個數(shù)和輸出通道數(shù)。全連接模塊則與AlexNet中的一樣。

現(xiàn)在我們構(gòu)造一個VGG網(wǎng)絡。它有5個卷積塊，前2塊使用單卷積層，而后3塊使用雙卷積層。第一塊的輸出通道是64，之后每次對輸出通道數(shù)翻倍，直到變?yōu)?12。因為這個網(wǎng)絡使用了8個卷積層和3個全連接層，所以經(jīng)常被稱為VGG-11。

def vgg(conv_arch):net = nn.Sequential()# 卷積層部分for (num_convs, num_channels) in conv_arch:net.add(vgg_block(num_convs, num_channels))# 全連接層部分net.add(nn.Dense(4096, activation='relu'), nn.Dropout(0.5),nn.Dense(4096, activation='relu'), nn.Dropout(0.5),nn.Dense(10))return netnet = vgg(conv_arch)

四，網(wǎng)絡中的網(wǎng)絡（NiN）

NiN塊

NiN塊是NiN中的基礎塊。它由一個卷積層加兩個充當全連接層的 1×1 卷積層串聯(lián)而成。其中第一個卷積層的超參數(shù)可以自行設置，而第二和第三個卷積層的超參數(shù)一般是固定的。

def nin_block(num_channels, kernel_size, strides, padding):blk = nn.Sequential()blk.add(nn.Conv2D(num_channels, kernel_size,strides, padding, activation='relu'),nn.Conv2D(num_channels, kernel_size=1, activation='relu'),nn.Conv2D(num_channels, kernel_size=1, activation='relu'))return blk

NiN模型

NiN是在AlexNet問世不久后提出的。它們的卷積層設定有類似之處。NiN使用卷積窗口形狀分別為 11×11 、 5×5 和 3×3 的卷積層，相應的輸出通道數(shù)也與AlexNet中的一致。每個NiN塊后接一個步幅為2、窗口形狀為 3×3 的最大池化層。

除使用NiN塊以外，NiN還有一個設計與AlexNet顯著不同：NiN去掉了AlexNet最后的3個全連接層，取而代之地，NiN使用了輸出通道數(shù)等于標簽類別數(shù)的NiN塊，然后使用全局平均池化層對每個通道中所有元素求平均并直接用于分類。這里的全局平均池化層即窗口形狀等于輸入空間維形狀的平均池化層。NiN的這個設計的好處是可以顯著減小模型參數(shù)尺寸，從而緩解過擬合。然而，該設計有時會造成獲得有效模型的訓練時間的增加。

net = nn.Sequential() net.add(nin_block(96, kernel_size=11, strides=4, padding=0),nn.MaxPool2D(pool_size=3, strides=2),nin_block(256, kernel_size=5, strides=1, padding=2),nn.MaxPool2D(pool_size=3, strides=2),nin_block(384, kernel_size=3, strides=1, padding=1),nn.MaxPool2D(pool_size=3, strides=2), nn.Dropout(0.5),# 標簽類別數(shù)是10nin_block(10, kernel_size=3, strides=1, padding=1),# 全局平均池化層將窗口形狀自動設置成輸入的高和寬nn.GlobalAvgPool2D(),# 將四維的輸出轉(zhuǎn)成二維的輸出，其形狀為(批量大小, 10)nn.Flatten())

五，含并行連結(jié)的網(wǎng)絡（GoogLeNet）

Inception 塊

Inception塊里有4條并行的線路。前3條線路使用窗口大小分別是 1×1 、 3×3 和 5×5 的卷積層來抽取不同空間尺寸下的信息，其中中間2個線路會對輸入先做 1×1 卷積來減少輸入通道數(shù)，以降低模型復雜度。第四條線路則使用 3×3 最大池化層，后接 1×1 卷積層來改變通道數(shù)。4條線路都使用了合適的填充來使輸入與輸出的高和寬一致。最后我們將每條線路的輸出在通道維上連結(jié)，并輸入接下來的層中去。

Inception塊中可以自定義的超參數(shù)是每個層的輸出通道數(shù)，我們以此來控制模型復雜度。

class Inception(nn.Block):# c1 - c4為每條線路里的層的輸出通道數(shù)def __init__(self, c1, c2, c3, c4, **kwargs):super(Inception, self).__init__(**kwargs)# 線路1，單1 x 1卷積層self.p1_1 = nn.Conv2D(c1, kernel_size=1, activation='relu')# 線路2，1 x 1卷積層后接3 x 3卷積層self.p2_1 = nn.Conv2D(c2[0], kernel_size=1, activation='relu')self.p2_2 = nn.Conv2D(c2[1], kernel_size=3, padding=1,activation='relu')# 線路3，1 x 1卷積層后接5 x 5卷積層self.p3_1 = nn.Conv2D(c3[0], kernel_size=1, activation='relu')self.p3_2 = nn.Conv2D(c3[1], kernel_size=5, padding=2,activation='relu')# 線路4，3 x 3最大池化層后接1 x 1卷積層self.p4_1 = nn.MaxPool2D(pool_size=3, strides=1, padding=1)self.p4_2 = nn.Conv2D(c4, kernel_size=1, activation='relu')def forward(self, x):p1 = self.p1_1(x)p2 = self.p2_2(self.p2_1(x))p3 = self.p3_2(self.p3_1(x))p4 = self.p4_2(self.p4_1(x))return nd.concat(p1, p2, p3, p4, dim=1) # 在通道維上連結(jié)輸出

GoogLeNet模型

GoogLeNet跟VGG一樣，在主體卷積部分中使用5個模塊（block），每個模塊之間使用步幅為2的 3×3 最大池化層來減小輸出高寬。第一模塊使用一個64通道的 7×7 卷積層。

b1 = nn.Sequential() b1.add(nn.Conv2D(64, kernel_size=7, strides=2, padding=3, activation='relu'),nn.MaxPool2D(pool_size=3, strides=2, padding=1))

第二模塊使用2個卷積層：首先是64通道的 1×1 卷積層，然后是將通道增大3倍的 3×3 卷積層。它對應Inception塊中的第二條線路。

b2 = nn.Sequential() b2.add(nn.Conv2D(64, kernel_size=1, activation='relu'),nn.Conv2D(192, kernel_size=3, padding=1, activation='relu'),nn.MaxPool2D(pool_size=3, strides=2, padding=1))

第三模塊串聯(lián)2個完整的Inception塊。第一個Inception塊的輸出通道數(shù)為 64+128+32+32=256 ，其中4條線路的輸出通道數(shù)比例為 64:128:32:32=2:4:1:1 。其中第二、第三條線路先分別將輸入通道數(shù)減小至 96/192=1/2 和 16/192=1/12 后，再接上第二層卷積層。第二個Inception塊輸出通道數(shù)增至 128+192+96+64=480 ，每條線路的輸出通道數(shù)之比為 128:192:96:64=4:6:3:2 。其中第二、第三條線路先分別將輸入通道數(shù)減小至 128/256=1/2 和 32/256=1/8 。

b3 = nn.Sequential() b3.add(Inception(64, (96, 128), (16, 32), 32),Inception(128, (128, 192), (32, 96), 64),nn.MaxPool2D(pool_size=3, strides=2, padding=1))

第四模塊更加復雜。它串聯(lián)了5個Inception塊，其輸出通道數(shù)分別是 192+208+48+64=512 、 160+224+64+64=512 、 128+256+64+64=512 、 112+288+64+64=528 和 256+320+128+128=832 。這些線路的通道數(shù)分配和第三模塊中的類似，首先是含 3×3 卷積層的第二條線路輸出最多通道，其次是僅含 1×1 卷積層的第一條線路，之后是含 5×5 卷積層的第三條線路和含 3×3 最大池化層的第四條線路。其中第二、第三條線路都會先按比例減小通道數(shù)。這些比例在各個Inception塊中都略有不同。

b4 = nn.Sequential() b4.add(Inception(192, (96, 208), (16, 48), 64),Inception(160, (112, 224), (24, 64), 64),Inception(128, (128, 256), (24, 64), 64),Inception(112, (144, 288), (32, 64), 64),Inception(256, (160, 320), (32, 128), 128),nn.MaxPool2D(pool_size=3, strides=2, padding=1))

第五模塊有輸出通道數(shù)為 256+320+128+128=832 和 384+384+128+128=1024 的兩個Inception塊。其中每條線路的通道數(shù)的分配思路和第三、第四模塊中的一致，只是在具體數(shù)值上有所不同。需要注意的是，第五模塊的后面緊跟輸出層，該模塊同NiN一樣使用全局平均池化層來將每個通道的高和寬變成1。最后我們將輸出變成二維數(shù)組后接上一個輸出個數(shù)為標簽類別數(shù)的全連接層。

b5 = nn.Sequential() b5.add(Inception(256, (160, 320), (32, 128), 128),Inception(384, (192, 384), (48, 128), 128),nn.GlobalAvgPool2D())net = nn.Sequential() net.add(b1, b2, b3, b4, b5, nn.Dense(10))

六，殘差網(wǎng)絡（ResNet）

殘差塊

ResNet沿用了VGG全 3×3 卷積層的設計。殘差塊里首先有2個有相同輸出通道數(shù)的 3×3 卷積層。每個卷積層后接一個批量歸一化層和ReLU激活函數(shù)。然后我們將輸入跳過這2個卷積運算后直接加在最后的ReLU激活函數(shù)前。這樣的設計要求2個卷積層的輸出與輸入形狀一樣，從而可以相加。如果想改變通道數(shù)，就需要引入一個額外的 1×1 卷積層來將輸入變換成需要的形狀后再做相加運算。

殘差塊的實現(xiàn)如下。它可以設定輸出通道數(shù)、是否使用額外的 1×1 卷積層來修改通道數(shù)以及卷積層的步幅。

class Residual(nn.Block): # 本類已保存在d2lzh包中方便以后使用def __init__(self, num_channels, use_1x1conv=False, strides=1, **kwargs):super(Residual, self).__init__(**kwargs)self.conv1 = nn.Conv2D(num_channels, kernel_size=3, padding=1,strides=strides)self.conv2 = nn.Conv2D(num_channels, kernel_size=3, padding=1)if use_1x1conv:self.conv3 = nn.Conv2D(num_channels, kernel_size=1,strides=strides)else:self.conv3 = Noneself.bn1 = nn.BatchNorm()self.bn2 = nn.BatchNorm()def forward(self, X):Y = nd.relu(self.bn1(self.conv1(X)))Y = self.bn2(self.conv2(Y))if self.conv3:X = self.conv3(X)return nd.relu(Y + X)

ResNet模型

ResNet的前兩層跟之前介紹的GoogLeNet中的一樣：在輸出通道數(shù)為64、步幅為2的 7×7 卷積層后接步幅為2的 3×3 的最大池化層。不同之處在于ResNet每個卷積層后增加的批量歸一化層。

net = nn.Sequential() net.add(nn.Conv2D(64, kernel_size=7, strides=2, padding=3),nn.BatchNorm(), nn.Activation('relu'),nn.MaxPool2D(pool_size=3, strides=2, padding=1))

GoogLeNet在后面接了4個由Inception塊組成的模塊。ResNet則使用4個由殘差塊組成的模塊，每個模塊使用若干個同樣輸出通道數(shù)的殘差塊。第一個模塊的通道數(shù)同輸入通道數(shù)一致。由于之前已經(jīng)使用了步幅為2的最大池化層，所以無須減小高和寬。之后的每個模塊在第一個殘差塊里將上一個模塊的通道數(shù)翻倍，并將高和寬減半。

下面我們來實現(xiàn)這個模塊。注意，這里對第一個模塊做了特別處理。

def resnet_block(num_channels, num_residuals, first_block=False):blk = nn.Sequential()for i in range(num_residuals):if i == 0 and not first_block:blk.add(Residual(num_channels, use_1x1conv=True, strides=2))else:blk.add(Residual(num_channels))return blk

接著我們?yōu)镽esNet加入所有殘差塊。這里每個模塊使用2個殘差塊。

net.add(resnet_block(64, 2, first_block=True),resnet_block(128, 2),resnet_block(256, 2),resnet_block(512, 2))

最后，與GoogLeNet一樣，加入全局平均池化層后接上全連接層輸出。

net.add(nn.GlobalAvgPool2D(), nn.Dense(10))

七，稠密連接網(wǎng)絡（DenseNet）

DenseNet與ResNet的主要區(qū)別在于，DenseNet里模塊 B 的輸出不是像ResNet那樣和模塊 A 的輸出相加，而是在通道維上連結(jié)。這樣模塊 A 的輸出可以直接傳入模塊 B 后面的層。在這個設計里，模塊 A 直接跟模塊 B 后面的所有層連接在了一起。這也是它被稱為“稠密連接”的原因。

DenseNet的主要構(gòu)建模塊是稠密塊（dense block）和過渡層（transition layer）。前者定義了輸入和輸出是如何連結(jié)的，后者則用來控制通道數(shù)，使之不過大。

稠密塊

DenseNet使用了ResNet改良版的“批量歸一化、激活和卷積”結(jié)構(gòu)，我們首先在conv_block函數(shù)里實現(xiàn)這個結(jié)構(gòu)。

def conv_block(num_channels):blk = nn.Sequential()blk.add(nn.BatchNorm(), nn.Activation('relu'),nn.Conv2D(num_channels, kernel_size=3, padding=1))return blkclass DenseBlock(nn.Block):def __init__(self, num_convs, num_channels, **kwargs):super(DenseBlock, self).__init__(**kwargs)self.net = nn.Sequential()for _ in range(num_convs):self.net.add(conv_block(num_channels))def forward(self, X):for blk in self.net:Y = blk(X)X = nd.concat(X, Y, dim=1) # 在通道維上將輸入和輸出連結(jié)return X

過渡層

由于每個稠密塊都會帶來通道數(shù)的增加，使用過多則會帶來過于復雜的模型。過渡層用來控制模型復雜度。它通過 1×1 卷積層來減小通道數(shù)，并使用步幅為2的平均池化層減半高和寬，從而進一步降低模型復雜度。

def transition_block(num_channels):blk = nn.Sequential()blk.add(nn.BatchNorm(), nn.Activation('relu'),nn.Conv2D(num_channels, kernel_size=1),nn.AvgPool2D(pool_size=2, strides=2))return blk

DenseNet模型

我們來構(gòu)造DenseNet模型。DenseNet首先使用同ResNet一樣的單卷積層和最大池化層。

net = nn.Sequential() net.add(nn.Conv2D(64, kernel_size=7, strides=2, padding=3),nn.BatchNorm(), nn.Activation('relu'),nn.MaxPool2D(pool_size=3, strides=2, padding=1))

類似于ResNet接下來使用的4個殘差塊，DenseNet使用的是4個稠密塊。同ResNet一樣，我們可以設置每個稠密塊使用多少個卷積層。這里我們設成4，從而與上一節(jié)的ResNet-18保持一致。稠密塊里的卷積層通道數(shù)（即增長率）設為32，所以每個稠密塊將增加128個通道。

ResNet里通過步幅為2的殘差塊在每個模塊之間減小高和寬。這里我們則使用過渡層來減半高和寬，并減半通道數(shù)。

num_channels, growth_rate = 64, 32 # num_channels為當前的通道數(shù) num_convs_in_dense_blocks = [4, 4, 4, 4]for i, num_convs in enumerate(num_convs_in_dense_blocks):net.add(DenseBlock(num_convs, growth_rate))# 上一個稠密塊的輸出通道數(shù)num_channels += num_convs * growth_rate# 在稠密塊之間加入通道數(shù)減半的過渡層if i != len(num_convs_in_dense_blocks) - 1:num_channels //= 2net.add(transition_block(num_channels))

同ResNet一樣，最后接上全局池化層和全連接層來輸出

net.add(nn.BatchNorm(), nn.Activation('relu'), nn.GlobalAvgPool2D(),nn.Dense(10))

八，批量歸一化

從零開始實現(xiàn)

下面我們通過NDArray來實現(xiàn)批量歸一化層。

def batch_norm(X, gamma, beta, moving_mean, moving_var, eps, momentum):# 通過autograd來判斷當前模式是訓練模式還是預測模式if not autograd.is_training():# 如果是在預測模式下，直接使用傳入的移動平均所得的均值和方差X_hat = (X - moving_mean) / nd.sqrt(moving_var + eps)else:assert len(X.shape) in (2, 4)if len(X.shape) == 2:# 使用全連接層的情況，計算特征維上的均值和方差mean = X.mean(axis=0)var = ((X - mean) ** 2).mean(axis=0)else:# 使用二維卷積層的情況，計算通道維上（axis=1）的均值和方差。這里我們需要保持# X的形狀以便后面可以做廣播運算mean = X.mean(axis=(0, 2, 3), keepdims=True)var = ((X - mean) ** 2).mean(axis=(0, 2, 3), keepdims=True)# 訓練模式下用當前的均值和方差做標準化X_hat = (X - mean) / nd.sqrt(var + eps)# 更新移動平均的均值和方差moving_mean = momentum * moving_mean + (1.0 - momentum) * meanmoving_var = momentum * moving_var + (1.0 - momentum) * varY = gamma * X_hat + beta # 拉伸和偏移return Y, moving_mean, moving_var

接下來，我們自定義一個BatchNorm層。它保存參與求梯度和迭代的拉伸參數(shù)gamma和偏移參數(shù)beta，同時也維護移動平均得到的均值和方差，以便能夠在模型預測時被使用。BatchNorm實例所需指定的num_features參數(shù)對于全連接層來說應為輸出個數(shù)，對于卷積層來說則為輸出通道數(shù)。該實例所需指定的num_dims參數(shù)對于全連接層和卷積層來說分別為2和4。

class BatchNorm(nn.Block):def __init__(self, num_features, num_dims, **kwargs):super(BatchNorm, self).__init__(**kwargs)if num_dims == 2:shape = (1, num_features)else:shape = (1, num_features, 1, 1)# 參與求梯度和迭代的拉伸和偏移參數(shù)，分別初始化成1和0self.gamma = self.params.get('gamma', shape=shape, init=init.One())self.beta = self.params.get('beta', shape=shape, init=init.Zero())# 不參與求梯度和迭代的變量，全在內(nèi)存上初始化成0self.moving_mean = nd.zeros(shape)self.moving_var = nd.zeros(shape)def forward(self, X):# 如果X不在內(nèi)存上，將moving_mean和moving_var復制到X所在顯存上if self.moving_mean.context != X.context:self.moving_mean = self.moving_mean.copyto(X.context)self.moving_var = self.moving_var.copyto(X.context)# 保存更新過的moving_mean和moving_varY, self.moving_mean, self.moving_var = batch_norm(X, self.gamma.data(), self.beta.data(), self.moving_mean,self.moving_var, eps=1e-5, momentum=0.9)return Y

接口實現(xiàn)

與我們剛剛自己定義的BatchNorm類相比，Gluon中nn模塊定義的BatchNorm類使用起來更加簡單。它不需要指定自己定義的BatchNorm類中所需的num_features和num_dims參數(shù)值。在Gluon中，這些參數(shù)值都將通過延后初始化而自動獲取。下面我們用Gluon實現(xiàn)使用批量歸一化的LeNet。

net = nn.Sequential() net.add(nn.Conv2D(6, kernel_size=5),nn.BatchNorm(),nn.Activation('sigmoid'),nn.MaxPool2D(pool_size=2, strides=2),nn.Conv2D(16, kernel_size=5),nn.BatchNorm(),nn.Activation('sigmoid'),nn.MaxPool2D(pool_size=2, strides=2),nn.Dense(120),nn.BatchNorm(),nn.Activation('sigmoid'),nn.Dense(84),nn.BatchNorm(),nn.Activation('sigmoid'),nn.Dense(10))

總結(jié)

以上是生活随笔為你收集整理的卷积神经网络——各种网络的简洁介绍和实现的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。