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

最新推荐文章于 2024-05-29 14:06:52 发布
最新推荐文章于 2024-05-29 14:06:52 发布
阅读量5.3k 收藏 41
点赞数 7
分类专栏： Python基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39220334/article/details/121606060
版权

ResNet18 深度学习 卷积神经网络 Paddle框架 模型实现
关键词由CSDN通过智能技术生成

建模 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
关注
  • 7
    点赞
  • 踩
  • 41
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ResNet18网络的具体构成
daweq的博客
10-26 4万+
ResNet18的基本含义是，网络的基本架构是ResNet，网络的深度是18层。但是这里的网络深度指的是网络的权重层，也就是包括池化，激活，线性层。3，步长为1，padding为1。这个卷积层的卷积核的大小为7。7，步长为2，padding为3，输出通道为64。也就是说这个池化不改变数据的通道数量，而会减半数据的大小。224，也就是3个通道，每个通道的大小为224*224。也就是将输出通道翻倍，输出数据大小全部减半。也就是将输出通道翻倍，输出数据大小全部减半。54，也就是这一层不改变数据的大小和通道数。
经典CNN网络：Resnet18网络结构输入和输出
热门推荐
weixin_43999691的博客
06-15 8万+
前言 每当看到一个新的网络，总会思考，这个网络提出来有什么意义，解决了什么问题？Resnet18的提出，解决
【Paddle】稀疏计算的使用指南 & 稀疏ResNet的学习心得 (2) + Paddle3D应用实例稀疏 ResNet代码解读 （1.6w字超详细）
最新发布
定期分享我的发现和想法，感谢你的陪伴和支持
05-29 5374
稀疏格式是一种特殊的数据存储方式，旨在有效存储和处理其中大部分元素为零的矩阵或张量。这种方法可以显著减少存储空间的需求，并提高数据处理的效率。常见的稀疏格式包括 COO（坐标列表格式）、CSR（压缩稀疏行格式）等。conv3x3和conv1x1是用于创建3D稀疏卷积层的帮助函数，它们使用了PaddlePaddle的SubmConv3D，这是一种专门处理稀疏数据的3D卷积。
【深度学习】ResNet网络详解
1900的博客
10-16 2万+
ResNet
pytorch Resnet-18源码解读
weixin_47062350的博客
11-14 3481
这里写自定义目录标题ResNet-18网络结构图ResNet代码Resnet 声明ResNet残差块定义 ResNet-18网络结构图 ResNet是微软研究院He KaiMing等人提出的。论文链接：Deep Residual Learning for Image Recognition ResNet代码 在pytorch中定义了： _all__ = ['ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101', 'resnet
【神经网络】(10) Resnet18、34 残差网络复现，附python完整代码
博观而约取，厚积而薄发
01-09 1万+
各位同学好，今天和大家分享一下 TensorFlow 深度学习中如何搭载 Resnet18 和 Resnet34 残差神经网络，残差网络利用 shotcut 的方法成功解决了网络退化的问题，在训练集和校验集上，都证明了的更深的网络错误率越小。 论文中给出的具体的网络结构如下： Resnet50 网络结构我已经在之前的博客中复现过，感兴趣的可以看一下：https://blog.csdn.net/dgvv4/article/details/121878494 感谢简书大佬画的残差网络结构图：h
paddle实现resnet-18
11-04
paddle实现resnet-18
【深度学习入门】Paddle实现人脸检测和表情识别（基于TinyYOLO和ResNet18）
12-20
【深度学习入门】Paddle实现人脸检测和表情识别是一个典型的计算机视觉任务，涉及到的主要知识点包括深度学习框架PaddlePaddle的使用、TinyYOLO模型在人脸检测中的应用以及ResNet18模型在表情识别中的作用。...
使用飞桨PaddleHub实现皮影戏创作
05-10
在本项目中，我们将探讨如何使用飞桨PaddleHub这一强大的深度学习开发工具来实现皮影戏创作。飞桨PaddlePaddle是中国首个自主研发的开源深度学习平台，而PaddleHub则是其生态中的一个模块，提供了丰富的预训练模型，...
基于百度飞桨paddle实现语音情感识别源码+项目说明.zip
05-15
模型 Params(M) 预处理方法 数据集 类别数量 准确率 获取模型 BidirectionalLSTM 1.8 Flank RAVDESS 8 0.95193 加入知识星球获取 说明： RAVDESS数据集只使用Audio_Speech_Actors_01-24.zip 安装环境 首先安装的是...
基于python的X2Paddle飞桨深度学习模型转换工具
03-26
《基于Python的X2Paddle：飞桨深度学习模型转换详解》 在当前的深度学习领域，模型的可移植性和跨平台性变得越来越重要。针对这一需求，PaddlePaddle（飞桨）推出了X2Paddle，这是一个强大的模型转换工具，能够将...
史上最全的ResNet网络文件(for Caffe)
12-12
整合了在Caffe框架下使用的主流ResNet网络结构文件Prototxt. 主要包括Resnet-18,34,50,101,152 的训练及测试网络结构文件;还有个solver文件用于配置参数.
pytorch-resnet18和resnet50官方预训练模型
08-22
pytroch官网提供的预训练模型：resnet18：resnet18-5c106cde.pth和resnet50：resnet50-19c8e357.pth（两个文件打包在一起）
ResNet18_resnet18_resnet18网络_
10-02
自己搭建了一个ResNet18网路，以供大家参考和学习，希望有用。
ResNet18代码实现
m0_58242646的博客
01-02 2294
import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers, Sequential, Model, datasets, optimizers # 自定义的预处理函数 def preprocess(x, y): # 调用此函数时会自动传入x,y对象，shape为[b,28,28],[b] # 标准化到0-1 x = 2*tf.cast(x, dtype=t...
深度学习与Pytorch入门实战（十二）实现ResNet-18并在Cifar-10数据集上进行验证
豆子
07-22 1181
ResNet图解 nn.Module详解 1. Pytorch上搭建ResNet-18 1.1 ResNet block子模块 import torch from torch import nn from torch.nn import functional as F class ResBlk(nn.Module): """ ResNet block子模块 "...
基于PaddlePaddle构建ResNet18残差神经网络的食物图片分类问题
黄波波的博客
03-28 2159
手动搭建残差神经网络的食物图片分类问题 Intrdution 本项目是在李宏毅机器学习课程的作业3进行的工作，任务是手动搭建一个CNN模型进行食物图片分类（11种）。 项目要求 请使用 CNN 搭建 model 不能使用额外 dataset 禁止使用 pre-trained model(只能自己手写CNN) 请不要上网寻找 label 项目传送门 Abstract 本文的主要内容如下： 1 PaddlePaddle的深度学习万能公式介绍：该万能公式其实是进行项目研究的常规性方法步骤，本项目就是按照
【转载】关于Resnet18的结构参数以及每层卷积池化后的特征图大小和通道数变化
LIsaWinLee的博客
04-24 5611
实验需要查到了这篇博客浅显易懂，真的是值得转载记录一下。 更多需要的人阅读哦~ 以下完整的记录了原版博客，想看原版请戳ResNet18结构、各层输出维度 网络结构及参数： 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
基于ResNet18网络训练二分类模型
斯人若彩虹，遇上方知有！
09-03 6062
图像二分类是指将图像分为两个类别的任务，通常分为正类和负类。在训练过程中，使用监督学习算法和各种机器学习模型来学习特征差异，并使用精确度、召回率、F1-score等指标进行评估。图像二分类有许多应用，例如人脸识别、疾病检测、文本分类等。本文介绍了基于ResNet18网络的训练蜜蜂和蚂蚁图像的二分类模型的过程。
resnet18网络结构
09-25
### 回答1： ResNet-18是一个基于残差网络的深度卷积神经网络，它包含18个卷积层和全连接层。以下是ResNet-18的网络结构： 输入图像（224x224x3） 卷积层1（7x7卷积核，64个卷积核，步长2）+ BN + ReLU 最大池化层（3x3池化核，步长2） 残差块1（64个卷积核，2个3x3卷积层，每层都有BN和ReLU激活函数） 残差块2（128个卷积核，2个3x3卷积层，每层都有BN和ReLU激活函数） 残差块3（256个卷积核，2个3x3卷积层，每层都有BN和ReLU激活函数） 残差块4（512个卷积核，2个3x3卷积层，每层都有BN和ReLU激活函数） 全局平均池化层 全连接层（1000个神经元） Softmax输出 ResNet-18的关键在于残差块，它允许网络直接拟合残差函数，从而避免了梯度消失问题，使得网络能够更好地训练。 ### 回答2： ResNet-18是一种用于图像分类的卷积神经网络结构。它是ResNet系列网络中的一员，由深度残差网络（Residual Network）发展而来。 ResNet-18主要由多个残差模块组成。每个残差模块中包含两个卷积层和一个跳跃连接。卷积层使用3x3的卷积核进行卷积操作，并使用ReLU激活函数进行非线性变换。跳跃连接将输入直接添加到残差模块的输出，以解决深层网络中的梯度消失问题。 在ResNet-18中，首先是一个7x7的卷积层，用于图像的初步特征提取。然后是一个最大池化层，将图像尺寸缩小为原来的一半。接下来是4个残差模块的堆叠，每个模块中包含两个3x3的卷积层。在每个模块的第一个卷积层后，图像尺寸会减小，通道数会增加。模块之间的通道数和图像尺寸变化如下：64-64、64-128、128-256、256-512。 最后，全局平均池化层将特征图转换成一个向量，并通过一个全连接层映射到最终的分类结果。在全连接层之后，通常还会添加一个softmax层用于分类。 ResNet-18相对于传统的深度卷积网络具有更强的表达能力和更好的训练结果。它采用跳跃连接和残差结构可以有效地解决梯度消失问题，并使网络训练更加稳定和高效。因此，ResNet-18成为了图像分类等任务中的一种重要网络结构。 ### 回答3： ResNet18是一种深度卷积神经网络模型，它是ResNet系列模型中较为简单和轻量级的一种。ResNet18的网络结构由18个卷积层和全局平均池化层组成。 ResNet18的基本模块是残差模块，这种模块可以解决深度网络中的梯度消失和梯度爆炸问题，同时可以加速模型的训练过程。每个残差模块包括两个卷积层，一个标准化层和一个跳跃连接。跳跃连接将输入直接与输出相加，使得梯度能够更轻松地传播。 ResNet18的第一个残差模块由一个7×7的卷积层、一个最大池化层和两个基本的残差模块组成。其余的模块由若干个基本的残差模块组成。最后，全局平均池化层将特征图转换为一个固定长度的向量，并通过一个全连接层将其映射到分类数目的维度。 与其他深度网络相比，ResNet18在参数量和运算量方面都较少，因此更易于训练和部署。它可以很好地解决图像分类、目标检测和语义分割等计算机视觉任务，并在一些基准测试中表现优异。 总之，ResNet18是一种具有18个卷积层和全局平均池化层的深度卷积神经网络模型。通过引入残差模块，它可以有效地训练深度网络，并在图像分类和计算机视觉任务中取得很好的性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值