深度卷積神經網絡AlexNet

文字過多，但是重點已經標出來了

背景

在LeNet提出后的將近20年里，神經網絡一度被其他機器學習方法超越，如支持向量機。雖然LeNet可以在早期的小數據集上取得好的成績，但是在更大的真實數據集上的表現并不盡如人意。一方面，神經網絡計算復雜。雖然20世紀90年代也有過一些針對神經網絡的加速硬件，但并沒有像之后GPU那樣大量普及。因此，訓練一個多通道、多層和有大量參數的卷積神經網絡在當年很難完成。另一方面，當年研究者還沒有大量深入研究參數初始化和非凸優化算法等諸多領域，導致復雜的神經網絡的訓練通常較困難。

神經網絡可以直接基于圖像的原始像素進行分類。這種稱為端到端（end-to-end）的方法節省了很多中間步驟。然而，在很長一段時間里更流行的是研究者通過勤勞與智慧所設計并生成的手工特征。這類圖像分類研究的主要流程是：

• 獲取圖像數據集；
• 使用已有的特征提取函數生成圖像的特征；
• 使用機器學習模型對圖像的特征分類。

當時認為的機器學習部分僅限最后這一步。如果那時候跟機器學習研究者交談，他們會認為機器學習既重要又優美。優雅的定理證明了許多分類器的性質。機器學習領域生機勃勃、嚴謹而且極其有用。然而，如果跟計算機視覺研究者交談，則是另外一幅景象。他們會告訴你圖像識別里“不可告人”的現實是：計算機視覺流程中真正重要的是數據和特征。也就是說，使用較干凈的數據集和較有效的特征甚至比機器學習模型的選擇對圖像分類結果的影響更大。

特征的表示

• 在相當長的時間里，特征都是基于各式各樣手工設計的函數從數據中提取的。事實上，不少研究者通過提出新的特征提取函數不斷改進圖像分類結果。

• 然而，另一些研究者認為特征本身也應該由學習得來。他們還相信，為了表征足夠復雜的輸入，特征本身應該分級表示。多層神經網絡可能可以學得數據的多級表征，并逐級表示越來越抽象的概念或模式。

• 以圖像分類為例，（二維卷積層）中物體邊緣檢測的例子。在多層神經網絡中，圖像的第一級的表示可以是在特定的位置和?度是否出現邊緣；

• 而第二級的表示說不定能夠將這些邊緣組合出有趣的模式，如花紋；

• 在第三級的表示中，也許上一級的花紋能進一步匯合成對應物體特定部位的模式。這樣逐級表示下去，最終，模型能夠較容易根據最后一級的表示完成分類任務。需要強調的是，輸入的逐級表示由多層模型中的參數決定，而這些參數都是學出來的。

AlexNet

AlexNet網絡結構

直接上圖：AlexNet網絡結構

AlexNet包含8層變換，其中有5層卷積和2層全連接隱藏層，以及1個全連接輸出層。

• 第一層中的卷積窗口形狀是$11\times 11$
• 第二層中的卷積窗口形狀減小到$5\times 5$
• 之后全采用$3\times 3$
• 第一、第二和第五個卷積層之后都使用了窗口形狀為$3\times 3$、步幅為2的最大池化層
• AlexNet使用的卷積通道數大于LeNet中的卷積通道數幾十倍
• 緊接著最后一個卷積層的是兩個輸出個數為4096的全連接層

簡單說網絡結構就是：
$$\begin{gathered} \begin{array}{c}卷積\\ (96個11?11的核)\\ (步長為4)\end{array}\to \begin{array}{c}降采樣(最大池化)\\ (3?3的核，步長2)\end{array}\to \\ . \\ \begin{array}{c}卷積\\ (256個5?5的核)\\ (padding為2)\end{array}\to \begin{array}{c}降采樣(最大池化)\\ (3?3的核，步長2)\end{array}\to \\ . \\ \begin{array}{c}卷積\\ (384個3?3的核)\\ (padding為1)\end{array}\to \\ . \\ \begin{array}{c}卷積\\ (384個3?3的核)\\ (padding為1)\end{array}\to \\ . \\ \begin{array}{c}卷積\\ (256個3?3的核)\\ (padding為1)\end{array}\to \begin{array}{c}降采樣(最大池化)\\ (3?3的核，步長2)\end{array}\to \\ . \\ \begin{array}{c}全連接\\ 6?6?256\to 4096\end{array}\to \begin{array}{c}全連接\\ 4096\to 4096\end{array}\to \begin{array}{c}全連接\\ 4096\to 10\end{array} \end{gathered}$$

每層尺寸解析：
(1)
原始圖像的227*227*3的圖像（最開始是224*224*3，為后續處理,t需要調整為227）
$$\begin{gathered} \begin{array}{c}卷積\\ (96個11?11的核)\\ (步長為4)\end{array} \\ ?(n_h?k_h+p_h+s_h)/s_h?\times ?(n_w?k_w+p_w+s_w)/s_w?= \\ ?(227?11+0\times 2+4)/4?\times ?(227?11+0\times 2+4)/4?=55\times 55 \\ . \\ \begin{array}{c}降采樣(最大池化)\\ (3?3的核，步長2)\end{array} \\ ?(n_h?k_h+p_h+s_h)/s_h?\times ?(n_w?k_w+p_w+s_w)/s_w?= \\ ?(55?3+0\times 2+2)/2?\times ?(55?3+0\times 2+2)/2?=27\times 27 \end{gathered}$$
第一層卷積層結束后形成的圖像層的規模為$27?27?96$.分別由96個卷積核對應生成，這96層數據分為2組，每組48個像素層
(2)
$$\begin{gathered} \begin{array}{c}卷積\\ (256個5?5的核)\\ (padding為2)\end{array} \\ ?(n_h?k_h+p_h+s_h)/s_h?\times ?(n_w?k_w+p_w+s_w)/s_w?= \\ ?(27?5+2\times 2+1)/1?\times ?(27?5+2\times 2+1)/1?=27\times 27 \\ . \\ \begin{array}{c}降采樣(最大池化)\\ (3?3的核，步長2)\end{array} \\ ?(n_h?k_h+p_h+s_h)/s_h?\times ?(n_w?k_w+p_w+s_w)/s_w?= \\ ?(27?3+0\times 2+2)/2?\times ?(27?3+0\times 2+2)/2?=13\times 13 \end{gathered}$$
第二層輸入數據為第一層輸出的27*27*96的像素層，分為2組像素數據，兩組像素數據分別在兩個不同的GPU中進行運算，一共有256個卷積核，即池化后像素的規模為2組13*13*128的像素層。
(3)
$$\begin{gathered} \begin{array}{c}卷積\\ (384個3?3的核)\\ (padding為1)\end{array} \\ ?(n_h?k_h+p_h+s_h)/s_h?\times ?(n_w?k_w+p_w+s_w)/s_w?= \\ ?(13?3+1\times 2+1)/1?\times ?(13?3+1\times 2+1)/1?=13\times 13 \end{gathered}$$
一共有384個卷積核，同理，也就是13*13*192兩組像素層。
(4)
$$\begin{gathered} \begin{array}{c}卷積\\ (384個3?3的核)\\ (padding為1)\end{array} \\ ?(n_h?k_h+p_h+s_h)/s_h?\times ?(n_w?k_w+p_w+s_w)/s_w?= \\ ?(13?3+1\times 2+1)/1?\times ?(13?3+1\times 2+1)/1?=13\times 13 \end{gathered}$$
一共有384個卷積核，同理，也就是13*13*192兩組像素層。
(5)
$$\begin{gathered} \begin{array}{c}卷積\\ (256個3?3的核)\\ (padding為1)\end{array} \\ ?(n_h?k_h+p_h+s_h)/s_h?\times ?(n_w?k_w+p_w+s_w)/s_w?= \\ ?(13?3+2\times 1+1)/1?\times ?(13?3+2\times 1+1)/1?=13\times 13 \\ . \\ \begin{array}{c}降采樣(最大池化)\\ (3?3的核，步長2)\end{array} \\ ?(n_h?k_h+p_h+s_h)/s_h?\times ?(n_w?k_w+p_w+s_w)/s_w?= \\ ?(13?3+0\times 2+2)/2?\times ?(13?3+0\times 2+2)/2?=6\times 6 \end{gathered}$$
一共有256個卷積核，同理，也就是6*6*128兩組像素層。
(6)
第6層輸入數據的尺寸是6*6*256，采用6*6*256尺寸的濾波器對第六層的輸入數據進行卷積運算；每個6*6*256尺寸的濾波器對第六層的輸入數據進行卷積運算生成一個運算結果，通過一個神經元輸出這個運算結果；共有4096個6*6*256尺寸的濾波器對輸入數據進行卷積，通過4096個神經元的輸出運算結果；然后通過ReLU激活函數以及dropout運算輸出4096個本層的輸出結果值。所以結果是2個2048輸出結果組
(7)
第6層輸出的4096個數據與第7層的4096個神經元進行全連接，然后由ReLU和Dropout進行處理后生成4096個數據。所以結果是2個2048輸出結果組
(8)
第7層輸入的4096個數據與第8層的1000個神經元進行全連接。

與LeNet的顯著區別

• AlexNet將sigmoid激活函數改成了更加簡單的ReLU激活函數
  (ReLU激活函數的計算更簡單，例如它并沒有sigmoid激活函數中的求冪運算。另一方面，ReLU激活函數在不同的參數初始化方法下使模型更容易訓練。這是由于當sigmoid激活函數輸出極接近0或1時，這些區域的梯度幾乎為0，從而造成反向傳播無法繼續更新部分模型參數；而ReLU激活函數在正區間的梯度恒為1。因此，若模型參數初始化不當，sigmoid函數可能在正區間得到幾乎為0的梯度，從而令模型無法得到有效訓練。)
• AlexNet通過丟棄法來控制全連接層的模型復雜度。而LeNet并沒有使用丟棄法。
• AlexNet引入了大量的圖像增廣，如翻轉、裁剪和顏色變化，從而進一步擴大數據集來緩解過擬合。

實現簡化過的AlexNet

import time import torch from torch import nn, optim import torchvisiondevice = torch.device('cuda' if torch.cuda.is_available() else 'cpu')class AlexNet(nn.Module):def __init__(self):super(AlexNet, self).__init__()self.conv = nn.Sequential(nn.Conv2d(1, 96, 11, 4), # in_channels, out_channels, kernel_size, stride, paddingnn.ReLU(),nn.MaxPool2d(3, 2), # kernel_size, stride# 減小卷積窗口，使用填充為2來使得輸入與輸出的高和寬一致，且增大輸出通道數nn.Conv2d(96, 256, 5, 1, 2),nn.ReLU(),nn.MaxPool2d(3, 2),# 連續3個卷積層，且使用更小的卷積窗口。除了最后的卷積層外，進一步增大了輸出通道數。# 前兩個卷積層后不使用池化層來減小輸入的高和寬nn.Conv2d(256, 384, 3, 1, 1),nn.ReLU(),nn.Conv2d(384, 384, 3, 1, 1),nn.ReLU(),nn.Conv2d(384, 256, 3, 1, 1),nn.ReLU(),nn.MaxPool2d(3, 2))# 這里全連接層的輸出個數比LeNet中的大數倍。使用丟棄層來緩解過擬合self.fc = nn.Sequential(nn.Linear(256*5*5, 4096),nn.ReLU(),nn.Dropout(0.5),nn.Linear(4096, 4096),nn.ReLU(),nn.Dropout(0.5),# 輸出層。由于這里使用Fashion-MNIST，所以用類別數為10，而非論文中的1000nn.Linear(4096, 10),)def forward(self, img):feature = self.conv(img)output = self.fc(feature.view(img.shape[0], -1))return output net = AlexNet() print(net) AlexNet((conv): Sequential((0): Conv2d(1, 96, kernel_size=(11, 11), stride=(4, 4))(1): ReLU()(2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)(3): Conv2d(96, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))(4): ReLU()(5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)(6): Conv2d(256, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(7): ReLU()(8): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(9): ReLU()(10): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))(11): ReLU()(12): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False))(fc): Sequential((0): Linear(in_features=6400, out_features=4096, bias=True)(1): ReLU()(2): Dropout(p=0.5)(3): Linear(in_features=4096, out_features=4096, bias=True)(4): ReLU()(5): Dropout(p=0.5)(6): Linear(in_features=4096, out_features=10, bias=True)) )

讀取數據：

def load_data_fashion_mnist(batch_size, resize=None, root='~/Datasets/FashionMNIST'):"""Download the fashion mnist dataset and then load into memory."""trans = []if resize:trans.append(torchvision.transforms.Resize(size=resize))trans.append(torchvision.transforms.ToTensor())transform = torchvision.transforms.Compose(trans)mnist_train = torchvision.datasets.FashionMNIST(root=root, train=True, download=True, transform=transform)mnist_test = torchvision.datasets.FashionMNIST(root=root, train=False, download=True, transform=transform)train_iter = torch.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True, num_workers=4)test_iter = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False, num_workers=4)return train_iter, test_iterbatch_size = 128 # 如出現“out of memory”的報錯信息，可減小batch_size或resize train_iter, test_iter = load_data_fashion_mnist(batch_size, resize=224)

訓練吧：

lr, num_epochs = 0.001, 5 optimizer = torch.optim.Adam(net.parameters(), lr=lr) def train(net, train_iter, test_iter, batch_size, optimizer, device, num_epochs):net = net.to(device)print("training on ", device)loss = torch.nn.CrossEntropyLoss()for epoch in range(num_epochs):train_l_sum, train_acc_sum, n, batch_count, start = 0.0, 0.0, 0, 0, time.time()for X, y in train_iter:X = X.to(device)y = y.to(device)y_hat = net(X)l = loss(y_hat, y)optimizer.zero_grad()l.backward()optimizer.step()train_l_sum += l.cpu().item()train_acc_sum += (y_hat.argmax(dim=1) == y).sum().cpu().item()n += y.shape[0]batch_count += 1test_acc = evaluate_accuracy(test_iter, net)print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f, time %.1f sec'% (epoch + 1, train_l_sum / batch_count, train_acc_sum / n, test_acc, time.time() - start))train(net, train_iter, test_iter, batch_size, optimizer, device, num_epochs)

《動手學深度學習》

總結

以上是生活随笔為你收集整理的（pytorch-深度学习系列）深度卷积神经网络AlexNet的全部內容，希望文章能夠幫你解決所遇到的問題。

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