ResNet

更复杂模型包含小模型，不一定改进，但是加更深的层更复杂的模型至少不会变差。

复杂模型包含小模型，当要新加的层没有学到任何东西的时候，模型仍旧是可以学到前面层已经学到了的知识。可以认为是嵌入了小网络，允许先学习小网络。

从vgg过来。1*1卷积是为了改变通道数，和ResNet块输出的通道数保持一致，这样能做对应位置元素加法。

核心：加了一个加法。

152个卷积层。层数越高精度越高。34个卷积层用的比较多。刷榜经常用152【实际使用很少，训练太贵】

ResNet的思想 Residual Connections（残差连接）当前经常使用，例如 bert， transformer。

不管再深，总是先训练好小网络，再往深层训练。

代码

用了比较大的输入。调优ResNet–把输入搞小或者调小config？

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:
      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)
# stride 不传参 默认为1
print(Y.shape)  # torch.Size([4, 3, 6, 6])

# stride=2 高宽减半 输出通道数加倍
blk = Residual(3,6, use_1x1conv=True, strides=2)
print(blk(X).shape)  # torch.Size([4, 6, 3, 3])

# 设置第一个网络块 7*7卷积 stride=2 3*3池化层 stride=2  高宽降低4倍
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))

# 用了比较大的输入数据 高宽224 VGG用的是96高宽
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())

torch.Size([4, 3, 6, 6])
torch.Size([4, 6, 3, 3])
Sequential output shape:	 torch.Size([1, 64, 56, 56])
Sequential output shape:	 torch.Size([1, 64, 56, 56])
Sequential output shape:	 torch.Size([1, 128, 28, 28])
Sequential output shape:	 torch.Size([1, 256, 14, 14])
Sequential output shape:	 torch.Size([1, 512, 7, 7])
AdaptiveAvgPool2d output shape:	 torch.Size([1, 512, 1, 1])
Flatten output shape:	 torch.Size([1, 512])
Linear output shape:	 torch.Size([1, 10])
loss 0.012, train acc 0.997, test acc 0.913
1557.1 examples/sec on cuda:0

d2l.load_data_fashion_mnist(batch_size, resize=224)

loss 0.027, train acc 0.993, test acc 0.876
354.8 examples/sec on cuda:0

ReLU的两种调用

在 PyTorch 中，可以通过多种方式调用 ReLU（Rectified Linear Unit）激活函数。以下是几种常见的方法：

1. 使用 torch.nn.ReLU 模块

torch.nn.ReLU 是一个 PyTorch 模块，可以直接在模型中作为层来使用。

import torch
import torch.nn as nn

# 创建一个 ReLU 模块实例
relu = nn.ReLU()

# 示例输入张量
input_tensor = torch.tensor([-1.0, 0.0, 1.0, 2.0])

# 应用 ReLU 激活函数
output_tensor = relu(input_tensor)
print(output_tensor)

2. 使用 torch.nn.functional.relu 函数

torch.nn.functional.relu 是一个函数，可以直接应用于张量。这在编写自定义前向传播方法时非常有用。

import torch
import torch.nn.functional as F

# 示例输入张量
input_tensor = torch.tensor([-1.0, 0.0, 1.0, 2.0])

# 应用 ReLU 激活函数
output_tensor = F.relu(input_tensor)
print(output_tensor)

总结

• torch.nn.ReLU：作为模块使用，适合在构建模型时作为层的一部分。
• torch.nn.functional.relu：作为函数使用，适合在自定义的前向传播方法中调用。

QA

1 lenet batch_size > 1000 大部分图片都是相似的，影响收敛精度。
2 当f(x)=x+g(x)时，如果x的效果已经很好，那么g(x)训练可能拿不到梯度，做梯度反传的时候，梯度会是一个很小的值，那么ResNet在做更深的网络的时候，不会让模型变得更坏，一般会变好。
3 绿色线-cos学习率 【效果挺好】 调参简单–调个最大值最小值。

4 残差怎么理解
layer2在layer1的基础上训练一些误差，在layer1的基础上做叠加。底层网络没有fit好的东西，加深的网络继续去fit。

5 * 解包裹传递参数 把list列表参数解包裹传参
6 两个BN有自己的参数要学 参数不一样
7 nn.ReLU(inplace=True) 原地更新参数 省一点内存
8 输入尺寸的确定，是由数据和框架确定？
9 当训练数据中加入了大量的噪音，测试精度会大于训练精度，在实际使用中 经常测试精度会大于训练精度。
达不到100%识别，本身技术水平达不到+数据集也会有标错的
10 不能假设数据集是完全正确的。还有数据人本身都无法分辨–hardcase。关心数据里面的误差。比较容易的case模型很容易训练好。

29.2 ResNet 为什么能训练处1000层的模型

https://www.bilibili.com/video/BV1554y157E3/?spm_id_from=autoNext&vd_source=eb04c9a33e87ceba9c9a2e5f09752ef8

ResNet的梯度计算

避免梯度消失：把乘法变加法。

怎么处理梯度消失的

假设省略loss， 希望偏y偏w不要很小，学习的不要很慢。
把网络加深，加一些层。
梯度怎么展开的–链式法则
导数和真实值预测值的区别是有一定关系的，预测比较好的情况下，导数会很小，做乘法后整体梯度会比原来梯度小很多。
假设残差网络为y" , 当g(x)的梯度很小的时候，加和的梯度也会比原来很小。大数+小数=大数 大数*小数=小数。当靠近底部的层，梯度会很小，避免梯度消失。
靠近数据端的w是很难训练的，由于有跳转，在训练一开始的时候，靠近数据端的网络就会拿到比较大的梯度。

QA

1 在靠近输入的学习率设大一些 靠近输出的lr学习率设小一些 可以缓解梯度消失的问题，但是调数比较难【设多大多小】。当超过浮点数的精度，计算会出问题， 小到很小梯度会为0， 精度fp16问题更明显一些。残差连接不需要调太多的东西。
2 梯度是累乘的， 深层的网络，梯度值和误差值有关，梯度回传越往网络底层会慢慢吸收掉误差，误差会越小。