手动搭建ResNet模型(pytorch)

最新推荐文章于 2024-05-07 17:19:42 发布
最新推荐文章于 2024-05-07 17:19:42 发布
阅读量2.3k 收藏 17
点赞数 5
分类专栏： 手动实现各类模型结构之分类 文章标签： resnet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Galen_xia/article/details/115903769
版权

手动搭建ResNet模型（pytorch）

一、ResNet模型结构？

  • ResNet18、34、50、101、152

在这里插入图片描述

  • ResNet18、34对应左下的残差块；ResNet50、101、152对应右下的残差块；

在这里插入图片描述

二、代码示例

import torchvision
import torch
import torch.nn as nn

__all__ = ['ResNet50','ResNet101','ResNet152']

def Conv1(in_planes,out_planes,stride=2):
    return nn.Sequential(
        nn.Conv2d(in_channels=in_planes,out_channels=out_planes,kernel_size=7,stride=stride,padding=3,bias=False),
        nn.BatchNorm2d(out_planes),
        nn.ReLU(inplace=True),
        nn.MaxPool2d(kernel_size=3,stride=2,padding=1)
    )

class Bottleneck(nn.Module):
    def __init__(self,in_places,out_places,stride=1,downsampling=False,expansion=4):
        super(Bottleneck,self).__init__()
        self.expansion = expansion
        self.downsampling = downsampling

        self.bottleneck = nn.Sequential(
            nn.Conv2d(in_channels=in_places,out_channels=out_places,kernel_size=1,stride=1,bias=False),
            nn.BatchNorm2d(out_places),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=out_places,out_channels=out_places,kernel_size=3,stride=stride,padding=1,bias=False),
            nn.BatchNorm2d(out_places),
            nn.ReLU(inplace=True),
            nn.Conv2d(in_channels=out_places,out_channels=out_places*self.expansion,kernel_size=1,stride=1,bias=False),
            nn.BatchNorm2d(out_places*self.expansion)
        )

        if self.downsampling :
            self.downsample = nn.Sequential(
                nn.Conv2d(in_channels=in_places,out_channels=out_places*self.expansion,kernel_size=1,stride=stride,bias=False),
                nn.BatchNorm2d(out_places*self.expansion)
            )
        self.relu = nn.ReLU(inplace=True)
    def forward(self,x):
        residual = x
        out = self.bottleneck(x)

        if self.downsampling:
            residual = self.downsample(x)

        out += residual
        out = self.relu(out)
        return out

class ResNet(nn.Module):
    def __init__(self,blocks,num_classes=1000,expansion=4):
        super(ResNet,self).__init__()
        self.expansion = expansion

        self.conv1 = Conv1(in_planes=3,out_planes=64)

        self.layer1 = self.make_layer(in_places=64,out_places=64,block=blocks[0],stride=1)
        self.layer2 = self.make_layer(in_places=256,out_places=128,block=blocks[1],stride=2)
        self.layer3 = self.make_layer(in_places=512,out_places=256,block=blocks[2],stride=2)
        self.layer4 = self.make_layer(in_places=1024,out_places=512,block=blocks[3],stride=2)

        self.avgpool = nn.AdaptiveAvgPool2d((1,1))
        self.fc = nn.Linear(2048,num_classes)

        # 定义初始化方式
        for m in self.modules():
            if isinstance(m,nn.Conv2d):
                nn.init.kaiming_normal_(m.weight,mode='fan_out',nonlinearity='relu')
            elif isinstance(m,nn.BatchNorm2d):
                nn.init.constant_(m.weight,1)
                nn.init.constant_(m.bias,0)



    def make_layer(self,in_places,out_places,block,stride):
        layers = []
        layers.append(Bottleneck(in_places,out_places,stride,downsampling=True))
        for i in range(1,block):
            layers.append(Bottleneck(out_places*self.expansion,out_places))

        return nn.Sequential(*layers)

    def forward(self,x):
        x = self.conv1(x)

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

        x = self.avgpool(x)
        x = x.view(x.size(0),-1)
        x = self.fc(x)
        return x


def ResNet50():
    return ResNet([3,4,6,3])

def ResNet101():
    return ResNet([3,4,23,3])

def ResNet152():
    return ResNet([3,8,36,3])

if __name__== '__main__':
    from torchsummary import summary
    model = ResNet50()
    # print (model)

    # input = torch.randn(1,3,244,244)
    # out = model(input)
    # print (out.shape)

    summary(model,(3,244,244))
  • 输出
D:\Anaconda3\python.exe C:/Users/夏戈/Desktop/DeepNet/classification/resnet.py
----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1         [-1, 64, 122, 122]           9,408
       BatchNorm2d-2         [-1, 64, 122, 122]             128
              ReLU-3         [-1, 64, 122, 122]               0
         MaxPool2d-4           [-1, 64, 61, 61]               0
            Conv2d-5           [-1, 64, 61, 61]           4,096
       BatchNorm2d-6           [-1, 64, 61, 61]             128
              ReLU-7           [-1, 64, 61, 61]               0
            Conv2d-8           [-1, 64, 61, 61]          36,864
       BatchNorm2d-9           [-1, 64, 61, 61]             128
             ReLU-10           [-1, 64, 61, 61]               0
           Conv2d-11          [-1, 256, 61, 61]          16,384
      BatchNorm2d-12          [-1, 256, 61, 61]             512
           Conv2d-13          [-1, 256, 61, 61]          16,384
      BatchNorm2d-14          [-1, 256, 61, 61]             512
             ReLU-15          [-1, 256, 61, 61]               0
       Bottleneck-16          [-1, 256, 61, 61]               0
           Conv2d-17           [-1, 64, 61, 61]          16,384
      BatchNorm2d-18           [-1, 64, 61, 61]             128
             ReLU-19           [-1, 64, 61, 61]               0
           Conv2d-20           [-1, 64, 61, 61]          36,864
      BatchNorm2d-21           [-1, 64, 61, 61]             128
             ReLU-22           [-1, 64, 61, 61]               0
           Conv2d-23          [-1, 256, 61, 61]          16,384
      BatchNorm2d-24          [-1, 256, 61, 61]             512
             ReLU-25          [-1, 256, 61, 61]               0
       Bottleneck-26          [-1, 256, 61, 61]               0
           Conv2d-27           [-1, 64, 61, 61]          16,384
      BatchNorm2d-28           [-1, 64, 61, 61]             128
             ReLU-29           [-1, 64, 61, 61]               0
           Conv2d-30           [-1, 64, 61, 61]          36,864
      BatchNorm2d-31           [-1, 64, 61, 61]             128
             ReLU-32           [-1, 64, 61, 61]               0
           Conv2d-33          [-1, 256, 61, 61]          16,384
      BatchNorm2d-34          [-1, 256, 61, 61]             512
             ReLU-35          [-1, 256, 61, 61]               0
       Bottleneck-36          [-1, 256, 61, 61]               0
           Conv2d-37          [-1, 128, 61, 61]          32,768
      BatchNorm2d-38          [-1, 128, 61, 61]             256
             ReLU-39          [-1, 128, 61, 61]               0
           Conv2d-40          [-1, 128, 31, 31]         147,456
      BatchNorm2d-41          [-1, 128, 31, 31]             256
             ReLU-42          [-1, 128, 31, 31]               0
           Conv2d-43          [-1, 512, 31, 31]          65,536
      BatchNorm2d-44          [-1, 512, 31, 31]           1,024
           Conv2d-45          [-1, 512, 31, 31]         131,072
      BatchNorm2d-46          [-1, 512, 31, 31]           1,024
             ReLU-47          [-1, 512, 31, 31]               0
       Bottleneck-48          [-1, 512, 31, 31]               0
           Conv2d-49          [-1, 128, 31, 31]          65,536
      BatchNorm2d-50          [-1, 128, 31, 31]             256
             ReLU-51          [-1, 128, 31, 31]               0
           Conv2d-52          [-1, 128, 31, 31]         147,456
      BatchNorm2d-53          [-1, 128, 31, 31]             256
             ReLU-54          [-1, 128, 31, 31]               0
           Conv2d-55          [-1, 512, 31, 31]          65,536
      BatchNorm2d-56          [-1, 512, 31, 31]           1,024
             ReLU-57          [-1, 512, 31, 31]               0
       Bottleneck-58          [-1, 512, 31, 31]               0
           Conv2d-59          [-1, 128, 31, 31]          65,536
      BatchNorm2d-60          [-1, 128, 31, 31]             256
             ReLU-61          [-1, 128, 31, 31]               0
           Conv2d-62          [-1, 128, 31, 31]         147,456
      BatchNorm2d-63          [-1, 128, 31, 31]             256
             ReLU-64          [-1, 128, 31, 31]               0
           Conv2d-65          [-1, 512, 31, 31]          65,536
      BatchNorm2d-66          [-1, 512, 31, 31]           1,024
             ReLU-67          [-1, 512, 31, 31]               0
       Bottleneck-68          [-1, 512, 31, 31]               0
           Conv2d-69          [-1, 128, 31, 31]          65,536
      BatchNorm2d-70          [-1, 128, 31, 31]             256
             ReLU-71          [-1, 128, 31, 31]               0
           Conv2d-72          [-1, 128, 31, 31]         147,456
      BatchNorm2d-73          [-1, 128, 31, 31]             256
             ReLU-74          [-1, 128, 31, 31]               0
           Conv2d-75          [-1, 512, 31, 31]          65,536
      BatchNorm2d-76          [-1, 512, 31, 31]           1,024
             ReLU-77          [-1, 512, 31, 31]               0
       Bottleneck-78          [-1, 512, 31, 31]               0
           Conv2d-79          [-1, 256, 31, 31]         131,072
      BatchNorm2d-80          [-1, 256, 31, 31]             512
             ReLU-81          [-1, 256, 31, 31]               0
           Conv2d-82          [-1, 256, 16, 16]         589,824
      BatchNorm2d-83          [-1, 256, 16, 16]             512
             ReLU-84          [-1, 256, 16, 16]               0
           Conv2d-85         [-1, 1024, 16, 16]         262,144
      BatchNorm2d-86         [-1, 1024, 16, 16]           2,048
           Conv2d-87         [-1, 1024, 16, 16]         524,288
      BatchNorm2d-88         [-1, 1024, 16, 16]           2,048
             ReLU-89         [-1, 1024, 16, 16]               0
       Bottleneck-90         [-1, 1024, 16, 16]               0
           Conv2d-91          [-1, 256, 16, 16]         262,144
      BatchNorm2d-92          [-1, 256, 16, 16]             512
             ReLU-93          [-1, 256, 16, 16]               0
           Conv2d-94          [-1, 256, 16, 16]         589,824
      BatchNorm2d-95          [-1, 256, 16, 16]             512
             ReLU-96          [-1, 256, 16, 16]               0
           Conv2d-97         [-1, 1024, 16, 16]         262,144
      BatchNorm2d-98         [-1, 1024, 16, 16]           2,048
             ReLU-99         [-1, 1024, 16, 16]               0
      Bottleneck-100         [-1, 1024, 16, 16]               0
          Conv2d-101          [-1, 256, 16, 16]         262,144
     BatchNorm2d-102          [-1, 256, 16, 16]             512
            ReLU-103          [-1, 256, 16, 16]               0
          Conv2d-104          [-1, 256, 16, 16]         589,824
     BatchNorm2d-105          [-1, 256, 16, 16]             512
            ReLU-106          [-1, 256, 16, 16]               0
          Conv2d-107         [-1, 1024, 16, 16]         262,144
     BatchNorm2d-108         [-1, 1024, 16, 16]           2,048
            ReLU-109         [-1, 1024, 16, 16]               0
      Bottleneck-110         [-1, 1024, 16, 16]               0
          Conv2d-111          [-1, 256, 16, 16]         262,144
     BatchNorm2d-112          [-1, 256, 16, 16]             512
            ReLU-113          [-1, 256, 16, 16]               0
          Conv2d-114          [-1, 256, 16, 16]         589,824
     BatchNorm2d-115          [-1, 256, 16, 16]             512
            ReLU-116          [-1, 256, 16, 16]               0
          Conv2d-117         [-1, 1024, 16, 16]         262,144
     BatchNorm2d-118         [-1, 1024, 16, 16]           2,048
            ReLU-119         [-1, 1024, 16, 16]               0
      Bottleneck-120         [-1, 1024, 16, 16]               0
          Conv2d-121          [-1, 256, 16, 16]         262,144
     BatchNorm2d-122          [-1, 256, 16, 16]             512
            ReLU-123          [-1, 256, 16, 16]               0
          Conv2d-124          [-1, 256, 16, 16]         589,824
     BatchNorm2d-125          [-1, 256, 16, 16]             512
            ReLU-126          [-1, 256, 16, 16]               0
          Conv2d-127         [-1, 1024, 16, 16]         262,144
     BatchNorm2d-128         [-1, 1024, 16, 16]           2,048
            ReLU-129         [-1, 1024, 16, 16]               0
      Bottleneck-130         [-1, 1024, 16, 16]               0
          Conv2d-131          [-1, 256, 16, 16]         262,144
     BatchNorm2d-132          [-1, 256, 16, 16]             512
            ReLU-133          [-1, 256, 16, 16]               0
          Conv2d-134          [-1, 256, 16, 16]         589,824
     BatchNorm2d-135          [-1, 256, 16, 16]             512
            ReLU-136          [-1, 256, 16, 16]               0
          Conv2d-137         [-1, 1024, 16, 16]         262,144
     BatchNorm2d-138         [-1, 1024, 16, 16]           2,048
            ReLU-139         [-1, 1024, 16, 16]               0
      Bottleneck-140         [-1, 1024, 16, 16]               0
          Conv2d-141          [-1, 512, 16, 16]         524,288
     BatchNorm2d-142          [-1, 512, 16, 16]           1,024
            ReLU-143          [-1, 512, 16, 16]               0
          Conv2d-144            [-1, 512, 8, 8]       2,359,296
     BatchNorm2d-145            [-1, 512, 8, 8]           1,024
            ReLU-146            [-1, 512, 8, 8]               0
          Conv2d-147           [-1, 2048, 8, 8]       1,048,576
     BatchNorm2d-148           [-1, 2048, 8, 8]           4,096
          Conv2d-149           [-1, 2048, 8, 8]       2,097,152
     BatchNorm2d-150           [-1, 2048, 8, 8]           4,096
            ReLU-151           [-1, 2048, 8, 8]               0
      Bottleneck-152           [-1, 2048, 8, 8]               0
          Conv2d-153            [-1, 512, 8, 8]       1,048,576
     BatchNorm2d-154            [-1, 512, 8, 8]           1,024
            ReLU-155            [-1, 512, 8, 8]               0
          Conv2d-156            [-1, 512, 8, 8]       2,359,296
     BatchNorm2d-157            [-1, 512, 8, 8]           1,024
            ReLU-158            [-1, 512, 8, 8]               0
          Conv2d-159           [-1, 2048, 8, 8]       1,048,576
     BatchNorm2d-160           [-1, 2048, 8, 8]           4,096
            ReLU-161           [-1, 2048, 8, 8]               0
      Bottleneck-162           [-1, 2048, 8, 8]               0
          Conv2d-163            [-1, 512, 8, 8]       1,048,576
     BatchNorm2d-164            [-1, 512, 8, 8]           1,024
            ReLU-165            [-1, 512, 8, 8]               0
          Conv2d-166            [-1, 512, 8, 8]       2,359,296
     BatchNorm2d-167            [-1, 512, 8, 8]           1,024
            ReLU-168            [-1, 512, 8, 8]               0
          Conv2d-169           [-1, 2048, 8, 8]       1,048,576
     BatchNorm2d-170           [-1, 2048, 8, 8]           4,096
            ReLU-171           [-1, 2048, 8, 8]               0
      Bottleneck-172           [-1, 2048, 8, 8]               0
AdaptiveAvgPool2d-173           [-1, 2048, 1, 1]               0
          Linear-174                 [-1, 1000]       2,049,000
================================================================
Total params: 25,557,032
Trainable params: 25,557,032
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.68
Forward/backward pass size (MB): 351.15
Params size (MB): 97.49
Estimated Total Size (MB): 449.33
----------------------------------------------------------------

Process finished with exit code 0

三、参考链接

骚火棍
关注
  • 5
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
62、python - 全手写搭建 resnet50 神经网络
AI与算法都要通俗易懂
01-07 1260
每一层命名为 Computexxx，比如第一层 ComputeConvLayer 说明这一层是一个卷积运算，ComputeAvgPoolLayer 说明这一层是一个平均池化运算，ComputeBottleNeck 说明这一层是一个BoottleNeck 结构，该结构包含了残差链接，查看上一节和前面一些。除了第一层的 ComputeConvLayer 第一个参数是 img 之外，后面所有层的第一个输入均为上一层的输出 out, 体现了神经网络逐层连接，数据从前往后流动的特点。的章节中，下载的模型。
pytorch_resnet:ResNet的PyTorch实施
05-15
ResNet的PyTorch实施 用法 $ python main.py --block_type basic --depth 110 --outdir results CIFAR-10的结果 模型 测试错误（3次运行的中位数） 测试错误（纸上） 训练时间 ResNet-110 6.52 6.43（最佳），...
ResNet神经网络搭建
最新发布
2301_78820199的博客
05-07 992
基于pytorch的resnet神经网络搭建
使用pytorch搭建自己的网络之ResNet
qq_40356092的博客
10-12 2066
一、introduction ResNet是2015年提出来的深度学习网络模型，其主要解决的是网络层数过多导致的退化问题。过去的网络模型层数差不多在十几二十层，随着网络层数的增多，人们发现模型的准确率很难再有较大的提升，甚至会出现准确率下降的情况，而ResNet提出的残差网络有效解决了这一问题，使得网络层数达到了上百层。 更重要的是，这一思想的提出，使得ResNet模型逐渐取代了VGG网络，几乎是当前应用最广泛的CNN特征提取网络，甚至影响了学术界和工业界未来的发展方向。随后提出的Res2Net和Dense
ResNet网络详解及Pytorch代码实现（超详细帮助你掌握ResNet原理及实现）
wuzhuoxi7116的博客
05-24 2万+
目录1. ResNet解决了什么问题2. ResNet原理及结构2.1 BasicBlock结构2.2 BottleNeck结构2.3 ResNet结构3. ResNet代码详解(Pytorch)3.1 BasicBlock代码块3.2 BottleNeck代码块3.3 ResNet代码 博客中的ResNet内容来自何凯明大神在CVPR2016发表的文章《Deep Residual Learning for Image Recognition》，ResNet代码部分来自Pytorch官方实现的ResNet源
利用Pytorch实现ResNet网络
AdjsWsgz的博客
11-21 4608
ResNet在2015年由微软实验室提出，获得当年ImageNet竞赛中分类任务、目标检测第一名；获得COCO数据集目标检测、图像分割第一名
Pytorch搭建ResNet（附完整代码）
u013310820的博客
12-20 4658
卷积神经网络逐渐取代传统算法，成为处理计算机视觉任务的核心，ResNet[1]的提出更是CNN图像史上一件里程碑事件。当网络深度增加时，网络准确度出现饱和甚至下降，残差学习的提出解决了网络退化的问题。ResNet通过shortcut的方法让信息跨层传播，被跨越的层拟合的就是shortcut连接的两层之间的残差。
ResNet网络Pytorch实战.pdf
06-05
总结了ResNet的相关原理、网络结构，pytorch代码实现，并对自定义花类数据集进行训练和测试。
resnet-pytorch
05-17
在PyTorch中的实现。 当前，trainer仅支持数据集。 要求 PyTorch v0.4.0 火炬视觉 麻木 科学的 tqdm 表现： 楷模 数据集 没有身份的前1名 具有身份的前1名 ResNet-10 CIFAR-10 94.2％ 94.4％ ResNet-18 ...
pytorch-deeplab-resnet：pytorch中的DeepLab resnet v2模型
02-05
pytorch-deeplab-resnet 模型实现。 deepLab-ResNet的体系结构已完全复制自caffe实现。 该体系结构可在多个比例（1x，0.75x，0.5x）上计算输入图像上的损耗。 在这三个等级上分别计算损失。 除了这3个损失外，在将3...
【ResNet】Pytorch从零构建ResNet18
通过图灵测试的人类的博客_CSDN_PYTHON_DeepLearning_数据挖掘
05-21 3万+
Pytorch从零构建ResNet18 ResNet 目前是应用很广的网络基础框架，所以有必要了解一下.本文从简单的ResNet18开始，详细分析了ResNet18的网络结构，并研究BasicBlock的结构。， 使得整个结构非常清晰，再之后手工构建ResNet18网络就没有那么困难了。
ResNet（mini）搭建
u011304078的博客
06-09 1472
手把手教你构建ResNet残差网络【导读】ResNet在2015年名声大噪，影响了2016年DL在学术界和工业界的发展方向。它对每一层的输入做一个reference，形成残差函数。残差用来设计解决深度网络退化问题，同时也解决了梯度消失问题，使得网络性能得到提升。本文解释了残差网络的技巧以及手把手教你如何应用它。编译 | 专知参与 | Yingying, Xiaowen近年来，由于大量数据集和功能强...
pytorch从0开始搭建resnet网络
Haoyee1的博客
05-12 1377
本文利用pytorch从0开始搭建resnet50网络，仅仅是我的学习记录，若有错误请多指教
ResNet网络结构详解与模型的搭建
热门推荐
霹雳吧啦Wz
03-07 5万+
首先给出三个链接： 1. ResNet网络结构详解视频 2. 使用Pytorch搭建ResNet网络并基于迁移学习训练 3. 使用Tensorflow搭建ResNet网络并基于迁移学习训练 ResNet网络是在2015年由微软实验室提出，斩获当年ImageNet竞赛中分类任务第一名，目标检测第一名。获得COCO数据集中目标检测第一名，图像分割第一名。下图是ResNet34层模型的结构...
pytorch从零实现resnet
爱在深秋
08-10 1375
resnet搭建
使用pytorch搭建ResNet并基于迁移学习训练(超详细 |附训练代码)
qq_73462282的博客
08-09 5909
最近在完成学校暑假任务时候,推荐的b站视频中发现了一个非常好的 计算机视觉 + pytorch实战 的教程，相见恨晚，能让初学者少走很多弯路。因此决定按着up给的教程路线：图像分类→目标检测→…一步步学习用 pytorch 实现深度学习在 cv 上的应用，并做笔记整理和总结。up主教程给出了pytorch和tensorflow两个版本的实现，我暂时只记录pytorch版本的笔记。
【Intel校企合作课程】手动搭建ResNet网络实现检测并清除杂草
qq_53672099的博客
01-12 1129
ResNet（Residual Network）是一种深度卷积神经网络架构，由微软亚洲研究院的何凯明等人于2015年提出。它的核心思想是通过建立残差映射来训练深层网络。ResNet的主要贡献在于解决了深度神经网络中的梯度消失和梯度爆炸问题，使得深层网络的训练变得更加容易。它引入了“跨层连接”的概念，即将输入信号直接加到网络中的某一层输出上，从而保留了前面层的信息，避免信息丢失。ResNet的基本结构是残差块，它由两个卷积层和一个跨层连接组成。每个残差块的输入和输出尺寸相同，这使得它们可以直接相加。
基于pytorch搭建resnet模型
05-28
好的，您可以参考下面的代码： ```python import torch.nn as nn class BasicBlock(nn.Module): expansion = 1 def __init__(self, in_planes, planes, stride=1): super(BasicBlock, self).__init__() self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(planes) self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False) self.bn2 = nn.BatchNorm2d(planes) self.shortcut = nn.Sequential() if stride != 1 or in_planes != self.expansion*planes: self.shortcut = nn.Sequential( nn.Conv2d(in_planes, self.expansion*planes, kernel_size=1, stride=stride, bias=False), nn.BatchNorm2d(self.expansion*planes) ) def forward(self, x): out = nn.ReLU()(self.bn1(self.conv1(x))) out = self.bn2(self.conv2(out)) out += self.shortcut(x) out = nn.ReLU()(out) return out class ResNet(nn.Module): def __init__(self, block, num_blocks, num_classes=10): super(ResNet, self).__init__() self.in_planes = 64 self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False) self.bn1 = nn.BatchNorm2d(64) 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.linear = nn.Linear(512*block.expansion, num_classes) def _make_layer(self, block, planes, num_blocks, stride): strides = [stride] + [1]*(num_blocks-1) layers = [] for stride in strides: layers.append(block(self.in_planes, planes, stride)) self.in_planes = planes * block.expansion return nn.Sequential(*layers) def forward(self, x): out = nn.ReLU()(self.bn1(self.conv1(x))) out = self.layer1(out) out = self.layer2(out) out = self.layer3(out) out = self.layer4(out) out = nn.AvgPool2d(4)(out) out = out.view(out.size(0), -1) out = self.linear(out) return out def ResNet18(): return ResNet(BasicBlock, [2,2,2,2]) ``` 这是一个基于PyTorch搭建ResNet18模型的例子。其中，BasicBlock是ResNet18的基本模块，ResNet是整个网络的结构体，包含多个BasicBlock，_make_layer函数用于构建多层BasicBlock，forward函数定义前向传播过程，ResNet18函数返回一个ResNet18模型的实例。您可以根据自己的需求修改或扩展该模型。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值