學習心得
（1）為了解決神經網路隨著層數的增加，引數量巨大的問題，GoogleNet利用1×1卷積核，并且分別通過幾個不同的卷積核進行處理，有多個相同的模塊用Inception類封裝；
（2）另一種網路ResNet是為了解決梯度消失（由于在梯度計算的程序中是用的反向傳播，所以需要利用鏈式法則來進行梯度計算，是一個累乘的程序，若每一個地方梯度都是小于1的，累乘后梯度會趨于0）的問題，
（3）構造網路的超引數和input、output的size需要計算好，為了檢驗網路是否正確，可以先對net簡單測驗（輸入rand的tensor代入），如注釋其他層，看前面層的結果和預期的tensor大小是否吻合，即【增量式開發】，
文章目錄
- 學習心得
- 零、簡單回顧
- 一、GoogleNet
- 1.1 Inception模塊
- 1.2 1×1卷積核
- 二、可減少引數量的1×1卷積核
- 三、GoogleNet代碼實踐
- 四、殘差網路代碼實踐
- 五、PyTorch學習路線
- Reference
零、簡單回顧
上節課主要講了CNN的架構（如下圖的LetNet5），
- 定義一個卷積層：輸入通道數、輸出通道數、卷積核的大小（長和寬），卷積層要求輸入輸出是四維張量
(B,C,W,H)，全連接層的輸入與輸出都是二維張量(B,Input_feature)， - 卷積(convolution)后，C(Channels)變，W(width)和H(Height)可變可不變，取決于是否padding，subsampling(或pooling)后，C不變，W和H變，
- 如果要有m個輸出channel，就要使用m個卷積核：
1）每個卷積核的通道數要求和輸入通道相同；
2）卷積核的組數是和輸入的通道數相同；
3）卷積核的大小由自己來定，和影像的大小無關，一般設定為正方形，邊長為奇數（其實設定為長方形也是可以的），
一、GoogleNet
減少代碼冗余：函式or類，從下圖的GoogleNet可以看出
1.1 Inception模塊
（1）最后要拼接在一起，要求每個的寬度和高度一致，走不通路徑出來的，（B，C，W，H）唯一可以不同的是channel，
（2）padding可以維持高度和寬度不變；average pooling也可以通過padding和stride使高度和寬度不變，
1.2 1×1卷積核
1×1卷積核能夠改變通道數的數量，1×1卷積核個數取決于input的通道數，如下圖記得將三個顏色的矩陣相加，
不論input的通道為多少，如下圖最后做完1×1卷積后都是從C×W×H變為1×W×H的feature map，
如果需要變為C’×W×H的feature map，那就將C’組【3個1×1組合起來卷積核】，可以回顧上次講CNN的多通道卷積運算，
1×1卷積核可以跨越不同通道相同位置的元素值（結果的某個位置可以包含input的所有相同位置的資訊，即資訊融合），
二、可減少引數量的1×1卷積核
（1）下圖首先用5×5卷積：每個通道需要拿25個像素進行運算；假如進行padding，則需要對28×28的每個元素都進行運算；每次卷積要對192個通道上進行，這樣的運算進行了32次才能得到output，
（2）為了減少引數量，可以使用1×1卷積直接改變通道數，下圖可見引數量是第一種的十分之一，
括號內為output的通道數，
最后拼接所有塊，沿著維度=1（因為從0開始計算，維度分別為B，C，W，H），
outputs = [branch1x1, branch5x5, branch3x3, branch_pool]
return torch.cat(outputs, dim = 1)
三、GoogleNet代碼實踐
結合上面的googleNet介紹，詳看下面代碼注釋，
# -*- coding: utf-8 -*-
"""
Created on Thu Oct 21 14:10:19 2021
@author: 86493
"""
import torch
import torch.nn as nn
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim
import matplotlib.pyplot as plt
# 準備資料
batch_size = 64
transform = transforms.Compose([transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081))])
train_dataset = datasets.MNIST(root = '../dataset/mnist/',
train = True,
download = True,
transform = transform)
train_loader = DataLoader(train_dataset,
shuffle = True,
batch_size = batch_size)
test_dataset = datasets.MNIST(root = '../dataset/mnist/',
train = False,
download = True,
transform = transform)
test_loader = DataLoader(test_dataset,
shuffle = False,
batch_size = batch_size)
class InceptionA(nn.Module):
def __init__(self, in_channels):
super(InceptionA, self).__init__()
self.branch1x1 = nn.Conv2d(in_channels,
16,
kernel_size = 1)
self.branch5x5_1 = nn.Conv2d(in_channels,
16,
kernel_size = 1)
# 為了保證高和寬不變，設定padding
self.branch5x5_2 = nn.Conv2d(16,
24,
kernel_size = 3,
padding = 1)
self.branch3x3_1 = nn.Conv2d(in_channels,
16,
kernel_size = 1)
self.branch3x3_2 = nn.Conv2d(16,
24,
kernel_size = 3,
padding = 1)
self.branch3x3_3 = nn.Conv2d(24,
24,
kernel_size = 3,
padding = 1)
self.branch_pool = nn.Conv2d(in_channels,
24,
kernel_size = 1)
def forward(self, x):
branch1x1 = self.branch1x1(x)
branch5x5 = self.branch5x5_1(x)
branch5x5 = self.branch5x5_2(branch5x5)
branch3x3 = self.branch3x3_1(x)
branch3x3 = self.branch3x3_2(branch3x3)
branch3x3 = self.branch3x3_3(branch3x3)
# 為了保證高和寬不變，設定padding，下面這個沒有要學習的引數
branch_pool = F.avg_pool2d(x,
kernel_size = 3,
stride = 1,
padding = 1)
branch_pool = self.branch_pool(branch_pool)
outputs = [branch1x1, branch5x5, branch3x3, branch_pool]
return torch.cat(outputs, dim = 1)
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 10, kernel_size = 5)
# 88=24×3+16
self.conv2 = nn.Conv2d(88, 20, kernel_size = 5)
self.incep1 = InceptionA(in_channels = 10)
self.incep2 = InceptionA(in_channels = 20)
self.mp = nn.MaxPool2d(2)
# self.fc = nn.Linear(1408, 10)
def forward(self, x):
in_size = x.size(0)
x = F.relu(self.mp(self.conv1(x)))
# 下面這句的output=88
x = self.incep1(x)
x = F.relu(self.mp(self.conv2(x)))
# 下面這句的output=88
x = self.incep2(x)
# 做全連接，結果是通過flatten得到1408個元素
x = x.view(in_size, -1)
print("x.shape:", x.shape)
# x = self.fc(x)
return x
# CNN網路
class Net1(nn.Module):
def __init__(self):
super(Net1, self).__init__()
self.conv1 = nn.Conv2d(1, 10, kernel_size = 5)
self.conv2 = nn.Conv2d(10, 20, kernel_size = 5)
self.pooling = nn.MaxPool2d(2)
self.fc = nn.Linear(320, 10)
def forward(self, x):
# Flatten data from (n, 1, 28, 28)to(n, 784)
batch_size = x.size(0)
x = F.relu(self.pooling(self.conv1(x)))
x = F.relu(self.pooling(self.conv2(x)))
# flatten
x = x.view(batch_size, -1)
# print("x.shape", x.shape)
x = self.fc(x)
return x
model = Net()
"""
X = torch.rand(4, 1, 28, 28)
model(X) # 列印x.shape: torch.Size([4, 1408])
"""
# print(model)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
# 有多個顯卡時則可以填其他cuda號
model.to(device)
# 把模型的引數等放到顯卡中
# 設計損失函式和優化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(),
lr = 0.01,
momentum = 0.5)
def train(epoch):
running_loss = 0.0
for batch_idx, data in enumerate(train_loader, 0):
# 1.準備資料
inputs, target = data
# 遷移到GPU，注意遷移的device要和模型的device在同一塊顯卡
inputs, target = inputs.to(device), target.to(device)
# 2.前向傳遞
outputs = model(inputs)
loss = criterion(outputs, target)
# 3.反向傳播
optimizer.zero_grad()
loss.backward()
# 4.更新引數
optimizer.step()
running_loss += loss.item()
if batch_idx % 300 == 299:
print('[%d, %5d] loss:%.3f'%
(epoch + 1,
batch_idx + 1,
running_loss / 300))
running_loss = 0.0
def test():
correct = 0
total = 0
with torch.no_grad():
for data in test_loader:
images, labels = data
images, labels = images.to(device), labels.to(device)
outputs = model(images)
# 求出每一行(樣本)的最大值的下標,dim = 1即行的維度
# 回傳最大值和最大值所在的下標
_, predicted = torch.max(outputs.data, dim = 1)
# label矩陣為N × 1
total += labels.size(0)
correct += (predicted == labels).sum().item()
print('accuracy on test set :%d %% ' % (100 * correct / total))
return correct / total
if __name__ == '__main__':
epoch_list = []
acc_list = []
for epoch in range(10):
train(epoch)
acc = test()
epoch_list.append(epoch)
acc_list.append(acc)
plt.plot(epoch_list, acc_list)
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.show()
結果為99%的準確率，比上次的CNN高了1%，
[1, 300] loss:0.952
[1, 600] loss:0.216
[1, 900] loss:0.150
accuracy on test set :96 %
[2, 300] loss:0.112
[2, 600] loss:0.097
[2, 900] loss:0.085
accuracy on test set :97 %
[3, 300] loss:0.078
[3, 600] loss:0.072
[3, 900] loss:0.063
accuracy on test set :98 %
[4, 300] loss:0.059
[4, 600] loss:0.057
[4, 900] loss:0.062
accuracy on test set :98 %
[5, 300] loss:0.049
[5, 600] loss:0.052
[5, 900] loss:0.053
accuracy on test set :98 %
[6, 300] loss:0.048
[6, 600] loss:0.044
[6, 900] loss:0.045
accuracy on test set :98 %
[7, 300] loss:0.040
[7, 600] loss:0.047
[7, 900] loss:0.038
accuracy on test set :98 %
[8, 300] loss:0.035
[8, 600] loss:0.037
[8, 900] loss:0.041
accuracy on test set :98 %
[9, 300] loss:0.033
[9, 600] loss:0.038
[9, 900] loss:0.035
accuracy on test set :98 %
[10, 300] loss:0.031
[10, 600] loss:0.031
[10, 900] loss:0.036
accuracy on test set :99 %
如果列印model也能看到對應的結構：
Net(
(conv1): Conv2d(1, 10, kernel_size=(5, 5), stride=(1, 1))
(conv2): Conv2d(88, 20, kernel_size=(5, 5), stride=(1, 1))
(incep1): InceptionA(
(branch1x1): Conv2d(10, 16, kernel_size=(1, 1), stride=(1, 1))
(branch5x5_1): Conv2d(10, 16, kernel_size=(1, 1), stride=(1, 1))
(branch5x5_2): Conv2d(16, 24, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(branch3x3_1): Conv2d(10, 16, kernel_size=(1, 1), stride=(1, 1))
(branch3x3_2): Conv2d(16, 24, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(branch3x3_3): Conv2d(24, 24, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(branch_pool): Conv2d(10, 24, kernel_size=(1, 1), stride=(1, 1))
)
(incep2): InceptionA(
(branch1x1): Conv2d(20, 16, kernel_size=(1, 1), stride=(1, 1))
(branch5x5_1): Conv2d(20, 16, kernel_size=(1, 1), stride=(1, 1))
(branch5x5_2): Conv2d(16, 24, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(branch3x3_1): Conv2d(20, 16, kernel_size=(1, 1), stride=(1, 1))
(branch3x3_2): Conv2d(16, 24, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(branch3x3_3): Conv2d(24, 24, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(branch_pool): Conv2d(20, 24, kernel_size=(1, 1), stride=(1, 1))
)
(mp): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
)
四、殘差網路代碼實踐
（1）residual block要求輸入和輸出的tensor維度相同，
（2）有的跳連接在上圖匯總是虛線的，表示不一定做跳連接（因為維度不匹配的原因，無法跳躍后相加），所以需要做單獨處理——如不做跳連接，或者在跳連接中做一個池化層，注意池化不改變通道數（上面栗子的正路是做一個卷積，起到/2效果），
（3）構造網路的超引數和input、output的size需要計算好，為了檢驗網路是否正確，可以先對net簡單測驗（輸入rand的tensor代入），如注釋其他層，看前面層的結果和預期的tensor大小是否吻合，即【增量式開發】，
（4）卷積層中做的事，res是層間做的事，
代碼如下，ResidualBlock和Net兩個類變了，其余和之前沒變，
class ResidualBlock(nn.Module):
def __init__(self, channels):
super(ResidualBlock, self).__init__()
self.channels = channels
self.conv1 = nn.Conv2d(channels,
channels,
kernel_size = 3,
padding = 1)
self.conv2 = nn.Conv2d(channels,
channels,
kernel_size = 3,
padding = 1)
def forward(self, x):
y = F.relu(self.conv1(x))
y = self.conv2(y)
# x+y后再relu激活
return F.relu(x + y)
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 16, kernel_size = 5)
self.conv2 = nn.Conv2d(16, 32, kernel_size = 5)
self.mp = nn.MaxPool2d(2)
self.rblock1 = ResidualBlock(16)
self.rblock2 = ResidualBlock(32)
self.fc = nn.Linear(512, 10)
def forward(self, x):
in_size = x.size(0)
x = self.mp(F.relu(self.conv1(x)))
x = self.rblock1(x)
x = self.mp(F.relu(self.conv2(x)))
x = self.rblock2(x)
x = x.view(in_size, -1)
x = self.fc(x)
return x
[1, 300] loss:0.524
[1, 600] loss:0.168
[1, 900] loss:0.119
accuracy on test set :97 %
[2, 300] loss:0.094
[2, 600] loss:0.079
[2, 900] loss:0.072
accuracy on test set :98 %
[3, 300] loss:0.064
[3, 600] loss:0.059
[3, 900] loss:0.055
accuracy on test set :98 %
[4, 300] loss:0.049
[4, 600] loss:0.047
[4, 900] loss:0.046
accuracy on test set :98 %
[5, 300] loss:0.042
[5, 600] loss:0.038
[5, 900] loss:0.038
accuracy on test set :99 %
[6, 300] loss:0.031
[6, 600] loss:0.036
[6, 900] loss:0.035
accuracy on test set :98 %
[7, 300] loss:0.031
[7, 600] loss:0.030
[7, 900] loss:0.031
accuracy on test set :98 %
[8, 300] loss:0.029
[8, 600] loss:0.026
[8, 900] loss:0.026
accuracy on test set :98 %
[9, 300] loss:0.024
[9, 600] loss:0.022
[9, 900] loss:0.023
accuracy on test set :98 %
[10, 300] loss:0.020
[10, 600] loss:0.021
[10, 900] loss:0.022
accuracy on test set :99 %
網路的結果也可以print出來：
Net(
(conv1): Conv2d(1, 16, kernel_size=(5, 5), stride=(1, 1))
(conv2): Conv2d(16, 32, kernel_size=(5, 5), stride=(1, 1))
(mp): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
(rblock1): ResidualBlock(
(conv1): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
)
(rblock2): ResidualBlock(
(conv1): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
(conv2): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
)
(fc): Linear(in_features=512, out_features=10, bias=True)
)
更多閱讀何愷明大神的論文：
He K, Zhang X, Ren S, et al. Identity Mappings in Deep Residual Networks[C]
Huang G, Liu Z, Laurens V D M, et al. Densely Connected Convolutional Networks[J]. 2016:2261-2269.
五、PyTorch學習路線
（1）理論，看花書《深度學習》
（2 ）通讀一遍PyTorch官方檔案
（3）復現經典作業（讀代碼和寫代碼交叉進行），注意去github下別人論文代碼跑通沒啥用，要自己復現，不會的再去看別人的代碼
（4）擴充視野，基于上面前三個能力，因為復現是一開始很花時間的，現在看別人論文應該腦海有直覺代碼大概咋寫，看到不會的模塊再去看別人代碼，吸取精華，把小模塊吸收為自己的內容，
Reference
（1）PyTorch 深度學習實踐 第10講，劉二系列
（2）b站視頻：https://www.bilibili.com/video/BV1Y7411d7Ys?p=10
（3）官方檔案：https://pytorch.org/docs/stable/_modules/torch/nn/modules/conv.html#Conv2d
（4）吳恩達網易云課程：https://study.163.com/my#/smarts
（5）劉洪普老師博客：https://liuii.github.io/
（6）某同學的筆記
（7）pytorch官方檔案：https://pytorch.org/docs/stable/index.html
（8）Deep-Learning-with-PyTorch中文版：https://tangshusen.me/Deep-Learning-with-PyTorch-Chinese/#/
（9）神經網路模型(Backbone)
（10）詳解殘差網路：https://zhuanlan.zhihu.com/p/42706477
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/330091.html
標籤：AI