【深度学习】最强算法之：残差网络（ResNet）

1、引言

小屌丝：鱼哥，深度神经网络是不是少了一篇没写
小鱼：少了哪篇？

小屌丝：额… 就是 内个…
小鱼：你倒是说啊， 哪个啊？
小屌丝：就…就是
小鱼：赶紧说，别墨迹
小屌丝：ResNet
小鱼：咳， 我还以为哪篇了
小屌丝：那…是不是要更新啊
小鱼：好说好说。
小屌丝： 哇塞。

2、残差网络

2.1 定义

残差网络（Residual Network，简称ResNet）是由Kaiming He等人在2015年提出的一种深度神经网络架构。

ResNet的核心思想是引入了“残差学习”的概念来解决深度神经网络训练中的梯度消失/梯度爆炸问题，使得网络能够通过简单地增加层数来提高准确率，而不会导致训练困难。

2.2 原理

残差网络的核心原理是通过残差模块来构建深层网络。

在传统的神经网络中，每一层的输出是下一层的输入。

而在残差网络中，每一层的输入不仅会传递给下一层，还会通过跳跃连接（skip connection）直接传递给更深的层次。

这种设计允许梯度直接流过这些跳跃连接，从而缓解了深层网络中的梯度消失问题。

2.3 实现方式

残差网络的实现主要包括以下步骤：

• 构建残差块：
  • 每个残差块包含两个或三个卷积层，以及一个跨层的直接连接。
  • 对于两层残差块（称为basic block），输入首先经过一个卷积层（通常为3x3卷积），然后通过ReLU激活函数，再经过另一个卷积层，最后与原始输入（通过恒等映射或1x1卷积进行维度匹配）相加。
  • 对于三层残差块（称为bottleneck block），中间还包含一个1x1卷积层用于减少通道数，从而减少计算量。
• 堆叠残差块：将多个残差块堆叠在一起，形成完整的残差网络。根据任务需求和网络深度，可以选择使用不同类型的残差块和堆叠方式。
• 添加其他组件：在残差网络的开头和结尾，可以添加其他组件，如卷积层、池化层、全连接层等，以满足特定的任务需求。

2.4 算法公式

残差模块的基本形式可以用以下公式表示：

$$[\mathbf{y}=\mathcal{F}(\mathbf{x},W_i)+\mathbf{x}]$$

其中，

• $(\mathbf{x})$和$(\mathbf{y})$分别是模块的输入和输出，
• $(\mathcal{F}(\mathbf{x}$,$W_i))$表示卷积层或全连接层的堆叠所进行的操作，
• $(W_i)$是这些层的权重，$(\mathbf{x})$表示通过跳跃连接直接传递的输入。

2.5 代码示例

# -*- coding:utf-8 -*-
# @Time   : 2024-05-02
# @Author : Carl_DJ

import torch
import torch.nn as nn
import torch.nn.functional as F

# 定义残差块
class BasicBlock(nn.Module):
    expansion = 1

    def __init__(self, in_channels, out_channels, stride=1, downsample=None):
        super(BasicBlock, self).__init__()
        # 第一个卷积层
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channels)
        # 第二个卷积层
        self.conv2 = nn.Conv2d(out_channels, out_channels * self.expansion, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels * self.expansion)
        self.relu = nn.ReLU(inplace=True)
        self.downsample = downsample

    def forward(self, x):
        identity = x

        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)

        out = self.conv2(out)
        out = self.bn2(out)

        if self.downsample is not None:
            identity = self.downsample(x)

        out += identity
        out = self.relu(out)

        return out

# 构建ResNet模型
class ResNet(nn.Module):
    def __init__(self, block, layers, num_classes=1000):
        super(ResNet, self).__init__()
        self.in_channels = 64
        # 初始卷积层
        self.conv1 = nn.Conv2d(3, self.in_channels, kernel_size=7, stride=2, padding=3, bias=False)
        self.bn1 = nn.BatchNorm2d(self.in_channels)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        # 残差层
        self.layer1 = self._make_layer(block, 64, layers[0])
        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(512 * block.expansion, num_classes)

    def _make_layer(self, block, out_channels, blocks, stride=1):
        downsample = None
        if stride != 1 or self.in_channels != out_channels * block.expansion:
            downsample = nn.Sequential(
                nn.Conv2d(self.in_channels, out_channels * block.expansion, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(out_channels * block.expansion),
            )

        layers = []
        layers.append(block(self.in_channels, out_channels, stride, downsample))
        self.in_channels = out_channels * block.expansion
        for _ in range(1, blocks):
            layers.append(block(self.in_channels, out_channels))

        return nn.Sequential(*layers)

    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)

        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)

        x = self.avgpool(x)
        x = torch.flatten(x, 1)
        x = self.fc(x)

        return x

# 实例化ResNet模型并应用于输入数据
def resnet18():
    return ResNet(BasicBlock, [2, 2, 2, 2])

model = resnet18()
print(model)

# 假设我们有一批大小为4的输入数据
input_tensor = torch.rand(4, 3, 224, 224)
output = model(input_tensor)
print(output.size())


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

代码解析：

• 首先，定义了BasicBlock类，它是构成ResNet的基本残差块。
• 然后，定义了ResNet类，它通过重复堆叠BasicBlock来构建整个网络。
  • 在ResNet类中，_make_layer方法用于生成每个残差层。
  • resnet18函数通过特定的配置来实例化一个18层深的ResNet模型。
• 最后，代码实例化了一个模型，并对一个随机生成的输入张量进行了一次前向传播，以展示模型的使用方式。

3、总结

残差网络（ResNet）通过引入跳跃连接解决了深度神经网络训练中的关键问题，使得网络能够在不增加额外参数和计算复杂度的情况下增加深度，显著提高了深度学习模型的性能。

ResNet的成功推动了深度学习在诸多领域的应用，如图像分类、物体检测和语义分割等。

我是小鱼：

• CSDN 博客专家；
• 阿里云 专家博主；
• 51CTO博客专家；
• 企业认证金牌面试官；
• 多个名企认证&特邀讲师等；
• 名企签约职场面试培训、职场规划师；
• 多个国内主流技术社区的认证专家博主；
• 多款主流产品(阿里云等)测评一、二等奖获得者；

关注小鱼，学习【机器学习】&【深度学习】领域的知识。