动手学深度学习29 残差网络ResNet

本文主要是介绍动手学深度学习29 残差网络ResNet，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

动手学深度学习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 d2lclass 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 = 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:X = self.conv3(X)Y += Xreturn 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 blkb2 = 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 梯度是累乘的，深层的网络，梯度值和误差值有关，梯度回传越往网络底层会慢慢吸收掉误差，误差会越小。

这篇关于动手学深度学习29 残差网络ResNet的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！