动手学深度学习29 残差网络ResNet
- ResNet
- 代码
- ReLU的两种调用
- 1. 使用 `torch.nn.ReLU` 模块
- 2. 使用 `torch.nn.functional.relu` 函数
- 总结
- QA
- 29.2 ResNet 为什么能训练处1000层的模型
- ResNet的梯度计算
- 怎么处理梯度消失的
- QA
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 梯度是累乘的， 深层的网络，梯度值和误差值有关，梯度回传越往网络底层会慢慢吸收掉误差，误差会越小。
