动手学PyTorch（李沐）20 ----ResNet

​ 每一个层都包含了前一个模型作为子模型，以致于不会使得模型学偏，确保模型一直向好的方向发展。

​ 思路是通过加层，不会影响到模型变复杂。做 f(x)=x+g(x) 加法，使得 如果新加的层没有学习到信息的时候，之前学习到的也能够传递到下一层，如果新加的层学到了新的信息，那么就可以叠加之前学到的信息。

​ 意思就是说会另外加一个 1 * 1 的卷积变换通道，再把信息加回去。

​ 可以使用不同的残差块，也可以添加在不同的地方（卷积层、归一化层、激活层）

ResNet块

**ResNet512是经常用来刷分的模型，ResNet34通常是用的比较多的。 **

QA：

1. f(x)=x+g(x) 中 加上 g( x ) 对loss下降如果效果不明显的话，g( x )的权重就不会被更新或者是一个随机小数，g(x) 就不会做出贡献。
2. cos学习率会比step的固定学习率稍好一点，cos学习率简单。
3. *resnet_block 就是把列表resnet_block展开，把每个元素都作为参数传入

---

为什么ResNet能训练1000层模型

怎么处理梯度消失的？

​ g(x) 相当于新加的层，如果说新加的层g(x)对数据的拟合能力比较好，那么梯度 $\frac{\partial g(y)}{\partial y}$ 就很小，那么$\frac{\partial g(y)}{\partial y}\cdot \frac{\partial y}{\partial w}$ 就很小，梯度小，要么就选择增大学习率，但增大学习率也没有太大的作用，因为靠近数据底部的更新，如果学习率太大，w的梯度也太大，那模型就不稳定了。

​ ResNet采用如下方法解决此问题 $y^{\prime \prime }=f(x)+g(f(x))$ ，对 y 求导的结果为 $\frac{\partial y^{\prime \prime }}{\partial w}=\frac{\partial y}{\partial w}+\frac{\partial y^{\prime }}{\partial w}$ 。如果后面部分比较小的时候，还有前面一部分大的。这就大+小=大，大*小=小差不多理解。

**这样的反向传播使得靠近数据的层也会拿到比较大的梯度，使得下面的层也能够做出比较搞笑的更新。**

---

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

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:
      # 输出的高宽要和f(x)相匹配
      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

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

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))

X = torch.rand(size=(1, 1, 224, 224))

for layer in net:
  X = layer(X)
  print(layer.__class__.__name__,'output shape:\t', X.shape)

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())