ResNet+代码练习+Q&A
#Resnet
import torch
from torch import nn
from torch.nn import functional as F
from d2l import torch as d2l
class Residual(nn.Module): #@save
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:
self.conv3 = nn.Conv2d(input_channels, num_channels,
kernel_size=1, stride=strides)
else:
self.conv3 = None
self.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:
X = self.conv3(X)
Y += X
return F.relu(Y)
blk = Residual(3,3)
X = torch.rand(4, 3, 6, 6)
Y = blk(X)
Y.shape
blk = Residual(3,6, use_1x1conv=True, strides=2)
blk(X).shape
#googleNet
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
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))
net = nn.Sequential(b1, b2, b3, b4, b5,
nn.AdaptiveAvgPool2d((1,1)),
nn.Flatten(), nn.Linear(512, 10))
lr, num_epochs, batch_size = 0.05, 10, 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=96)
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())-
图7.4.1中的Inception块与残差块之间的主要区别是什么？在删除了Inception块中的一些路径之后，它们是如何相互关联的？
Inception块是用了4种不同的卷积核并行然后将输出的通道数叠到一起，计算量有所减少，提升了模型的感知能力。残差块的参数近乎为0.。虽然他们都是分割了道路，但是resnet是合并的。inception块是串联合并的。且卷积不一样。 -
参考ResNet论文 [He et al., 2016a]中的表1，以实现不同的变体。
-
对于更深层次的网络，ResNet引入了“bottleneck”架构来降低模型复杂性。请你试着去实现它。
论文中说：一般来说，增加网络的深度可以提高accuracy, 但是会增加计算量，而bottleneck既增加了深度，计算量又可以得到节约。
class bottleNeck(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=1, stride=strides) self.bn1 = nn.BatchNorm2d(num_channels) self.comv2 = nn.Conv2d(input_channels, num_channels, kernel_size=3,padding = 1, stride=strides) self.bn2 = nn.BatchNorm2d(num_channels) self.conv3 = nn.Conv2d(input_channels, num_channels, kernel_size=1, stride=strides) self.bn3 = nn.BatchNorm2d(num_channels) def forward(self, X): Y = F.relu(self.bn1(self.conv1(X))) Y = self.bn2(self.conv2(Y)) Y = Y.relu(Y) Y = conv3(Y) return Y -
在ResNet的后续版本中，作者将“卷积层、批量规范化层和激活层”架构更改为“批量规范化层、激活层和卷积层”架构。请你做这个改进。详见 [He et al., 2016b]中的图1。
-
为什么即使函数类是嵌套的，我们仍然要限制增加函数的复杂性呢？
对于conv的参数来说，函数类的嵌套计算的复杂度是足以忽略的（我猜的，其实我没听懂问题是什么意思）
Q&A：
1.f(x) = x + g(x) x是input 这样可以保证至少不会变坏吗？如果g（x）变坏了呢？
我训练fx，发现g（x）很难训练或者说训练的不好，模型会拿不到gx的梯度，因为模型发现了f(x)=x训练的已经很好了，加上了gx对我的loss下降没什么影响的话。在BP的时候g(x)是拿不到什么梯度的也就是我们的gx的梯度不会更新。权重不会更新。所以说Resnet不会让模型变坏。
2.cos学习率不错哦。
3.残差的概念体现在什么地方？f(x) = x +g(x) .所以g(x)可以视为f(x)的残差。
x是一个小模型，我会先选择拟合这个小的模型(x)，然后再用g(x)训练没有训练好的东西。右图是一个很好的解释。
4.为什么在我们的模型中Resnet块定义了两个bn，他们的参数一样？
不一样，之所以定义两个就是因为参数不一样要学习不同的参数。