飞桨 | 基于 Paddle 从零开始实现 Resnet18 之 模型结构

最新推荐文章于 2024-02-21 23:18:47 发布
最新推荐文章于 2024-02-21 23:18:47 发布
阅读量4.9k 收藏 37
点赞数 6
分类专栏： Python基础 文章标签： 深度学习 计算机视觉 paddlepaddle
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39220334/article/details/121606060
版权

建模 Resnet18

Resnet18 是何恺明在论文 Deep Residual Learning for Image Recognition 中提出的一个卷积神经网络。本文将带你根据论文基于百度深度学习框架 paddle 从头开始实现 Resnet18 模型结构。

一、网络结构

首先，我们来看一下要实现的目标 Resnet18 的整体结构。然后，再将 Resnet18 拆成几个主要部件分别进行代码实现。

Resnet18 的整体结构

Resnet18 的整体结构如下图所示，共有 18 个有权重的层（卷积层和全连接层），池化层和 BN 层不计入层数。Resnet18 图片来源自 PyTorch实现ResNet18。

在这里插入图片描述

Resnet 18 的主要部件

Resnet18 主要包括 stem、block 和 head 三种部件。它们的结构如下图所示：

Block + Stem + Head
在这里插入图片描述

二、代码实现

那么如何用 stem、block 和 head 构成 Resnet18 呢？
为了简化代码，将两个 block 封装成一个 layer，所有 layer 组成 body。因此 Resnet18 由 stem、body 和 head 三个部分组成。
其中，

  • stem 包括一个 7x7 的卷积层，一个 3x3 的最大池化层
  • body 包括 4 个 layer，每个 layer 由两个 Block 组成
  • head 包括一个 average pool 层 和 fc 层

Resnet18 各层的具体参数如下，下面我们依照下图利用 paddle 开始实现 Resnet18。
在这里插入图片描述

利用 paddle 实现 Resnet18，首先需要导入必要的库

import paddle
import paddle.nn as nn

然后分别实现 block , stem 和 head 结构。在实现这些结构之前，先写一个 Identity 类，它的作用是保持输入和输出一致，直接返回输入

 # 定义一个类，直接返回输入，不对输入做任何操作
class Identity(nn.Layer):
    def __init_(self):
        super().__init__()

    def forward(self, x):
        return x

1. 定义 Block

残差块 block 的结构如下图所示，由两个卷积层和一个 shortcut 组成。shortcut 分为实线 shortcut 和 虚线 shortcut。

  • 实线 shortcut 的输入输出有相同的维度，故对输入特征执行 identity 保持输入输出一致即可
  • 虚线 shortcut 的输入输出有不同的维度，输出维度增加，故需要将输入维度扩展到输出维度大小，同时伴随特征图大小减半操作

在这里插入图片描述
Block 的代码实现如下：
先做两次卷积操作，再将 shortcut h 和 block 的输出 x 求和，返回二者之和即可。

# 定义残差块 Block
# 一个 Block 由两个卷积层组成
class Block(nn.Layer):
    def __init__(self, in_dim, out_dim, stride):
        super().__init__()
        self.conv1 = nn.Conv2D(in_dim, out_dim, 3, stride=stride, padding=1,bias_attr=False)
        self.bn1 = nn.BatchNorm2D(out_dim)
        self.conv2 = nn.Conv2D(out_dim, out_dim, 3, stride=1,padding=1,bias_attr=False)
        self.bn2 = nn.BatchNorm2D(out_dim)
        self.relu = nn.ReLU()

        # shortcut 分为 实线 shortcut 和 虚线 shortcut
        # 实线 shortcut 的输入输出有相同的维度，故无需处理
        # 虚线 shortcut 的输出维度增加，故需要将输入维度扩展到输出维度大小，同时令 stride=2 减小特征图大小
        
        # 当 滑动步长为 2 或者 特征图输入输出维度不相等时，为虚线 shortcut，需要下采样 
        if stride == 2 or in_dim != out_dim:
            # 增加维度 + 下采样调整大小
            self.downsample = nn.Sequential(*[
                nn.Conv2D(in_dim, out_dim, 1, stride = stride),
                nn.BatchNorm2D(out_dim)])
        else:
            # 实线 shortcut 不做操作，保持不变
            self.downsample = Identity()

    def forward(self, x):
        # shortcut
        h = x
        # 做两次卷积
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.conv2(x)
        x = self.bn2(x)
        # 对 shortcut h 做处理，方便连接 x
        identity = self.downsample(h)
        x = x + identity 
        x = self.relu(x)
        return x

2. 定义 Layer 层

body 中一共包括 4 个 layer，每个 layer 由两个 block 组成。第一个 block 可能会对特征图下采样（stride=2 或 stride=1），第二个 block 不会改变特征图大小（stride=1）。因此先将第一个 block 加入 layer，之后再循环加入剩余的 block。

def _make_layer(self, out_dim, n_blocks, stride):
    layers = []
    # 先加入一个 stride 不为 1 的 block，对特征图进行下采样
    layers.append(Block(self.in_dim,out_dim,stride=stride))
    self.in_dim = out_dim
    # 再加入 stride 为 1 的若干 block，特征图大小保持不变
    for i in range(1, n_blocks):
        layers.append(Block(self.in_dim, out_dim, stride=1))
    return nn.Sequential(*layers)

在这里插入图片描述
参考上图，layer1 —— layer4 的维度分别为

self.layer1 = self._make_layer(out_dim=64,  n_blocks=2, stride=1)
self.layer2 = self._make_layer(out_dim=128, n_blocks=2, stride=2)
self.layer3 = self._make_layer(out_dim=256, n_blocks=2, stride=2)
self.layer4 = self._make_layer(out_dim=512, n_blocks=2, stride=2)

3. 定义 stem 和 head

stem 包括一个 7x7 的卷积层，一个 3x3 的最大池化层。

        self.in_dim = in_dim
        self.conv1 = nn.Conv2D(in_channels=3, 
                        out_channels=in_dim, 
                        kernel_size=7,  
                        stride=2, 
                        padding=3,
                        bias_attr=False)

        self.bn1 = nn.BatchNorm2D(in_dim)
        self.relu = nn.ReLU()

        self.maxpool = nn.MaxPool2D(kernel_size=3, stride=2, padding=1)

head 包括一个 average pool 层 和 fc 层。

        self.avgpool = nn.AdaptiveAvgPool2D(1)
        self.classifier = nn.Linear(512, num_classes)

ResNet18 类的整体代码实现如下：

# 定义 ResNet18 类
# Resnet18 由 stem、body 和 head 三个部分组成
# 其中，stem 包括一个 7x7 的卷积层，一个 3x3 的最大池化层
# body 包括 4 个 layer，每个 layer 由两个 Block 组成
# head 包括一个 average pool 层 和 fc 层

class ResNet18(nn.Layer):
    def __init__(self, in_dim=64, num_classes=1000):
        super().__init__()
        self.in_dim = in_dim
        self.conv1 = nn.Conv2D(in_channels=3, 
                        out_channels=in_dim, 
                        kernel_size=7,  
                        stride=2, 
                        padding=3,
                        bias_attr=False)

        self.bn1 = nn.BatchNorm2D(in_dim)
        self.relu = nn.ReLU()

        self.maxpool = nn.MaxPool2D(kernel_size=3, stride=2, padding=1)

        self.layer1 = self._make_layer(out_dim=64,  n_blocks=2, stride=1)
        self.layer2 = self._make_layer(out_dim=128, n_blocks=2, stride=2)
        self.layer3 = self._make_layer(out_dim=256, n_blocks=2, stride=2)
        self.layer4 = self._make_layer(out_dim=512, n_blocks=2, stride=2)  

        self.avgpool = nn.AdaptiveAvgPool2D(1)
        self.classifier = nn.Linear(512, num_classes)   

    def _make_layer(self, out_dim, n_blocks, stride):
        layers = []
        # 先加入一个 stride 不为 1 的 block，对特征图进行下采样
        layers.append(Block(self.in_dim,out_dim,stride=stride))
        self.in_dim = out_dim
        # 再加入 stride 为 1 的若干 block，特征图大小保持不变
        for i in range(1, n_blocks):
            layers.append(Block(self.in_dim, out_dim, stride=1))
        return nn.Sequential(*layers)
        

    def forward(self, x):
        ## stem
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)
        ## body
        x = self.layer1(x)
        x = self.layer2(x)        
        x = self.layer3(x)
        x = self.layer4(x)        
        ## head
        x = self.avgpool(x)
        # 为了连接全连接层 fc, 即 classifier ,需要将特征展成一维
        x = x.flatten(1)
        x = self.classifier(x)
        return x

4. 输出模型结构

# 测试代码
def main():
    model = ResNet18()
    print(model)
    paddle.summary(model, (2, 3, 32, 32))
    # x = paddle.randn([2, 3, 32, 32])
    # out = model(x)
    # print(out.shape)

if __name__ == "__main__":
    main()

输出结果如下所示：

ResNet18(
  (conv1): Conv2D(3, 64, kernel_size=[7, 7], stride=[2, 2], padding=3, data_format=NCHW)
  (bn1): BatchNorm2D(num_features=64, momentum=0.9, epsilon=1e-05)
  (relu): ReLU()
  (maxpool): MaxPool2D(kernel_size=3, stride=2, padding=1)
  (layer1): Sequential(
    (0): Block(
      (conv1): Conv2D(64, 64, kernel_size=[3, 3], padding=1, data_format=NCHW)
      (bn1): BatchNorm2D(num_features=64, momentum=0.9, epsilon=1e-05)
      (conv2): Conv2D(64, 64, kernel_size=[3, 3], padding=1, data_format=NCHW)
      (bn2): BatchNorm2D(num_features=64, momentum=0.9, epsilon=1e-05)
      (relu): ReLU()
      (downsample): Identity()
    )
    (1): Block(
      (conv1): Conv2D(64, 64, kernel_size=[3, 3], padding=1, data_format=NCHW)
      (bn1): BatchNorm2D(num_features=64, momentum=0.9, epsilon=1e-05)
      (conv2): Conv2D(64, 64, kernel_size=[3, 3], padding=1, data_format=NCHW)
      (bn2): BatchNorm2D(num_features=64, momentum=0.9, epsilon=1e-05)
      (relu): ReLU()
      (downsample): Identity()
    )
  )
  (layer2): Sequential(
    (0): Block(
      (conv1): Conv2D(64, 128, kernel_size=[3, 3], stride=[2, 2], padding=1, data_format=NCHW)
      (bn1): BatchNorm2D(num_features=128, momentum=0.9, epsilon=1e-05)
      (conv2): Conv2D(128, 128, kernel_size=[3, 3], padding=1, data_format=NCHW)
      (bn2): BatchNorm2D(num_features=128, momentum=0.9, epsilon=1e-05)
      (relu): ReLU()
      (downsample): Sequential(
        (0): Conv2D(64, 128, kernel_size=[1, 1], stride=[2, 2], data_format=NCHW)
        (1): BatchNorm2D(num_features=128, momentum=0.9, epsilon=1e-05)
      )
    )
    (1): Block(
      (conv1): Conv2D(128, 128, kernel_size=[3, 3], padding=1, data_format=NCHW)
      (bn1): BatchNorm2D(num_features=128, momentum=0.9, epsilon=1e-05)
      (conv2): Conv2D(128, 128, kernel_size=[3, 3], padding=1, data_format=NCHW)
      (bn2): BatchNorm2D(num_features=128, momentum=0.9, epsilon=1e-05)
      (relu): ReLU()
      (downsample): Identity()
    )
  )
  (layer3): Sequential(
    (0): Block(
      (conv1): Conv2D(128, 256, kernel_size=[3, 3], stride=[2, 2], padding=1, data_format=NCHW)
      (bn1): BatchNorm2D(num_features=256, momentum=0.9, epsilon=1e-05)
      (conv2): Conv2D(256, 256, kernel_size=[3, 3], padding=1, data_format=NCHW)
      (bn2): BatchNorm2D(num_features=256, momentum=0.9, epsilon=1e-05)
      (relu): ReLU()
      (downsample): Sequential(
        (0): Conv2D(128, 256, kernel_size=[1, 1], stride=[2, 2], data_format=NCHW)
        (1): BatchNorm2D(num_features=256, momentum=0.9, epsilon=1e-05)
      )
    )
    (1): Block(
      (conv1): Conv2D(256, 256, kernel_size=[3, 3], padding=1, data_format=NCHW)
      (bn1): BatchNorm2D(num_features=256, momentum=0.9, epsilon=1e-05)
      (conv2): Conv2D(256, 256, kernel_size=[3, 3], padding=1, data_format=NCHW)
      (bn2): BatchNorm2D(num_features=256, momentum=0.9, epsilon=1e-05)
      (relu): ReLU()
      (downsample): Identity()
    )
  )
  (layer4): Sequential(
    (0): Block(
      (conv1): Conv2D(256, 512, kernel_size=[3, 3], stride=[2, 2], padding=1, data_format=NCHW)
      (bn1): BatchNorm2D(num_features=512, momentum=0.9, epsilon=1e-05)
      (conv2): Conv2D(512, 512, kernel_size=[3, 3], padding=1, data_format=NCHW)
      (bn2): BatchNorm2D(num_features=512, momentum=0.9, epsilon=1e-05)
      (relu): ReLU()
      (downsample): Sequential(
        (0): Conv2D(256, 512, kernel_size=[1, 1], stride=[2, 2], data_format=NCHW)
        (1): BatchNorm2D(num_features=512, momentum=0.9, epsilon=1e-05)
      )
    )
    (1): Block(
      (conv1): Conv2D(512, 512, kernel_size=[3, 3], padding=1, data_format=NCHW)
      (bn1): BatchNorm2D(num_features=512, momentum=0.9, epsilon=1e-05)
      (conv2): Conv2D(512, 512, kernel_size=[3, 3], padding=1, data_format=NCHW)
      (bn2): BatchNorm2D(num_features=512, momentum=0.9, epsilon=1e-05)
      (relu): ReLU()
      (downsample): Identity()
    )
  )
  (avgpool): AdaptiveAvgPool2D(output_size=1)
  (classifier): Linear(in_features=512, out_features=1000, dtype=float32)
)
-------------------------------------------------------------------------------
   Layer (type)         Input Shape          Output Shape         Param #    
===============================================================================
     Conv2D-61        [[2, 3, 32, 32]]     [2, 64, 16, 16]         9,408     
  BatchNorm2D-61     [[2, 64, 16, 16]]     [2, 64, 16, 16]          256      
      ReLU-28        [[2, 64, 16, 16]]     [2, 64, 16, 16]           0       
    MaxPool2D-4      [[2, 64, 16, 16]]      [2, 64, 8, 8]            0       
     Conv2D-62        [[2, 64, 8, 8]]       [2, 64, 8, 8]         36,864     
  BatchNorm2D-62      [[2, 64, 8, 8]]       [2, 64, 8, 8]           256      
      ReLU-29         [[2, 64, 8, 8]]       [2, 64, 8, 8]            0       
     Conv2D-63        [[2, 64, 8, 8]]       [2, 64, 8, 8]         36,864     
  BatchNorm2D-63      [[2, 64, 8, 8]]       [2, 64, 8, 8]           256      
    Identity-16       [[2, 64, 8, 8]]       [2, 64, 8, 8]            0       
     Block-25         [[2, 64, 8, 8]]       [2, 64, 8, 8]            0       
     Conv2D-64        [[2, 64, 8, 8]]       [2, 64, 8, 8]         36,864     
  BatchNorm2D-64      [[2, 64, 8, 8]]       [2, 64, 8, 8]           256      
      ReLU-30         [[2, 64, 8, 8]]       [2, 64, 8, 8]            0       
     Conv2D-65        [[2, 64, 8, 8]]       [2, 64, 8, 8]         36,864     
  BatchNorm2D-65      [[2, 64, 8, 8]]       [2, 64, 8, 8]           256      
    Identity-17       [[2, 64, 8, 8]]       [2, 64, 8, 8]            0       
     Block-26         [[2, 64, 8, 8]]       [2, 64, 8, 8]            0       
     Conv2D-66        [[2, 64, 8, 8]]       [2, 128, 4, 4]        73,728     
  BatchNorm2D-66      [[2, 128, 4, 4]]      [2, 128, 4, 4]          512      
      ReLU-31         [[2, 128, 4, 4]]      [2, 128, 4, 4]           0       
     Conv2D-67        [[2, 128, 4, 4]]      [2, 128, 4, 4]        147,456    
  BatchNorm2D-67      [[2, 128, 4, 4]]      [2, 128, 4, 4]          512      
     Conv2D-68        [[2, 64, 8, 8]]       [2, 128, 4, 4]         8,320     
  BatchNorm2D-68      [[2, 128, 4, 4]]      [2, 128, 4, 4]          512      
     Block-27         [[2, 64, 8, 8]]       [2, 128, 4, 4]           0       
     Conv2D-69        [[2, 128, 4, 4]]      [2, 128, 4, 4]        147,456    
  BatchNorm2D-69      [[2, 128, 4, 4]]      [2, 128, 4, 4]          512      
      ReLU-32         [[2, 128, 4, 4]]      [2, 128, 4, 4]           0       
     Conv2D-70        [[2, 128, 4, 4]]      [2, 128, 4, 4]        147,456    
  BatchNorm2D-70      [[2, 128, 4, 4]]      [2, 128, 4, 4]          512      
    Identity-18       [[2, 128, 4, 4]]      [2, 128, 4, 4]           0       
     Block-28         [[2, 128, 4, 4]]      [2, 128, 4, 4]           0       
     Conv2D-71        [[2, 128, 4, 4]]      [2, 256, 2, 2]        294,912    
  BatchNorm2D-71      [[2, 256, 2, 2]]      [2, 256, 2, 2]         1,024     
      ReLU-33         [[2, 256, 2, 2]]      [2, 256, 2, 2]           0       
     Conv2D-72        [[2, 256, 2, 2]]      [2, 256, 2, 2]        589,824    
  BatchNorm2D-72      [[2, 256, 2, 2]]      [2, 256, 2, 2]         1,024     
     Conv2D-73        [[2, 128, 4, 4]]      [2, 256, 2, 2]        33,024     
  BatchNorm2D-73      [[2, 256, 2, 2]]      [2, 256, 2, 2]         1,024     
     Block-29         [[2, 128, 4, 4]]      [2, 256, 2, 2]           0       
     Conv2D-74        [[2, 256, 2, 2]]      [2, 256, 2, 2]        589,824    
  BatchNorm2D-74      [[2, 256, 2, 2]]      [2, 256, 2, 2]         1,024     
      ReLU-34         [[2, 256, 2, 2]]      [2, 256, 2, 2]           0       
     Conv2D-75        [[2, 256, 2, 2]]      [2, 256, 2, 2]        589,824    
  BatchNorm2D-75      [[2, 256, 2, 2]]      [2, 256, 2, 2]         1,024     
    Identity-19       [[2, 256, 2, 2]]      [2, 256, 2, 2]           0       
     Block-30         [[2, 256, 2, 2]]      [2, 256, 2, 2]           0       
     Conv2D-76        [[2, 256, 2, 2]]      [2, 512, 1, 1]       1,179,648   
  BatchNorm2D-76      [[2, 512, 1, 1]]      [2, 512, 1, 1]         2,048     
      ReLU-35         [[2, 512, 1, 1]]      [2, 512, 1, 1]           0       
     Conv2D-77        [[2, 512, 1, 1]]      [2, 512, 1, 1]       2,359,296   
  BatchNorm2D-77      [[2, 512, 1, 1]]      [2, 512, 1, 1]         2,048     
     Conv2D-78        [[2, 256, 2, 2]]      [2, 512, 1, 1]        131,584    
  BatchNorm2D-78      [[2, 512, 1, 1]]      [2, 512, 1, 1]         2,048     
     Block-31         [[2, 256, 2, 2]]      [2, 512, 1, 1]           0       
     Conv2D-79        [[2, 512, 1, 1]]      [2, 512, 1, 1]       2,359,296   
  BatchNorm2D-79      [[2, 512, 1, 1]]      [2, 512, 1, 1]         2,048     
      ReLU-36         [[2, 512, 1, 1]]      [2, 512, 1, 1]           0       
     Conv2D-80        [[2, 512, 1, 1]]      [2, 512, 1, 1]       2,359,296   
  BatchNorm2D-80      [[2, 512, 1, 1]]      [2, 512, 1, 1]         2,048     
    Identity-20       [[2, 512, 1, 1]]      [2, 512, 1, 1]           0       
     Block-32         [[2, 512, 1, 1]]      [2, 512, 1, 1]           0       
AdaptiveAvgPool2D-4   [[2, 512, 1, 1]]      [2, 512, 1, 1]           0       
     Linear-4            [[2, 512]]           [2, 1000]           513,000    
===============================================================================
Total params: 11,700,008
Trainable params: 11,680,808
Non-trainable params: 19,200
-------------------------------------------------------------------------------
Input size (MB): 0.02
Forward/backward pass size (MB): 2.53
Params size (MB): 44.63
Estimated Total Size (MB): 47.19
-------------------------------------------------------------------------------

三、相关API

1. Conv2D

class paddle.nn.Conv2D(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, padding_mode='zeros', weight_attr=None, bias_attr=None, data_format='NCHW')

2. BatchNorm

class paddle.nn.BatchNorm(num_channels, act=None, is_test=False, momentum=0.9, epsilon=1e-05, param_attr=None, bias_attr=None, dtype='float32', data_layout='NCHW', in_place=False, moving_mean_name=None, moving_variance_name=None, do_model_average_for_mean_and_var=False, use_global_stats=False, trainable_statistics=False)

3. Relu

paddle.nn.functional.relu(x, name=None)

4. AdaptiveAvgPool2D

paddle.nn.AdaptiveAvgPool2D(output_size, data_format='NCHW', name=None)

5. MaxPool2D

paddle.nn.MaxPool2D(kernel_size, stride=None, padding=0, ceil_mode=False, return_mask=False, data_format='NCHW', name=None)

6. nn.Sequential(*layers)

针对顺序的线性网络结构可以直接使用Sequential来快速完成组网，可以减少类的定义等代码编写。

下面 paddle 上的一个示例

import paddle

# Sequential形式组网
mnist = paddle.nn.Sequential(
    paddle.nn.Flatten(),
    paddle.nn.Linear(784, 512),
    paddle.nn.ReLU(),
    paddle.nn.Dropout(0.2),
    paddle.nn.Linear(512, 10)
)

参考链接

  1. PyTorch实现ResNet18
  2. 从零开始学视觉Transformer
star_function
关注
  • 6
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
18 深度学习案例——基于卷积神经网络的手写体识别
01-20
基于卷积神经网络的手写体识别19.2 深度学习的概念及关键技术1、神经网络模型2、深度学习之卷积神经网络19.3 Python深度学习库——Keras1、Keras的安装2、Keras的网络层3、用Keras构建神经网络19.4 程序设计的思路19.5 源代码1、MNIST数据集2、手写体识别案例体现3、预测自己手写图像 #!/usr/bin/env python # coding: utf-8 19.2 深度学习的概念及关键技术 1、神经网络模型 ·生物神经元 ·轴突（输出）终端为其他神经元的树突（输入） ·人工神经网络 2、深度学习之卷积神经网络 ·深度学习结构：含有多隐层的神经网络。
读pytroch使用resnet18网络的代码
airleaya的博客
10-11 2836
读读pytorch中调用resnet18的代码
Paddle模型结构可视化
qq_42615735的博客
02-21 884
使用paddle框架中的paddle.jit.save将模型保存至本地并使用visualdl将模型可视化
经典网络结构总结–ResNet系列
01-06
ResNet 论文：Deep Residual Learning for Image Recognition Motivation：网络越深，能获取的信息越多，而且特征也越丰富。但是根据实验表明，随着网络的加深，优化效果反而越差，测试数据和训练数据的准确率反而降低了（网络退化）。为了让更深的网络也能训练出好的效果，何凯明大神提出了一个新的网络结构——ResNet。这个网络结构的想法主要源于VLAD（残差的想法来源）和Highway Network（跳跃连接的想法来源）。 ResNet Block 残差学习模块包括identity mapping和residual mapping，其中前者指的
深度学习-残差网络RestNet18/34+Tensorboard可视化
LuoFan_A的博客
05-08 2593
ResNet-18/ResNet-34 此ResNet为深度学习keras中CNN卷积网络对于图像的处理 搭配Tensorflow2.1框架+keras实现 ResNet网络结构介绍: ResNet-18网络结构图示: 网络结构图分析: 首先从我们就以18层网络结构图为基础进行对应解释 总体结构来讲Resnet分为17个卷积层(convolution)和1个全连接层(Fully connected) 通过观察网络结构我们可以发现在网络结构中存在两种不同基础块 第一种是 带有实线标注跳跃连接的部分，
ResNet18详细原理（含tensorflow版源码）
Code_and516的博客
03-28 1万+
ResNet18详细原理（含tensorflow版源码）
resnet_18_structure.pdf
09-25
resnet 18 网络结构（摘要需要大于50个字节，所以请自动忽略这个括号。。。）
ResNet18网络的具体构成
daweq的博客
10-26 4万+
ResNet18的基本含义是，网络的基本架构是ResNet，网络的深度是18层。但是这里的网络深度指的是网络的权重层，也就是包括池化，激活，线性层。3，步长为1，padding为1。这个卷积层的卷积核的大小为7。7，步长为2，padding为3，输出通道为64。也就是说这个池化不改变数据的通道数量，而会减半数据的大小。224，也就是3个通道，每个通道的大小为224*224。也就是将输出通道翻倍，输出数据大小全部减半。也就是将输出通道翻倍，输出数据大小全部减半。54，也就是这一层不改变数据的大小和通道数。
图像识别-ResNet-18网络结构图示及解读
算法之美
05-22 3万+
图像识别-ResNet-18网络结构图示及解读
Resnet 18网络模型
Chenzhinan1219的博客
12-20 4万+
1. 残差网络：（Resnet） 残差块： 让我们聚焦于神经网络局部：如图左侧所示，假设我们的原始输入为x，而希望学出的理想映射为f(x)（作为上方激活函数的输入）。左图虚线框中的部分需要直接拟合出该映射f(x)，而右图虚线框中的部分则需要拟合出残差映射f(x)−x。 残差映射在现实中往往更容易优化。 以本节开头提到的恒等映射作为我们希望学出的理想映射f(x)，我们只需将右图虚线框内上方的加权运算（如仿射）的权重和偏置参数设成0，那么f(x)即为恒等映射。 实际中，当理想映射f(x)极接近于恒等映..
ResNet-18超详细介绍！！！！
m0_64799972的博客
09-08 4万+
残差神经网络(ResNet)是由微软研究院的何恺明、张祥雨、任少卿、孙剑等人提出的。ResNet 在2015 年的ILSVRC（ImageNet Large Scale Visual Recognition Challenge）中取得了冠军。残差神经网络的主要贡献是发现了“退化现象（Degradation）”，并针对退化现象发明了 “快捷连接（Shortcut connection）”，极大的消除了深度过大的神经网络训练困难问题。下面我将一步步引出退化现象和快捷连接。
【深度学习入门】Paddle实现人脸检测和表情识别（基于TinyYOLO和ResNet18）
12-20
Paddle实现人脸检测和表情识别（基于YOLO和ResNet18）一、先看效果：训练及测试结果：UI 界面及其可视化：二、AI Studio 简介：平台简介：创建项目：三、创建AI Studio项目：创建并启动环境：下载数据：下载预训练...
paddle实现resnet-18
11-04
paddle实现resnet-18
基于百度飞桨paddle实现语音情感识别源码+项目说明.zip
最新发布
05-15
模型 Params(M) 预处理方法 数据集 类别数量 准确率 获取模型 BidirectionalLSTM 1.8 Flank RAVDESS 8 0.95193 加入知识星球获取 说明： RAVDESS数据集只使用Audio_Speech_Actors_01-24.zip 安装环境 首先安装的是...
使用飞桨PaddleHub实现皮影戏创作
05-10
使用飞桨PaddleHub实现皮影戏创作
基于python的X2Paddle飞桨深度学习模型转换工具
03-26
基于python的X2Paddle飞桨深度学习模型转换工具
深度学习——ResNet18 / 34
Dunkle.T的博客
04-06 2万+
ResNet在2015年由微软实验室提出，斩获当年ImageNet竞赛中分类任务第一名，目标检测第一名。获得COCO数据集中目标检测第一名，图像分割第一名。 ResNet34层模型的结构简图： ResNet网络中的亮点： 超深的网络结构（突破1000层） 提出residual模块（残差结构） 使用Batch Normalization加速训练（丢弃dropout） 在ResNet网络提出之前，传统的卷积神经网络都是通过将一系列卷积层与下采样层进行堆叠得到的。但是当堆叠到一定网络深度时，就会出现两个问题
基于一维残差网络的美国西储大学轴承故障诊断完整代码
qq_56997902的博客
09-09 367
采用MATLAB对数据进行预处理；网络训练环境为python3.7 与 pytorch1.8.0
经典CNN网络：Resnet18网络结构输入和输出
热门推荐
weixin_43999691的博客
06-15 8万+
前言 每当看到一个新的网络，总会思考，这个网络提出来有什么意义，解决了什么问题？Resnet18的提出，解决
使用paddle框架写一段resnet网络代码
05-15
好的，以下是使用 PaddlePaddle 框架实现 ResNet 网络的代码： ```python import paddle import paddle.nn as nn class BasicBlock(nn.Layer): 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_attr=False) self.bn1 = nn.BatchNorm2D(out_channels) self.relu = nn.ReLU() self.conv2 = nn.Conv2D(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias_attr=False) self.bn2 = nn.BatchNorm2D(out_channels) self.downsample = downsample self.stride = stride 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 class Bottleneck(nn.Layer): expansion = 4 def __init__(self, in_channels, out_channels, stride=1, downsample=None): super(Bottleneck, self).__init__() self.conv1 = nn.Conv2D(in_channels, out_channels, kernel_size=1, bias_attr=False) self.bn1 = nn.BatchNorm2D(out_channels) self.conv2 = nn.Conv2D(out_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias_attr=False) self.bn2 = nn.BatchNorm2D(out_channels) self.conv3 = nn.Conv2D(out_channels, out_channels * self.expansion, kernel_size=1, bias_attr=False) self.bn3 = nn.BatchNorm2D(out_channels * self.expansion) self.relu = nn.ReLU() self.downsample = downsample self.stride = stride 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) out = self.relu(out) out = self.conv3(out) out = self.bn3(out) if self.downsample is not None: identity = self.downsample(x) out += identity out = self.relu(out) return out class ResNet(nn.Layer): def __init__(self, block, layers, 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_attr=False) self.bn1 = nn.BatchNorm2D(64) self.relu = nn.ReLU() 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_attr=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 = paddle.flatten(x, 1) x = self.fc(x) return x def resnet18(num_classes=1000): return ResNet(BasicBlock, [2, 2, 2, 2], num_classes=num_classes) def resnet34(num_classes=1000): return ResNet(BasicBlock, [3, 4, 6, 3], num_classes=num_classes) def resnet50(num_classes=1000): return ResNet(Bottleneck, [3, 4, 6, 3], num_classes=num_classes) def resnet101(num_classes=1000): return ResNet(Bottleneck, [3, 4, 23, 3], num_classes=num_classes) def resnet152(num_classes=1000): return ResNet(Bottleneck, [3, 8, 36, 3], num_classes=num_classes) ``` 以上代码定义了 BasicBlock 和 Bottleneck 两个块，并使用它们构建了 ResNet 模型。其中，ResNet 可以选择使用不同的块和层数来构建不同版本的网络。通过调用 `resnet18()`，`resnet34()`，`resnet50()`，`resnet101()` 和 `resnet152()` 函数可以得到不同版本的 ResNet 网络。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值