一.舉例通俗解釋ResNet思想

假設(shè)你正在學(xué)習(xí)如何騎自行車，并且想要騎到一個遙遠(yuǎn)的目的地。你可以選擇直接騎到目的地，也可以選擇在途中設(shè)置幾個“中轉(zhuǎn)站”，每個中轉(zhuǎn)站都會告訴你如何朝著目的地前進(jìn)。

在傳統(tǒng)的神經(jīng)網(wǎng)絡(luò)中，就好比只能選擇直接騎到目的地。當(dāng)你的目的地很遠(yuǎn)時，可能會出現(xiàn)騎不到目的地的情況，因為網(wǎng)絡(luò)在訓(xùn)練過程中無法有效地傳遞信息，導(dǎo)致梯度消失或梯度爆炸。

而ResNet則是在途中設(shè)置多個**“殘差塊”作為中轉(zhuǎn)站**。每個殘差塊相當(dāng)于一個中轉(zhuǎn)站。

二.ResNet網(wǎng)絡(luò)結(jié)構(gòu)

假設(shè)f(x)是最終求得的函數(shù)。ResNet把函數(shù)拆成了f(x) = x + g(x).

傳統(tǒng)網(wǎng)絡(luò)相當(dāng)于直接達(dá)到目的地，就是直接求f(x)。
ResNet是先到達(dá)一個中轉(zhuǎn)站，即先求得g(x)，再求g(x) + x 得到f(x)。同時可以推出g(x) = f(x) - x。

三.用實際的數(shù)舉例子：

假設(shè)要求的f(x) = 5x^2 + 3x +2
ResNet先求得 g(x) = f(x) - x = 5x^2 + 2x +2 ，然后將g(x) 與x相加，最終得到f(x)=g(x) + x = 5x^2 + 3x +2

四.為什么ResNet非要設(shè)計成先求一個中轉(zhuǎn)的函數(shù)g(x)，然后再加上x呢？

4.1 解決網(wǎng)絡(luò)加深，效果變差的問題

假如輸入的x已經(jīng)是最好的結(jié)果，如果加深網(wǎng)絡(luò)效果會變差，即把最好的結(jié)果x輸入到新一層的網(wǎng)絡(luò)g(x)中，效果會變差。

那么我們直接令g(x)=0,相當(dāng)于舍棄掉影響最優(yōu)結(jié)果的網(wǎng)絡(luò)塊。最終得到的f(x) = 0 +x，保留了最優(yōu)結(jié)果x。

從反向傳播的角度來說，解決梯度消失和梯度爆炸的問題

對y=F(x)+x求偏導(dǎo)發(fā)現(xiàn)會出現(xiàn)畫圈的地方，梯度消失是累積的乘積中出現(xiàn)接近0的數(shù)，影響梯度的結(jié)果，梯度爆炸是累積乘積，結(jié)果出現(xiàn)指數(shù)級增長。多了畫圈地方的+操作，就打破了累乘，結(jié)果不容易出現(xiàn)梯度消失與爆炸。

五.代碼實現(xiàn)

import torch
from torch import nn
from torch.nn import functional as F
from d2l import  torch as d2l
import time

class Residual(nn.Module):def __init__(self,input_channels,num_channels,use_1x1conv=False,strides=1):super().__init__()self.conv1 = nn.Conv2d(input_channels,num_channels,kernel_size=3,padding=1,stride=strides)self.conv2 = nn.Conv2d(num_channels,num_channels,kernel_size=3,padding=1)if use_1x1conv: # 使用1x1卷積核控制輸出通道數(shù)self.conv3 = nn.Conv2d(input_channels,num_channels,kernel_size=1,stride=strides)else:self.conv3 = Noneself.bn1 = nn.BatchNorm2d(num_channels)self.bn2 = nn.BatchNorm2d(num_channels)def forward(self,X):Y = F.relu(self.bn1(self.conv1(X)))Y = self.bn2(self.conv2(Y))if self.conv3: # 用1x1卷積將x通道與形狀 調(diào)整的與 f(x)-x一致X = self.conv3(X)# 不用1x1調(diào)整通道時直接 y+X = = f(x)-X + XY += Xreturn F.relu(Y)

包含以及不包含 1 × 1 卷積層的殘差塊

此代碼生成兩種類型的網(wǎng)絡(luò):一種是當(dāng)use_1x1conv=False時,應(yīng)用ReLU非線性函數(shù)之前,
將輸入添加到輸出。另一種是當(dāng)use_1x1conv=True時,添加通過1 × 1卷積調(diào)整通道和分辨率。

blk = Residual(input_channels=3,num_channels=3)
X = torch.rand(4, 3, 6, 6)
Y = blk(X)
Y.shape

torch.Size([4, 3, 6, 6])

# 使用1x1卷積控制通道數(shù)，使用strides=2減半輸出的高和寬,num_channels是輸出的通道數(shù)
blk = Residual(input_channels=3,num_channels=6, use_1x1conv=True, strides=2)
blk(X).shape

torch.Size([4, 6, 3, 3])

ResNet模型架構(gòu)

#ResNet模型
b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
nn.BatchNorm2d(64), nn.ReLU(),
nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

# 殘差塊
def resnet_block(input_channels, num_channels, num_residuals,first_block=False):blk = []for i in range(num_residuals):if i == 0 and not first_block:blk.append(Residual(input_channels, num_channels,use_1x1conv=True, strides=2))else:blk.append(Residual(num_channels, num_channels))return blk

# 接著在ResNet加入所有殘差塊,這里每個模塊使用2個殘差塊。
b2 = nn.Sequential(*resnet_block(64, 64, 2, first_block=True))
b3 = nn.Sequential(*resnet_block(64, 128, 2))
b4 = nn.Sequential(*resnet_block(128, 256, 2))
b5 = nn.Sequential(*resnet_block(256, 512, 2))

# 最后,與GoogLeNet一樣,在ResNet中加入全局平均匯聚層,以及全連接層輸出。
# 每個模塊有4個卷積層(不包括恒等映射的1 × 1卷積層)。加上第一個7 × 7卷積層和最后一個全連接層,共有18層。因此,這種模型通常被稱為ResNet-18。
net = nn.Sequential(b1, b2, b3, b4, b5,nn.AdaptiveAvgPool2d((1,1)),nn.Flatten(), nn.Linear(512, 10))

# 觀察一下ResNet中不同模塊的輸入形狀是如何變化的。在之前所有架構(gòu)中,分辨率降低,通道數(shù)量增加,直到全局平均匯聚層聚集所有特征。
X = torch.rand(size=(1, 1, 224, 224))
for layer in net:X = layer(X)print(layer.__class__.__name__,'output shape:\t', X.shape)

# 庫中的函數(shù)沒有取最優(yōu)的準(zhǔn)確率，自己實現(xiàn)一個
def train_ch6(net, train_iter, test_iter, num_epochs, lr, device):"""Train a model with a GPU (defined in Chapter 6).Defined in :numref:`sec_lenet`"""def init_weights(m):if type(m) == nn.Linear or type(m) == nn.Conv2d:nn.init.xavier_uniform_(m.weight)net.apply(init_weights)print('training on', device)net.to(device)optimizer = torch.optim.SGD(net.parameters(), lr=lr)loss = nn.CrossEntropyLoss()animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs],legend=['train loss', 'train acc', 'test acc'])timer, num_batches = d2l.Timer(), len(train_iter)best_test_acc = 0for epoch in range(num_epochs):# Sum of training loss, sum of training accuracy, no. of examplesmetric = d2l.Accumulator(3)net.train()for i, (X, y) in enumerate(train_iter):timer.start()optimizer.zero_grad()X, y = X.to(device), y.to(device)y_hat = net(X)l = loss(y_hat, y)l.backward()optimizer.step()with torch.no_grad():metric.add(l * X.shape[0], d2l.accuracy(y_hat, y), X.shape[0])timer.stop()train_l = metric[0] / metric[2]train_acc = metric[1] / metric[2]if (i + 1) % (num_batches // 5) == 0 or i == num_batches - 1:animator.add(epoch + (i + 1) / num_batches,(train_l, train_acc, None))test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)if test_acc>best_test_acc:best_test_acc = test_accanimator.add(epoch + 1, (None, None, test_acc))print(f'loss {train_l:.3f}, train acc {train_acc:.3f}, 'f'test acc {test_acc:.3f}, best test acc {best_test_acc:.3f}')# 取的好像是平均準(zhǔn)備率print(f'{metric[2] * num_epochs / timer.sum():.1f} examples/sec 'f'on {str(device)}')

'''訓(xùn)練并打印訓(xùn)練耗時'''
'''開始計時'''
start_time = time.time()lr, num_epochs, batch_size = 0.05, 10, 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=96)
# 使用自己的訓(xùn)練函數(shù)
train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())'''計時結(jié)束'''
end_time = time.time()
run_time = end_time - start_time
# 將輸出的秒數(shù)保留兩位小數(shù)
if int(run_time)<60:print(f'{round(run_time,2)}s')
else:print(f'{round(run_time/60,2)}minutes')

牛逼！比之前所有的模型準(zhǔn)確率都高。

參考文章與視頻

三分鐘說明白ResNet ，關(guān)于它的設(shè)計、原理、推導(dǎo)及優(yōu)點
https://www.bilibili.com/video/BV1cM4y117ob/?spm_id_from=333.337.search-card.all.click&vd_source=ebc47f36e62b223817b8e0edff181613

ResNet詳解——通俗易懂版
https://blog.csdn.net/sunny_yeah_/article/details/89430124