pytroch【ResNet架构复现】

已于 2023-01-05 17:45:56 修改
阅读量225 收藏
点赞数
分类专栏： 深度学习 文章标签： python 深度学习 人工智能 残差网络 resnet
于 2023-01-05 17:42:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62684026/article/details/128567314
版权
本文详细介绍了如何使用PyTorch实现ResNet网络的残差块和瓶颈模块，包括3x3和1x1卷积层，以及如何通过make_layers函数动态构建网络层。通过示例展示了不同层的输出和参数数量，以及在不同层结构中的应用。
摘要由CSDN通过智能技术生成

文章目录

#basicconv-conv2d+BN+ReLu(conv3x3,conv1x1)
#Residual Unit ,Bottleneck

架构图

在这里插入图片描述

#导入需要的库
import torch
import torch.nn as nn
from typing import Type,Union,List,Optional
from torchinfo import summary

在这里插入图片描述

定义3x3核的卷积层

def conv3x3(in_,out_,stride=1,initialzero=False):
    bn=nn.BatchNorm2d(out_)
    #需要进行判断，要对BN进行0初始化吗？
    # 只有最后一层才需要初始化，不是最后一层就不改变gama和beta
    #initialzero代表需要初始化
    if initialzero==True:
        #只需要改gama，beta本来就是0
        nn.init.constant_(bn.weight,0)

    return nn.Sequential(
        nn.Conv2d(in_,out_,kernel_size=3,padding=1,stride=stride
                  ,bias=False)
        ,bn)

#进行测试
conv3x3(2,10)

Sequential(
  (0): Conv2d(2, 10, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
  (1): BatchNorm2d(10, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
)

定义1x1核的卷积层

def conv1x1(in_,out_,stride=1,initialzero=False):
    bn=nn.BatchNorm2d(out_)
    #需要进行判断，要对BN进行0初始化吗？
    # 只有最后一层才需要初始化，不是最后一层就不改变gama和beta
    #initialzero代表需要初始化
    if initialzero==True:
        #只需要改gama，beta本来就是0
        nn.init.constant_(bn.weight,0)

    return nn.Sequential(
        nn.Conv2d(in_,out_,kernel_size=1,padding=0,stride=stride
                  ,bias=False)
        ,bn)

#测试代码
conv1x1(2,10,1,True)

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

#如果进行了0初始化的话，我们得到的bn层的初始的参数全部都是0
conv1x1(2,10,1,True)[1].weight

Parameter containing:
tensor([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], requires_grad=True)

#如果我们没有进行初始化的话，我们的道德bn蹭的初始的参数全部都是1
conv1x1(2,10,1)[1].weight

Parameter containing:
tensor([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.], requires_grad=True)

定义残差块

在这里插入图片描述

#ResidualUnit
#这是我们残差单元的类
class ResidualUnit(nn.Module):
    #stride1是否等于2呢？如果等于2-特征图尺寸会发生变化
    #需要再跳跃连接上增加1x1卷积层来调整特征图尺寸
    #如果stride1等于1，则什么都不需要做

    def __init__(self,out_ :int,
                 stride1:int=1,#定义补偿的默认值是1
                 in_:Optional[int]=None):
        super().__init__()
        self.stride1=stride1
        #当特征图尺寸需要缩小时，卷积层的输出特征图的数量out等于输入特征图数量in/2
        #当特征图的尺寸不需要缩小的时候,out==in
        if stride1 !=1:
            in_=int(out_/2)
        else:
            in_=out_

        #拟合部分，输出F(x)
        self.fit_=nn.Sequential(
            #传入一个超参数stride1，来表示我们传入的第一个卷积层的补偿
            conv3x3(in_,out_,stride=stride1),
            nn.ReLU(inplace=True),
            #最后一个卷积层的bn层的初始化为0
            conv3x3(out_,out_,initialzero=True)
            #还没有加和，这里不用relu激活函数
        )

        #跳跃连接，输出x(1x1卷积核之后的x）
        self.skipconv=conv1x1(in_,out_,stride=stride1)

        #单独定义放在H(x)之后使用的激活函数ReLu
        self.relu=nn.ReLU(inplace=True)
    def forward(self,x):
        #拟合结果
        fx=self.fit_(x)
        if self.stride1 ==2:
            x=self.skipconv(x) #跳跃连接
        #跳跃连接
        hx=self.relu(fx+x)
        return hx

#进行测试
data=torch.ones(10,64,56,56)
conv3_x_18_0=ResidualUnit(out_=128,stride1=2)

在这里插入图片描述

#这里我们模拟的是conv3的第一层
conv3_x_18_0(data).shape#0号残差单元，需要特征图折半，特征图数量加倍

torch.Size([10, 128, 28, 28])

#conv2的第0层
#这里不需要将我们的特征图折半，因为上面的池化层已经帮我们这般了
conv2_x_18_0=ResidualUnit(out_=64)

在这里插入图片描述

conv2_x_18_0(data).shape

torch.Size([10, 64, 56, 56])

定义瓶颈模块

class Bottleneck(nn.Module):
    def __init__(self,middle_out,stride1:int=1,in_:Optional[int]=None):
        super().__init__()
        out_=4*middle_out
        #我希望使用选填参数in_来帮助我们区别，这个架构是不是conv1后面的那个瓶颈架构
        #如果不是跟在conv1后，就不填写in_
        if in_==None:
            #从conv2_x -conv3_x-conv4_x-conv5_x相互连接的时候
            #每次都需要将特征图尺寸折半，同时卷积层上的middle_out=1/2in_
            if stride1 !=1:
                in_=middle_out*2
            else:
                #不缩小特征图的场合，即这个平津结构不是这个layers的第一个瓶颈结构的时候
                in_=middle_out*4

        self.fit_=nn.Sequential(
            conv1x1(in_,middle_out,stride=stride1),
            nn.ReLU(inplace=True),
            conv3x3(middle_out,middle_out)
            ,nn.ReLU(inplace=True),
            conv1x1(middle_out,out_,initialzero=True)
        )
        self.skipconv=conv1x1(in_,out_,stride=stride1)

        self.relu=nn.ReLU(inplace=True)
    def forward(self,x):
        fx=self.fit_(x)
        #瓶颈结构的输入和输出一定是不相同的，所以我们这里只需要直接写死为卷积就可以了。
        x=self.skipconv(x)
        hx=self.relu(fx+x)
        return hx


#测试

在这里插入图片描述

data1=torch.ones(10,64,56,56)#conv2x的输入
#假设我是conv1后紧跟的第一个瓶颈结构
conv2_x_101_0=Bottleneck(in_=64,middle_out=64)
conv2_x_101_0(data1).shape

torch.Size([10, 256, 56, 56])

在这里插入图片描述

#不是conv1后紧跟的第一个瓶颈结构，但是需要缩小特征图尺寸
data2=torch.ones(10,256,56,56)
conv3_x_101_0=Bottleneck(middle_out=128,stride1=2)
conv3_x_101_0(data2).shape

torch.Size([10, 512, 28, 28])

在这里插入图片描述

#不是conv1后的第一个瓶颈结构，也不需要缩小特征图
data3=torch.ones(10,512,28,28)
conv3_x_101_1=Bottleneck(middle_out=128)
conv3_x_101_1(data3).shape

torch.Size([10, 512, 28, 28])

定义一个函数来编写层

#在单一的layers里的残差单元/瓶颈结构的数量使用num_blocks来表示

layers=[]
num_blocks=6
#第一个块
afterconv1=True#是的话，就是conv1之后的第一个块，false的话就不是conv1之后的第一个块
if afterconv1 == True:
    layers.append(Bottleneck(middle_out=64,in_=64))
else:
    layers.append(Bottleneck(middle_out=128,stride1=2))
#剩下的块就使用for循环来跑
for i in range(num_blocks-1):
    layers.append(Bottleneck(middle_out=128))

len(layers)

6

layers=[]
num_blocks=6
#第一个块
afterconv1=True#是的话，就是conv1之后的第一个块，false的话就不是conv1之后的第一个块
if afterconv1 == True:
    layers.append(ResidualUnit(out_=64,in_=64))
else:
    layers.append(ResidualUnit(out_=128,stride1=2))
#剩下的块就使用for循环来跑
for i in range(num_blocks-1):
    layers.append(ResidualUnit(out_=128))

len(layers)

6

#可以同时用于残差单元和瓶颈结构
#我们将这个功能打包到一个函数中，用来实现生成每一个layers的函数

#block中填入的类型只能残差单元或者瓶颈结构
def make_layers(
        block:Type[Union[ResidualUnit,Bottleneck]],
        middle_out:int,
        num_blocks:int,
        #有默认值参数的一定要写在没有默认值参数的最后面
        afterconv1:bool=False):
    layers=[]
    if afterconv1 == True:
        layers.append(block(middle_out,in_=64))
    else:
        layers.append(block(middle_out,stride1=2))
    #剩下的块就使用for循环来跑
    for i in range(num_blocks-1):
        layers.append(block(middle_out))
    return nn.Sequential(*layers)

在这里插入图片描述

layer_34_conv4_x=make_layers(ResidualUnit,256,6,False)

len(layer_34_conv4_x)

6

#用*来将我们的列表中的元素拆开，放入nn.Sequential中
nn.Sequential(*layer_34_conv4_x)

查看我们的测试的输出结果

Sequential(
  (0): ResidualUnit(
    (fit_): Sequential(
      (0): Sequential(
        (0): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (1): ReLU(inplace=True)
      (2): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (skipconv): 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)
    )
    (relu): ReLU(inplace=True)
  )
  (1): ResidualUnit(
    (fit_): Sequential(
      (0): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (1): ReLU(inplace=True)
      (2): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (skipconv): Sequential(
      (0): Conv2d(256, 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)
    )
    (relu): ReLU(inplace=True)
  )
  (2): ResidualUnit(
    (fit_): Sequential(
      (0): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (1): ReLU(inplace=True)
      (2): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (skipconv): Sequential(
      (0): Conv2d(256, 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)
    )
    (relu): ReLU(inplace=True)
  )
  (3): ResidualUnit(
    (fit_): Sequential(
      (0): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (1): ReLU(inplace=True)
      (2): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (skipconv): Sequential(
      (0): Conv2d(256, 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)
    )
    (relu): ReLU(inplace=True)
  )
  (4): ResidualUnit(
    (fit_): Sequential(
      (0): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (1): ReLU(inplace=True)
      (2): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (skipconv): Sequential(
      (0): Conv2d(256, 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)
    )
    (relu): ReLU(inplace=True)
  )
  (5): ResidualUnit(
    (fit_): Sequential(
      (0): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
      (1): ReLU(inplace=True)
      (2): Sequential(
        (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      )
    )
    (skipconv): Sequential(
      (0): Conv2d(256, 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)
    )
    (relu): ReLU(inplace=True)
  )
)

#34层网络,conv2_x，紧跟在conv1后的首个架构
#不缩小特征图的尺寸，每层输出的都是64，3个块

在这里插入图片描述

conv2_x_34=make_layers(ResidualUnit,64,3,afterconv1=True)
datashape=(10,64,56,56)
summary(conv2_x_34,datashape,depth=1,device="cpu")

查看我们的测试的输出结果

==========================================================================================
Layer (type:depth-idx)                   Output Shape              Param #
==========================================================================================
Sequential                               [10, 64, 56, 56]          --
├─ResidualUnit: 1-1                      [10, 64, 56, 56]          78,208
├─ResidualUnit: 1-2                      [10, 64, 56, 56]          78,208
├─ResidualUnit: 1-3                      [10, 64, 56, 56]          78,208
==========================================================================================
Total params: 234,624
Trainable params: 234,624
Non-trainable params: 0
Total mult-adds (G): 6.94
==========================================================================================
Input size (MB): 8.03
Forward/backward pass size (MB): 192.68
Params size (MB): 0.89
Estimated Total Size (MB): 201.59
==========================================================================================

在这里插入图片描述

conv2_x_101=make_layers(Bottleneck,64,3,afterconv1=True)
datashape=(10,64,56,56)

summary(conv2_x_101,datashape,depth=3,device="cpu")

查看我们的测试的输出结果

==========================================================================================
Layer (type:depth-idx)                   Output Shape              Param #
==========================================================================================
Sequential                               [10, 256, 56, 56]         --
├─Bottleneck: 1-1                        [10, 256, 56, 56]         --
│    └─Sequential: 2-1                   [10, 256, 56, 56]         --
│    │    └─Sequential: 3-1              [10, 64, 56, 56]          4,224
│    │    └─ReLU: 3-2                    [10, 64, 56, 56]          --
│    │    └─Sequential: 3-3              [10, 64, 56, 56]          36,992
│    │    └─ReLU: 3-4                    [10, 64, 56, 56]          --
│    │    └─Sequential: 3-5              [10, 256, 56, 56]         16,896
│    └─Sequential: 2-2                   [10, 256, 56, 56]         --
│    │    └─Conv2d: 3-6                  [10, 256, 56, 56]         16,384
│    │    └─BatchNorm2d: 3-7             [10, 256, 56, 56]         512
│    └─ReLU: 2-3                         [10, 256, 56, 56]         --
├─Bottleneck: 1-2                        [10, 256, 56, 56]         --
│    └─Sequential: 2-4                   [10, 256, 56, 56]         --
│    │    └─Sequential: 3-8              [10, 64, 56, 56]          16,512
│    │    └─ReLU: 3-9                    [10, 64, 56, 56]          --
│    │    └─Sequential: 3-10             [10, 64, 56, 56]          36,992
│    │    └─ReLU: 3-11                   [10, 64, 56, 56]          --
│    │    └─Sequential: 3-12             [10, 256, 56, 56]         16,896
│    └─Sequential: 2-5                   [10, 256, 56, 56]         --
│    │    └─Conv2d: 3-13                 [10, 256, 56, 56]         65,536
│    │    └─BatchNorm2d: 3-14            [10, 256, 56, 56]         512
│    └─ReLU: 2-6                         [10, 256, 56, 56]         --
├─Bottleneck: 1-3                        [10, 256, 56, 56]         --
│    └─Sequential: 2-7                   [10, 256, 56, 56]         --
│    │    └─Sequential: 3-15             [10, 64, 56, 56]          16,512
│    │    └─ReLU: 3-16                   [10, 64, 56, 56]          --
│    │    └─Sequential: 3-17             [10, 64, 56, 56]          36,992
│    │    └─ReLU: 3-18                   [10, 64, 56, 56]          --
│    │    └─Sequential: 3-19             [10, 256, 56, 56]         16,896
│    └─Sequential: 2-8                   [10, 256, 56, 56]         --
│    │    └─Conv2d: 3-20                 [10, 256, 56, 56]         65,536
│    │    └─BatchNorm2d: 3-21            [10, 256, 56, 56]         512
│    └─ReLU: 2-9                         [10, 256, 56, 56]         --
==========================================================================================
Total params: 347,904
Trainable params: 347,904
Non-trainable params: 0
Total mult-adds (G): 10.79
==========================================================================================
Input size (MB): 8.03
Forward/backward pass size (MB): 963.38
Params size (MB): 1.39
Estimated Total Size (MB): 972.80
==========================================================================================

conv4_x_101=make_layers(Bottleneck,256,23)
datashape=(10,512,28,28)
summary(conv4_x_101,datashape,depth=1,device="cpu")

查看我们的测试的输出结果

==========================================================================================
Layer (type:depth-idx)                   Output Shape              Param #
==========================================================================================
Sequential                               [10, 1024, 14, 14]        --
├─Bottleneck: 1-1                        [10, 1024, 14, 14]        1,512,448
├─Bottleneck: 1-2                        [10, 1024, 14, 14]        2,167,808
├─Bottleneck: 1-3                        [10, 1024, 14, 14]        2,167,808
├─Bottleneck: 1-4                        [10, 1024, 14, 14]        2,167,808
├─Bottleneck: 1-5                        [10, 1024, 14, 14]        2,167,808
├─Bottleneck: 1-6                        [10, 1024, 14, 14]        2,167,808
├─Bottleneck: 1-7                        [10, 1024, 14, 14]        2,167,808
├─Bottleneck: 1-8                        [10, 1024, 14, 14]        2,167,808
├─Bottleneck: 1-9                        [10, 1024, 14, 14]        2,167,808
├─Bottleneck: 1-10                       [10, 1024, 14, 14]        2,167,808
├─Bottleneck: 1-11                       [10, 1024, 14, 14]        2,167,808
├─Bottleneck: 1-12                       [10, 1024, 14, 14]        2,167,808
├─Bottleneck: 1-13                       [10, 1024, 14, 14]        2,167,808
├─Bottleneck: 1-14                       [10, 1024, 14, 14]        2,167,808
├─Bottleneck: 1-15                       [10, 1024, 14, 14]        2,167,808
├─Bottleneck: 1-16                       [10, 1024, 14, 14]        2,167,808
├─Bottleneck: 1-17                       [10, 1024, 14, 14]        2,167,808
├─Bottleneck: 1-18                       [10, 1024, 14, 14]        2,167,808
├─Bottleneck: 1-19                       [10, 1024, 14, 14]        2,167,808
├─Bottleneck: 1-20                       [10, 1024, 14, 14]        2,167,808
├─Bottleneck: 1-21                       [10, 1024, 14, 14]        2,167,808
├─Bottleneck: 1-22                       [10, 1024, 14, 14]        2,167,808
├─Bottleneck: 1-23                       [10, 1024, 14, 14]        2,167,808
==========================================================================================
Total params: 49,204,224
Trainable params: 49,204,224
Non-trainable params: 0
Total mult-adds (G): 96.21
==========================================================================================
Input size (MB): 16.06
Forward/backward pass size (MB): 1846.48
Params size (MB): 196.82
Estimated Total Size (MB): 2059.35
==========================================================================================

定义完整的架构

#构建残差网络
class ResNet(nn.Module):
    def __init__(self,block:Type[Union[ResidualUnit,Bottleneck]],layers:List[int],num_classes:int):
        super().__init__()
        #Layer1:卷积+池化
        self.layer1=nn.Sequential(nn.Conv2d(3,64,kernel_size=7,stride=2,padding=3,bias=False)
                                  ,nn.BatchNorm2d(64)
                                  ,nn.ReLU(inplace=True)
                                  ,nn.MaxPool2d(kernel_size=3,stride=2,ceil_mode=True))
        #Layer2-Layers5
        self.layer2_x=make_layers(block,64,layers[0],afterconv1=True)
        self.layer3_x=make_layers(block,128,layers[1])
        self.layer4_x=make_layers(block,256,layers[2])
        self.layer5_x=make_layers(block,512,layers[3])

        #全局平均池化
        self.avgpool=nn.AdaptiveAvgPool2d((1,1))

        #分类
        if block==ResidualUnit:
            self.fc=nn.Linear(512,num_classes)
        else:
            self.fc=nn.Linear(2048,num_classes)

    def forward(self,x):
        x=self.layer1(x)
        x=self.layer5_x(self.layer4_x(self.layer3_x(self.layer2_x(x))))
        x=self.avgpool(x)
        #将x拉成一维
        x=torch.flatten(x,1)
        x=self.fc(x)

#进行测试
datashape=(10,3,224,224)

在这里插入图片描述

res34=ResNet(ResidualUnit,[3,4,6,3],num_classes=1000)

在这里插入图片描述

res101=ResNet(Bottleneck,[3,4,23,3],num_classes=1000)

summary(res34,datashape,depth=1,device="cpu")

查看我们的测试的输出结果

===============================================================================================
Layer (type:depth-idx)                        Output Shape              Param #
===============================================================================================
ResNet                                        --                        --
├─Sequential: 1-1                             [10, 64, 56, 56]          9,536
├─Sequential: 1-2                             [10, 64, 56, 56]          234,624
├─Sequential: 1-3                             [10, 128, 28, 28]         1,166,336
├─Sequential: 1-4                             [10, 256, 14, 14]         7,152,640
├─Sequential: 1-5                             [10, 512, 7, 7]           13,640,704
├─AdaptiveAvgPool2d: 1-6                      [10, 512, 1, 1]           --
├─Linear: 1-7                                 [10, 1000]                513,000
===============================================================================================
Total params: 22,716,840
Trainable params: 22,716,840
Non-trainable params: 0
Total mult-adds (G): 36.64
===============================================================================================
Input size (MB): 6.02
Forward/backward pass size (MB): 598.18
Params size (MB): 87.19
Estimated Total Size (MB): 691.39
===============================================================================================
桜キャンドル淵
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
ResNet代码（超详细注释）+数据集，pytorch实现
10-02
1. **ResNet架构**：ResNet的核心思想在于引入了“残差块”（Residual Block）。每个残差块包含两个或三个卷积层，通过短路结构将输入直接连接到输出，形如`output = F(x) + x`，其中`F(x)`表示一系列非线性变换（卷...
ResNet代码复现＋超详细注释（PyTorch）
路人贾的博客
12-23 9681
ResNet代码复现（PyTorch），每一行都有超详细注释，新手小白都能看懂，亲测可运行
resnet18 参数解读
keyanxiaocaicai的专栏
05-19 4351
global_params=GlobalParams( block=block, num_classes=num_classes, zero_init_residual=zero_init_residual, groups=groups, width_per_group=width_per_group, replace_stride_with_dilation=replace_strid...
pytorch实战5：基于pytorch复现ResNet
weixin_46676835的博客
01-21 929
pytorch实战5：基于pytorch复现ResNet
resnet50网络结构复现——pytorch
qq_53640005的博客
04-18 3754
残差学习 ——y = F( x,{ w_i }) + x 残差学习的block一共包含两个分支或者两种映射（mapping）： identity mapping：是上图右边那条弯的曲线。是指本身的映射，也就是x自身； residual mapping，指的是另一条分支，即F(x)部分，这部分称为残差映射，也就是y-x 相比于VGG-19，ResNet没有使用全连接层，而使用了全局平均池化层，可以减少大量参数 ...
Resnet50 pytorch复现
kui9702的博客
03-28 2125
Resnet50 pytorch复现 之前复现过Resnet18，今天复现与Resnet网络结构稍有不同的Resnet50 Resnet50的基本结构是1x1卷积->3x3卷积->1x1卷积。而每一组卷积是这样的结构：卷积->BN->RELU组合而成。 如果所示，上面左边的为Resnet18,34的残差结构，右边的是Resnet50 101 152的残差结构。从图中可以看出Resnet50 的 1x1的卷积->3x3卷积->1x1卷积结构中，第一个1x1的卷积是
Person_reID_baseline_pytorch-master.zip_Person Re-ID:_PyTorch行人识
09-20
2. 模型定义：包含具体的网络结构，如ResNet、MobileNet等基础网络架构加上针对行人重识别任务的修改或扩展。 3. 训练脚本：定义了损失函数、优化器、学习率策略以及训练过程的控制逻辑。 4. 测试脚本：评估模型在...
pytorch构建多模型实例
09-18
在本文中，作者将分享如何使用PyTorch构建多个模型实例，其中包括构建一个双模型实例，即se_resnet152和DPN92。PyTorch是一个开源机器学习库，基于Python语言，它广泛用于计算机视觉和自然语言处理领域，主要特点...
Inceptionv1v2v3v4的pytorch实现
08-05
通过理解这些核心概念并参考已有的实现代码，可以轻松地在PyTorch中复现Inceptionv1v2v3v4。 总结来说，Inception模型系列是深度学习中具有里程碑意义的工作，它们的创新设计对后续的网络结构产生了深远影响。在...
常见分类网络pytorch版本.zip
07-01
这些网络在PyTorch中的实现，使开发者能够快速理解和复现这些经典模型，进行模型比较和微调。对于初学者，这是一个很好的学习资源，可以深入理解深度学习中网络架构的设计原理；对于研究者，这些代码可以作为基础，...
ResNet残差网络一维、二维复现pytorch-含残差块复现思路分析
一个学长的博客
06-16 1万+
由于深度学习的会面临退化的问题，也就是当深度学习的网络加深到某一程度之后再加深会导致准确率降低，为了保证加深的网络的性能不低于浅层次的网络，为此2015年何凯明大佬发表了著名了ResNet残差网络，既再GoogLeNet在横向维度的创新之后，在网络结构上进行了新的创新。链接: ResNet原文地址结构的原理并不复杂，看一下从原文截取出来的这个残差结构，很好理解就是把输入最后加入到的输出上，构造一个类似短路的结构。 实践中，原文作者针对VGG19进行了改进，首先是增加了卷积层，然后每两个卷积层之之间进行残差
Siamese目标跟踪系列学习笔记
My_Communication的博客
06-17 330
1. 网络结构 消除padding对跟踪过程的影响 def center_crop(x): """ center crop layer. crop [1:-2] to eliminate padding influence. Crop 1 element around the tensor input x can be a Variable or Tensor """ return x[:, :, 1:-1, 1:-1].contiguous() 带有pa
pytorch中残差网络resnet的源码解读
ZJE
07-24 2万+
pytorch的resnet模块在torchvision的models中。 里面可以选择的resnet类型有： _all_列表的每一个resnet都提供了实现的函数： def resnet18(pretrained=False, progress=True, **kwargs): """Constructs a ResNet-18 model. Args: ...
pytorch复现resnet（附个人理解）
小马博客
12-30 2358
pytorch复现resnet 1.Resnet网络介绍（个人理解） ​ 对于传统的CNN，层数在25层之前，准确率会随着层数增加提高。但是一旦层数过深，网络过于庞大，准确率反而会下降。而Resnet较好的解决了这一问题。其原因在于： ​ Resnet具有一定的记忆性，在第一次进入某个卷积块（多个卷积层）时，Tensor0（输入）通过卷积块进行前向传播得到Tensor1，之后，如果Tensor0与...
简单易懂的PyTorch版ResNet50复现代码
hlld__的博客
02-09 7853
ResNet50网络架构 ResNet50是卷积神经网络的代表之一，其广泛使用在包括分类、检测、分割等任务中，可以说是最为著名的深度神经网络之一。 PyTorch复现代码 # ResNet50.py import torch import torch.nn as nn import torch.nn.functional as F class Conv(nn.Module): def __init__(self, in_channels, out_channels, kernel_size=1,
PyTorch实现ResNet
远方
03-11 1510
import numpy as np import torch from torch import nn from torch.autograd import Variable import torch.nn.functional as F 定义残差模块 def conv3x3(in_channel, out_channel, stride=1): return nn.Conv2d(in...
Pytorch学习笔记（六）
kongshuchen的博客
05-16 1万+
（10）使用Pytorch实现ResNet ResNet要解决的问题 深度学习网络的深度对最后的分类和识别的效果有着很大的影响，所以正常想法就是能把网络设计的越深越好，但是事实上却不是这样，常规的网络的堆叠（plain network）在网络很深的时候，效果却越来越差了。 其中的原因之一即是网络越深，梯度消失的现象就越来越明显，网络的训练效果也不会很好。 但是现在浅层的网络（shallower
ResNet模型框架（PyTorch）
weixin_41978493的博客
07-31 1041
I. 前言 ResNet，论文地址：Deep Residual Learning for Image Recognition，该论文提出了一种残差网络结构，将网络每一部分的输入经shortcut connection，与第二（三）个卷积核的结果相加，然后一并进行ReLU生成总的激活值. 每一部分的残差网络结构如下图所示. 【注】左侧的building block是RestNet-34的， 右侧的是ResNet-50/101/152. 其中，shortcut connection有三种方案，A）在维度上升的
卷积神经网络学习—Resnet50（论文精读+pytorch代码复现）
热门推荐
ZhengrongYue的博客
07-04 3万+
卷积神经网络学习—Resnet50（论文精读+pytorch代码复现）
pytorch resnet50下载
最新发布
06-02
PyTorch ResNet50是一种深度学习网络，它可以用于图像分类和目标检测任务。它是ResNet系列网络的其中一种，由Microsoft Research Asia团队提出。ResNet50包含50层卷积神经网络，可以处理不同大小的图像并输出预测...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

桜キャンドル淵

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值