经典的卷积神经网络模型 - ResNet

经典的卷积神经网络模型 - ResNet

flyfish

2015年，何恺明（Kaiming He）等人在论文《Deep Residual Learning for Image Recognition》中提出了ResNet（Residual Network，残差网络）。在当时，随着深度神经网络层数的增加，训练变得越来越困难，主要问题是梯度消失和梯度爆炸现象。即使使用各种优化技术和正则化方法，深层网络的表现仍然不如浅层网络。ResNet通过引入残差块（Residual Block）有效解决了这个问题，使得网络层数可以大幅度增加，同时还能显著提升模型的表现。

经典的卷积神经网络模型 - AlexNet
经典的卷积神经网络模型 - VGGNet
卷积层的输出
1x1卷积的作用

2. 残差（Residual）

在ResNet中，残差指的是输入值与输出值之间的差值。具体来说，假设输入为 x x x，经过一系列变换后的输出为 F ( x ) F(x) F(x)，ResNet引入了一条“快捷连接”（shortcut connection），直接将输入 x x x加入到输出 F ( x ) F(x) F(x)，最终的输出为 H ( x ) = F ( x ) + x H(x) = F(x) + x H(x)=F(x)+x。这种结构称为残差块（Residual Block）。

3. ResNet的不同版本

ResNet有多个不同版本，后面的数字表示网络层的数量。具体来说：

  • ResNet18: 18层
  • ResNet34: 34层
  • ResNet50: 50层
  • ResNet101: 101层
  • ResNet152: 152层

4. 常规残差模块

常规残差模块（Residual Block）包含两个3x3卷积层，每个卷积层后面跟着批归一化（Batch Normalization）和ReLU激活函数。假设输入为 x x x，经过第一层卷积、批归一化和ReLU后的输出为 F 1 ( x ) F_1(x) F1​(x)，再经过第二层卷积、批归一化后的输出为 F 2 ( F 1 ( x ) ) F_2(F_1(x)) F2​(F1​(x))。最终的输出是输入 x x x和 F 2 ( F 1 ( x ) ) F_2(F_1(x)) F2​(F1​(x))的和，即 H ( x ) = F ( x ) + x H(x) = F(x) + x H(x)=F(x)+x。
ResNet-18和ResNet-34使用的是BasicBlock。
在这里插入图片描述

5. 瓶颈残差模块（Bottleneck Residual Block）

瓶颈残差模块用于更深的ResNet版本（如ResNet50及以上），目的是减少计算量和参数量。瓶颈残差模块包含三个卷积层：一个1x1卷积层用于降维，一个3x3卷积层用于特征提取，最后一个1x1卷积层用于升维。假设输入为 x x x，经过1x1卷积降维后的输出为 F 1 ( x ) F_1(x) F1​(x)，再经过3x3卷积后的输出为 F 2 ( F 1 ( x ) ) F_2(F_1(x)) F2​(F1​(x))，最后经过1x1卷积升维后的输出为 F 3 ( F 2 ( F 1 ( x ) ) ) F_3(F_2(F_1(x))) F3​(F2​(F1​(x)))。最终的输出是输入 x x x和 F 3 ( F 2 ( F 1 ( x ) ) ) F_3(F_2(F_1(x))) F3​(F2​(F1​(x)))的和，即 H ( x ) = F ( x ) + x H(x) = F(x) + x H(x)=F(x)+x。ResNet-50、ResNet-101和ResNet-152使用的是Bottleneck。
在这里插入图片描述

6. 快捷连接（shortcut connection ）

快捷连接（shortcut connection），即直接将输入 x x x加到输出 F ( x ) F(x) F(x)上，从而避免了梯度消失和梯度爆炸问题。

import torchvision.models as models
resnet18 = models.resnet18()
print(resnet18)

ResNet(
  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace=True)
  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  (layer1): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
    (1): BasicBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer2): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer3): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (layer4): Sequential(
    (0): BasicBlock(
      (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
        (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): BasicBlock(
      (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    )
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
  (fc): Linear(in_features=512, out_features=1000, bias=True)
)

自定义实现ResNet-18

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):
        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.relu = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)

        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != self.expansion * out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, self.expansion * out_channels, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(self.expansion * out_channels)
            )

    def forward(self, x):
        out = self.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        out += self.shortcut(x)
        out = self.relu(out)
        return out

class ResNet(nn.Module):
    def __init__(self, block, num_blocks, num_classes=1000):
        super(ResNet, self).__init__()
        self.in_channels = 64

        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)

        self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)
        self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)
        self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)
        self.layer4 = self._make_layer(block, 512, num_blocks[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, num_blocks, stride):
        layers = []
        layers.append(block(self.in_channels, out_channels, stride))
        self.in_channels = out_channels * block.expansion
        for _ in range(1, num_blocks):
            layers.append(block(self.in_channels, out_channels))
        return nn.Sequential(*layers)

    def forward(self, x):
        x = self.relu(self.bn1(self.conv1(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

def resnet18(num_classes=1000):
    return ResNet(BasicBlock, [2, 2, 2, 2], num_classes)

# Example usage
model = resnet18()
print(model)

自定义实现ResNet-18、ResNet-34、ResNet-50、ResNet-101和ResNet-152

ResNet-18和ResNet-34使用的是BasicBlock，而ResNet-50、ResNet-101和ResNet-152使用的是Bottleneck。

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):
        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.relu = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)

        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != self.expansion * out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, self.expansion * out_channels, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(self.expansion * out_channels)
            )

    def forward(self, x):
        out = self.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        out += self.shortcut(x)
        out = self.relu(out)
        return out

class Bottleneck(nn.Module):
    expansion = 4

    def __init__(self, in_channels, out_channels, stride=1):
        super(Bottleneck, self).__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)
        self.conv3 = nn.Conv2d(out_channels, out_channels * self.expansion, kernel_size=1, bias=False)
        self.bn3 = nn.BatchNorm2d(out_channels * self.expansion)
        self.relu = nn.ReLU(inplace=True)

        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != out_channels * self.expansion:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels * self.expansion, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(out_channels * self.expansion)
            )

    def forward(self, x):
        out = self.relu(self.bn1(self.conv1(x)))
        out = self.relu(self.bn2(self.conv2(out)))
        out = self.bn3(self.conv3(out))
        out += self.shortcut(x)
        out = self.relu(out)
        return out

class ResNet(nn.Module):
    def __init__(self, block, num_blocks, num_classes=1000):
        super(ResNet, self).__init__()
        self.in_channels = 64

        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)

        self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)
        self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)
        self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)
        self.layer4 = self._make_layer(block, 512, num_blocks[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, num_blocks, stride):
        layers = []
        layers.append(block(self.in_channels, out_channels, stride))
        self.in_channels = out_channels * block.expansion
        for _ in range(1, num_blocks):
            layers.append(block(self.in_channels, out_channels))
        return nn.Sequential(*layers)

    def forward(self, x):
        x = self.relu(self.bn1(self.conv1(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

def resnet18(num_classes=1000):
    return ResNet(BasicBlock, [2, 2, 2, 2], num_classes)

def resnet34(num_classes=1000):
    return ResNet(BasicBlock, [3, 4, 6, 3], num_classes)

def resnet50(num_classes=1000):
    return ResNet(Bottleneck, [3, 4, 6, 3], num_classes)

def resnet101(num_classes=1000):
    return ResNet(Bottleneck, [3, 4, 23, 3], num_classes)

def resnet152(num_classes=1000):
    return ResNet(Bottleneck, [3, 8, 36, 3], num_classes)

# Example usage
model_18 = resnet18()
model_34 = resnet34()
model_50 = resnet50()
model_101 = resnet101()
model_152 = resnet152()

print(model_18)
print(model_34)
print(model_50)
print(model_101)
print(model_152)

网络结构

以ResNet18和ResNet50的结构举例
因为ResNet-18和ResNet-34使用的是BasicBlock，ResNet-50、ResNet-101和ResNet-152使用的是Bottleneck，可以区分看。

ResNet18

  • 输入：224x224图像

  • 卷积层：7x7卷积，64个过滤器，步长2

  • 最大池化层：3x3，步长2

  • 残差模块：

    • 2个Basic Block，每个包含2个3x3卷积层（64个过滤器）

    • 2个Basic Block，每个包含2个3x3卷积层（128个过滤器）

    • 2个Basic Block，每个包含2个3x3卷积层（256个过滤器）

    • 2个Basic Block，每个包含2个3x3卷积层（512个过滤器）

  • 全局平均池化层

  • 全连接层：1000个单元（对应ImageNet的1000个类别）

用参数表示就是 [2, 2, 2, 2]

ResNet50

  • 输入：224x224图像

  • 卷积层：7x7卷积，64个过滤器，步长2

  • 最大池化层：3x3，步长2

  • 残差模块：

    • 3个Bottleneck Block，每个包含1x1降维、3x3卷积、1x1升维（256个过滤器）

    • 4个Bottleneck Block，每个包含1x1降维、3x3卷积、1x1升维（512个过滤器）

    • 6个Bottleneck Block，每个包含1x1降维、3x3卷积、1x1升维（1024个过滤器）

    • 3个Bottleneck Block，每个包含1x1降维、3x3卷积、1x1升维（2048个过滤器）

  • 全局平均池化层

  • 全连接层：1000个单元（对应ImageNet的1000个类别）

用参数表示就是 [3, 4, 6, 3]

列表参数表示每个阶段（layer）中包含的残差块（residual block）的数量。ResNet的网络结构通常分为多个阶段，每个阶段包含多个残差块。这些残差块可以是常规的（BasicBlock）或瓶颈的（Bottleneck）。具体来说：

[2, 2, 2, 2] 表示第1个阶段有2个残差块，第2个阶段有2个残差块，第3个阶段有2个残差块，第4个阶段有2个残差块。
[3, 4, 6, 3] 表示第1个阶段有3个残差块，第2个阶段有4个残差块，第3个阶段有6个残差块，第4个阶段有3个残差块。

BasicBlock: 实现了常规残差模块，包含两个3x3的卷积层。用于ResNet-18和ResNet-34。
Bottleneck: 实现了瓶颈残差模块，包含一个1x1卷积层、一个3x3卷积层和另一个1x1卷积层。用于ResNet-50、ResNet-101和ResNet-152。

identity shortcut和projection shortcut

import torchvision.models as models
model = models.resnet50()
print(model)

完整内容自行打印看，这里主要说明 identity shortcut和projection shortcut

ResNet(
  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace=True)
  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  (layer1): Sequential(
    (0): Bottleneck(
      (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (downsample): Sequential(
        (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (1): Bottleneck(
      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
    (2): Bottleneck(
      (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
      (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
    )
  )
  ......

在 ResNet 中，identity shortcut 和 projection shortcut 主要出现在 Bottleneck 模块中。

  1. Identity Shortcut : 这是直接跳过层的快捷方式，输入直接添加到输出。通常在输入和输出维度相同时使用。在模型输出中可以看到，如 layer1 的第 1 和第 2 个 Bottleneck：
(1): Bottleneck(
  (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
  (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
  (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace=True)
)

可以看到这里没有 downsample 层，所以输入和输出直接相加。

  1. Projection Shortcut : 这是使用卷积层调整维度的快捷方式，用于当输入和输出维度不同时。在模型输出中可以看到，如 layer1 的第 0 个 Bottleneck：
(0): Bottleneck(
  (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
  (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
  (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace=True)
  (downsample): Sequential(
    (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  )
)

这里有一个 downsample 层，通过卷积和批量归一化调整输入的维度以匹配输出。
在这里插入图片描述

  • Identity Shortcut : 左侧图，没有 downsample 层。如果要写上downsample也是 (downsample): Sequential()括号里是空的

  • Projection Shortcut :右侧图 有 downsample 层，用于调整维度。 比如

(downsample): Sequential(
    (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
    (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  )

Bottleneck 结构中，f 通常表示瓶颈层的过滤器（或通道）数。
在 Bottleneck 模块中，通常有三层卷积：
第一个 1x1 卷积，用于降低维度，通道数是 f。
第二个 3x3 卷积，用于在降低维度的情况下进行卷积操作，通道数也是 f。
第三个 1x1 卷积，用于恢复维度，通道数是 4f。

如果要保证输出的特征图大小是固定的（如 1x1），自适应平均池化或者全局平均池化是最常用的选择；如果要调整通道数并保持空间结构，则可以用 1x1 卷积和池化的组合。
无论输入的特征图大小是多少，自适应平均池化都可以将其调整到一个指定的输出大小。在 ResNet 中使用的 AdaptiveAvgPool2d(output_size=(1, 1)) 会将输入的特征图调整到大小为 1x1。通过将特征图大小固定，可以更容易地设计网络结构，尤其是全连接层的输入部分。例如，将特征图调整到 1x1 后，后面的全连接层只需要处理固定数量的特征，不用考虑输入图像的大小变化。在特征图被调整到较小的大小（例如 1x1）后，随后的全连接层所需的参数和计算量会显著减少。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/765293.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

搜狐新闻HarmonyOS版本 push 推送开发

搜狐新闻HarmonyOS版本 push 推送开发

背景 搜狐新闻作为HarmonyOS的合作伙伴，于2023年12月成功上架鸿蒙单框架应用市场，成为首批鸿蒙应用矩阵的一员。 新闻类推送作为应用的重要组成部分，在二期规划中，我们将推送功能列为核心功能模块。本文将推送集成过程中的步骤和…
阅读更多...
360的chromesafe64.dll动态链接库导致chrome和edge浏览器闪退崩溃关闭

360的chromesafe64.dll动态链接库导致chrome和edge浏览器闪退崩溃关闭

在chrome或edge浏览器中打开特定的一些网页会导致浏览器闪退关闭 这是windows系统记录的报错日志 chrome报错日志 edge报错日志 日志指向的就是chromesafe64.dll这个动态库 然后用everything搜索发现原来在360安装目录下 360安装目录下的chromesafe64.dll文件 为什么360中的…
阅读更多...
NSSCTF-Web题目21（文件上传-phar协议、RCE-空格绕过）

NSSCTF-Web题目21（文件上传-phar协议、RCE-空格绕过）

目录 [NISACTF 2022]bingdundun~ 1、题目 2、知识点 3、思路 [FSCTF 2023]细狗2.0 4、题目 5、知识点 6、思路 [NISACTF 2022]bingdundun~ 1、题目 2、知识点 文件上传，phar伪协议 3、思路 点击upload，看看 这里提示我们可以上传图片或压缩包&…
阅读更多...
【CSAPP】-binarybomb实验

【CSAPP】-binarybomb实验

目录 实验目的与要求 实验原理与内容 实验设备与软件环境 实验过程与结果（可贴图） 操作异常问题与解决方案 实验总结 实验目的与要求 1. 增强学生对于程序的机器级表示、汇编语言、调试器和逆向工程等方面原理与技能的掌握。 2. 掌握使用gdb调试器…
阅读更多...
生命在于学习——Python人工智能原理（3.1.2）

生命在于学习——Python人工智能原理（3.1.2）

一、概率基本知识 1.3 常见概型 1.3.1 古典概型 定义1 古典概型 若随机事件E满足如下两个条件： （1）样本空间S中只有有限个样本点。 （2）样本空间S中每个样本点发生都是等可能的。 这样的随机试验称为古典概型。 P(A)…
阅读更多...
JavaMySQL 学习（基础）

JavaMySQL 学习（基础）

目录 Java CMD Java发展 计算机存储规则 Java学习 switch新用法（可以当做if来使用） 数组定义 随机数 Java内存分配 MySQL MySQL概述 启动和停止 客户端连接 数据模型 关系型数据库 SQL SQL通用语法 SQL分类 DDL--数据定义语言 数据库…
阅读更多...
GPT-4o不仅能写代码，还能自查Bug，程序员替代进程再进一步！

GPT-4o不仅能写代码，还能自查Bug，程序员替代进程再进一步！

目录 1 CriticGPT 01 综合性（Comprehensiveness）： 02 幻觉问题（Hallucinates a problem）： 2 其他 CriticGPT 案例 随着人工智能（AI）技术不断进步，AI在编程领域的应用…
阅读更多...
产品设计的8大步骤

产品设计的8大步骤

产品设计，通俗来说就是将创新想法或概念转化为落地实体的过程。一般来说，一个成功的产品应当具有创新性、美观性、实用性、可持续性以及经济效益，从而满足用户的使用需求以及市场的发展需求。产品设计也并不是一件简单的事情，产品…
阅读更多...
STM32第十五课：LCD屏幕及应用

STM32第十五课：LCD屏幕及应用

文章目录 需求一、LCD显示屏二、全屏图片三、数据显示1.显示欢迎词2.显示温湿度3.显示当前时间 四、需求实现代码 需求 1.在LCD屏上显示一张全屏图片。 2.在LCD屏上显示当前时间，温度，湿度。 一、LCD显示屏 液晶显示器，简称 LCD(Liquid Cry…
阅读更多...
flex布局中子元素内容超出时，子元素本身出现滚动条实现方法

flex布局中子元素内容超出时，子元素本身出现滚动条实现方法

flex布局中子元素宽度平均分配，并且当子元素内容超出时，子元素本身出现滚动条实现方法： 将父元素设置为display: flex，以启用Flexbox布局。将每个子元素的flex属性设置为1，以使其宽度平均分配。设置子元素的overflow属…
阅读更多...
CVE-2019-12272 Openwrt可视页面LuCi命令注入漏洞复现（完结）

CVE-2019-12272 Openwrt可视页面LuCi命令注入漏洞复现（完结）

声明 本文所使用的一些源代码等内容已经上传至github，具体地址如下 Vulnerability_POC-EXP/OpenWrt/CVE-2019-12272 at main a2148001284/Vulnerability_POC-EXP GitHub 漏洞简介 参考内容： CVE-2019-12272 OpenWrt图形化管理界面LuCI命令注入分析 |…
阅读更多...
【吴恩达机器学习-week2】可选实验：使用 Scikit-Learn 进行线性回归

【吴恩达机器学习-week2】可选实验：使用 Scikit-Learn 进行线性回归

支持我的工作 🎉 📃亲爱的朋友们，感谢你们一直以来对我的关注和支持！ 💪🏻 为了提供更优质的内容和更有趣的创作，我付出了大量的时间和精力。如果你觉得我的内容对你有帮助或带来了欢乐&#xf…
阅读更多...
springboot项目jar包修改数据库配置运行时异常

springboot项目jar包修改数据库配置运行时异常

一、背景 我将软件成功打好jar包了，到部署的时候发现jar包中数据库配置写的有问题，不想再重新打包了，打算直接修改配置文件，结果修改配置后，再通过java -jar运行时就报错了。 二、问题描述 本地项目是springBoot项目…
阅读更多...
Git使用——首次创建本地仓库、配置、初始化、关联远程仓库

Git使用——首次创建本地仓库、配置、初始化、关联远程仓库

1、安装 Git软件 官网：git-scm.com 有时候官网打不开，这里留存个之前下载过的安装包： https://download.csdn.net/download/weixin_43908355/89502977 2、配置本地仓库 在准备建仓库的文件夹里，右键点击：Git Bash …
阅读更多...
Cybervadis认证是什么？

Cybervadis认证是什么？

Cybervadis认证是一种全面且深入的网络安全评估和认证服务，旨在帮助组织提高其网络安全实践的成熟度，并有效应对不断变化的网络威胁和攻击。以下是关于Cybervadis认证的一些关键信息： 认证目的： 评估和验证组织在网络安全方面的能…
阅读更多...
HMI 的 UI 风格成就经典

HMI 的 UI 风格成就经典

HMI 的 UI 风格成就经典
阅读更多...
SAR目标检测

SAR目标检测

Multi-Stage with Filter Augmentation 多阶段滤波器增强(MSFA) 对SAR合成孔径雷达目标检测性能的改善 MSFA ON SAR 传统方法: 预训练:传统方法开始于在通用数据集上预训练一个基础模型。 微调:这个预训练的模型会被微调以适应特定的SAR图像，试图缩小域间的差距 …
阅读更多...
git命令含有中文，终端输出中文乱码的问题

git命令含有中文，终端输出中文乱码的问题

目录 1、[当前代码页] 的936 (ANSI/OEM - 简体中文 GBK) 是导致中文乱码的原因 2、这样会导致什么问题呢？ (1) 问题一: 【属性】选项的【字体】无法识别自定义文字样式，【默认值】选项可选自定义字体样式，却无法覆盖【属性】选项 (2) 问题…
阅读更多...
AutoCAD Mechanical下载安装；Mechanical针对机械设计领域开发的CAD软件下载安装！

AutoCAD Mechanical下载安装；Mechanical针对机械设计领域开发的CAD软件下载安装！

在AutoCAD Mechanical的助力下，用户能够轻松应对二维绘图与三维建模两大核心任务。二维绘图方面，软件提供了精准且灵活的绘图工具，使得工程师能够迅速勾勒出机械部件的轮廓与细节，大大提高了工作效率。 而在三维建模方面&#xff…
阅读更多...
继承QAbstractListModel，结合QListView

继承QAbstractListModel，结合QListView

这里想要写一个QAbstractListModel的子类&#xff0c;学习一下如何实例化QAbstractListModel。 QAbstractListModel子类化-CSDN博客 QVariant与自定义类型互转之奇巧淫技_qt 类型转 qvariant-CSDN博客 #pragma once#include <QStyledItemDelegate> #include <qmeta…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站