当前位置：个人在线分享 > 动手学深度学习29 残差网络ResNet

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

作者 : admin 本文共4658个字，预计阅读时间需要12分钟 发布时间： 2024-06-9 共2人阅读

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

  • ResNet
  • 代码
    • ReLU的两种调用
      • 1. 使用 `torch.nn.ReLU` 模块
      • 2. 使用 `torch.nn.functional.relu` 函数
      • 总结
  • QA
  • 29.2 ResNet 为什么能训练处1000层的模型
  • ResNet的梯度计算
    • 怎么处理梯度消失的
  • QA

ResNet

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

更复杂模型包含小模型，不一定改进，但是加更深的层更复杂的模型至少不会变差。
动手学深度学习29 残差网络ResNet插图(1)
复杂模型包含小模型，当要新加的层没有学到任何东西的时候，模型仍旧是可以学到前面层已经学到了的知识。可以认为是嵌入了小网络，允许先学习小网络。
动手学深度学习29 残差网络ResNet插图(2)
从vgg过来。1*1卷积是为了改变通道数，和ResNet块输出的通道数保持一致，这样能做对应位置元素加法。
动手学深度学习29 残差网络ResNet插图(3)
核心：加了一个加法。
动手学深度学习29 残差网络ResNet插图(4)
动手学深度学习29 残差网络ResNet插图(5)
动手学深度学习29 残差网络ResNet插图(6)

152个卷积层。层数越高精度越高。34个卷积层用的比较多。刷榜经常用152【实际使用很少，训练太贵】
动手学深度学习29 残差网络ResNet插图(7)
ResNet的思想 Residual Connections（残差连接）当前经常使用，例如 bert， transformer。

不管再深，总是先训练好小网络，再往深层训练。
动手学深度学习29 残差网络ResNet插图(8)

代码

用了比较大的输入。调优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:	', 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

动手学深度学习29 残差网络ResNet插图(9)

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

动手学深度学习29 残差网络ResNet插图(10)

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学习率 【效果挺好】 调参简单–调个最大值最小值。
动手学深度学习29 残差网络ResNet插图(11)
4 残差怎么理解
layer2在layer1的基础上训练一些误差，在layer1的基础上做叠加。底层网络没有fit好的东西，加深的网络继续去fit。
动手学深度学习29 残差网络ResNet插图(12)
5 * 解包裹传递参数 把list列表参数解包裹传参
6 两个BN有自己的参数要学 参数不一样
7 nn.ReLU(inplace=True) 原地更新参数 省一点内存
8 输入尺寸的确定，是由数据和框架确定？
9 当训练数据中加入了大量的噪音，测试精度会大于训练精度，在实际使用中 经常测试精度会大于训练精度。
达不到100%识别，本身技术水平达不到+数据集也会有标错的
10 不能假设数据集是完全正确的。还有数据人本身都无法分辨–hardcase。关心数据里面的误差。比较容易的case模型很容易训练好。

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

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

ResNet的梯度计算

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

怎么处理梯度消失的

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

QA

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

本站无任何商业行为
个人在线分享 » 动手学深度学习29 残差网络ResNet
admin

admin 钻石

分享到：

相关推荐

E-->