diy一个ResNet18网络

最新推荐文章于 2025-03-10 10:58:20 发布
最新推荐文章于 2025-03-10 10:58:20 发布
阅读量224 收藏
点赞数 1
文章标签： 网络 python 开发语言 pytorch 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Holy_cow/article/details/132907400
版权

一、网络结构

1.1 残差结构

在这里插入图片描述
代码如下：

class ResidualBlock(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1):
        super(ResidualBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)

        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)

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

    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.downsample(identity)
        out = self.relu(out)

        return out

1.2 ResNet18网络结构

在这里插入图片描述
代码如下：

class ResNet(nn.Module):
    def __init__(self, num_classes=1000):
        super(ResNet, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        self.layer1 = self.maker_layer(64, 64, blocks=2, stride=1)
        self.layer2 = self.maker_layer(64, 128, blocks=2, stride=2)
        self.layer3 = self.maker_layer(128, 256, blocks=2, stride=2)
        self.layer4 = self.maker_layer(256, 512, blocks=2, stride=2)
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(512, num_classes)

    def maker_layer(self, in_channels, out_channels, blocks, stride=1):
        layer = []
        layer.append(ResidualBlock(in_channels, out_channels, stride))
        for _ in range(1, blocks):
            layer.append(ResidualBlock(out_channels, out_channels))
        return nn.Sequential(*layer)

    def forward(self, x):
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        out = self.maxpool(out)

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

        out = self.avgpool(out)
        out = torch.flatten(out, 1)
        out = self.fc(out)

        return out

二、运行结果：

ResNet(
  (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
  (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (relu): ReLU(inplace=True)
  (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
  (layer1): Sequential(
    (0): ResidualBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential()
    )
    (1): ResidualBlock(
      (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential()
    )
  )
  (layer2): Sequential(
    (0): ResidualBlock(
      (conv1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(64, 128, kernel_size=(1, 1), stride=(2, 2), bias=False)
      )
    )
    (1): ResidualBlock(
      (conv1): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential()
    )
  )
  (layer3): Sequential(
    (0): ResidualBlock(
      (conv1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(2, 2), bias=False)
      )
    )
    (1): ResidualBlock(
      (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential()
    )
  )
  (layer4): Sequential(
    (0): ResidualBlock(
      (conv1): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential(
        (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
      )
    )
    (1): ResidualBlock(
      (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (relu): ReLU(inplace=True)
      (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
      (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
      (downsample): Sequential()
    )
  )
  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
  (fc): Linear(in_features=512, out_features=1000, bias=True)
)
----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Conv2d-1         [-1, 64, 112, 112]           9,408
       BatchNorm2d-2         [-1, 64, 112, 112]             128
              ReLU-3         [-1, 64, 112, 112]               0
         MaxPool2d-4           [-1, 64, 56, 56]               0
            Conv2d-5           [-1, 64, 56, 56]          36,864
       BatchNorm2d-6           [-1, 64, 56, 56]             128
              ReLU-7           [-1, 64, 56, 56]               0
            Conv2d-8           [-1, 64, 56, 56]          36,864
       BatchNorm2d-9           [-1, 64, 56, 56]             128
             ReLU-10           [-1, 64, 56, 56]               0
    ResidualBlock-11           [-1, 64, 56, 56]               0
           Conv2d-12           [-1, 64, 56, 56]          36,864
      BatchNorm2d-13           [-1, 64, 56, 56]             128
             ReLU-14           [-1, 64, 56, 56]               0
           Conv2d-15           [-1, 64, 56, 56]          36,864
      BatchNorm2d-16           [-1, 64, 56, 56]             128
             ReLU-17           [-1, 64, 56, 56]               0
    ResidualBlock-18           [-1, 64, 56, 56]               0
           Conv2d-19          [-1, 128, 28, 28]          73,728
      BatchNorm2d-20          [-1, 128, 28, 28]             256
             ReLU-21          [-1, 128, 28, 28]               0
           Conv2d-22          [-1, 128, 28, 28]         147,456
      BatchNorm2d-23          [-1, 128, 28, 28]             256
           Conv2d-24          [-1, 128, 28, 28]           8,192
             ReLU-25          [-1, 128, 28, 28]               0
    ResidualBlock-26          [-1, 128, 28, 28]               0
           Conv2d-27          [-1, 128, 28, 28]         147,456
      BatchNorm2d-28          [-1, 128, 28, 28]             256
             ReLU-29          [-1, 128, 28, 28]               0
           Conv2d-30          [-1, 128, 28, 28]         147,456
      BatchNorm2d-31          [-1, 128, 28, 28]             256
             ReLU-32          [-1, 128, 28, 28]               0
    ResidualBlock-33          [-1, 128, 28, 28]               0
           Conv2d-34          [-1, 256, 14, 14]         294,912
      BatchNorm2d-35          [-1, 256, 14, 14]             512
             ReLU-36          [-1, 256, 14, 14]               0
           Conv2d-37          [-1, 256, 14, 14]         589,824
      BatchNorm2d-38          [-1, 256, 14, 14]             512
           Conv2d-39          [-1, 256, 14, 14]          32,768
             ReLU-40          [-1, 256, 14, 14]               0
    ResidualBlock-41          [-1, 256, 14, 14]               0
           Conv2d-42          [-1, 256, 14, 14]         589,824
      BatchNorm2d-43          [-1, 256, 14, 14]             512
             ReLU-44          [-1, 256, 14, 14]               0
           Conv2d-45          [-1, 256, 14, 14]         589,824
      BatchNorm2d-46          [-1, 256, 14, 14]             512
             ReLU-47          [-1, 256, 14, 14]               0
    ResidualBlock-48          [-1, 256, 14, 14]               0
           Conv2d-49            [-1, 512, 7, 7]       1,179,648
      BatchNorm2d-50            [-1, 512, 7, 7]           1,024
             ReLU-51            [-1, 512, 7, 7]               0
           Conv2d-52            [-1, 512, 7, 7]       2,359,296
      BatchNorm2d-53            [-1, 512, 7, 7]           1,024
           Conv2d-54            [-1, 512, 7, 7]         131,072
             ReLU-55            [-1, 512, 7, 7]               0
    ResidualBlock-56            [-1, 512, 7, 7]               0
           Conv2d-57            [-1, 512, 7, 7]       2,359,296
      BatchNorm2d-58            [-1, 512, 7, 7]           1,024
             ReLU-59            [-1, 512, 7, 7]               0
           Conv2d-60            [-1, 512, 7, 7]       2,359,296
      BatchNorm2d-61            [-1, 512, 7, 7]           1,024
             ReLU-62            [-1, 512, 7, 7]               0
    ResidualBlock-63            [-1, 512, 7, 7]               0
AdaptiveAvgPool2d-64            [-1, 512, 1, 1]               0
           Linear-65                 [-1, 1000]         513,000
================================================================
Total params: 11,687,720
Trainable params: 11,687,720
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.57
Forward/backward pass size (MB): 61.45
Params size (MB): 44.59
Estimated Total Size (MB): 106.61
----------------------------------------------------------------

进程已结束,退出代码0

附录：

import torch
import torch.nn as nn
from torchsummary import summary


class ResidualBlock(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1):
        super(ResidualBlock, self).__init__()
        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)

        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)

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

    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.downsample(identity)
        out = self.relu(out)

        return out


class ResNet(nn.Module):
    def __init__(self, num_classes=1000):
        super(ResNet, self).__init__()
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        self.layer1 = self.maker_layer(64, 64, blocks=2, stride=1)
        self.layer2 = self.maker_layer(64, 128, blocks=2, stride=2)
        self.layer3 = self.maker_layer(128, 256, blocks=2, stride=2)
        self.layer4 = self.maker_layer(256, 512, blocks=2, stride=2)
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Linear(512, num_classes)

    def maker_layer(self, in_channels, out_channels, blocks, stride=1):
        layer = []
        layer.append(ResidualBlock(in_channels, out_channels, stride))
        for _ in range(1, blocks):
            layer.append(ResidualBlock(out_channels, out_channels))
        return nn.Sequential(*layer)

    def forward(self, x):
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        out = self.maxpool(out)

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

        out = self.avgpool(out)
        out = torch.flatten(out, 1)
        out = self.fc(out)

        return out


device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = ResNet().to(device)
print(model)
summary(model, (3, 224, 224))
Holy_cow
关注
Resnet-18的搭建
DIECTOR_YUAN的博客
05-10 932
在Cifar10数据集上面搭建Resnet18 import tensorflow as tf import os import numpy as np from matplotlib import pyplot as plt from tensorflow.keras.layers import Conv2D, BatchNormalization, Activation, MaxPool2D, Dropout, Flatten, Dense from tensorflow.keras import Mo
resnet50网络结构_pytorch实践(改造属于自己的resnet网络结构并训练二分类网络)
weixin_39854288的博客
11-21 1783
我的优快云博客：https://blog.youkuaiyun.com/litt1e我的公众号：工科宅生活在学习pytorch过程中，突然想拥有属于自己的网络结构，于是便自己选择了一个比较简单的resnet18进行改造，并用其对蚂蚁和蜜蜂进行分类，比较一下没有经过预训练的resnet18好还是自己改造的resnet_diy好。在开始撸代码之前，为了方便大家自己设计网络，我把resnet的pytorch实现详...
ResNet 18 网络结构
S20144144的博客
09-25 1万+
import torch from torchvision import models resnet = models.resnet18(pretrained=True) print(resnet) """ ResNet( (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False...
ResNet 经典网络详解：深度学习中的革命性突破（含代码）
最新发布
murphymeng2001的博客
03-10 3129
如果你对 ResNet 还有更深入的兴趣，可以尝试 ResNet-50、ResNet-101 这些更深层次的变体，或者结合 Transformer、注意力机制等技术进行优化！在深度学习的发展历程中，ResNet（残差网络）是一个重要的突破。它成功解决了深层神经网络训练中的梯度消失问题，使得深度模型能够达到更好的性能。ResNet-18 是深度学习领域中最经典的网络之一，尤其在图像分类任务上表现优异。为例，详细解析其网络结构、关键技术，并探讨其实际应用。，避免梯度消失，并帮助网络学习更深层次的特征。
LeNet模型搭建
weixin_64443786的博客
08-02 267
LeNet
ResNet-18結構
gesshoo的博客
02-27 6007
残差块⾥⾸先有 2 个有相同输出通道数的 3 × 3 卷积层。每 个卷积层后接⼀个批量归⼀化层和 ReLU 激活函数。然后我们通过跨层数据通路，跳过这 2 个卷积运算，将输⼊直接加在最后的 ReLU 激活函数前。这样的设计要求 2 个卷积层的输出与输⼊形状⼀样，从而可以相加。 如 果想改变通道数，就需要引⼊⼀个额外的 1 × 1 卷积层来将输⼊变换成需要的形状后再做相加运算。 import torch from torch import nn from torch....
图像识别-ResNet-18网络结构图示及解读
算法之美
05-22 4万+
图像识别-ResNet-18网络结构图示及解读
深度学习课设基于Transformer与Resnet CNN网络实现图像分类任务源码（含模型+项目说明）.zip
07-26
深度学习课设基于Transformer与Resnet CNN网络实现图像分类任务源码（含模型+项目说明）.zip 在Convolution-enhanced image Transformer（CeiT）上进行CIFAR100的训练，baseline 为 ResNet18 文件下载 包含 CeiT 和...
基于PyTorch实现ResNet自蒸馏网络源码（可在CIFAR-100数据集上训练，供学习借鉴）.zip
09-24
基于PyTorch实现ResNet自蒸馏网络源码（可在CIFAR-100数据集上训练，供学习借鉴）.zip基于PyTorch实现ResNet自蒸馏网络源码（可在CIFAR-100数据集上训练，供学习借鉴）.zip 【说明】 【1】项目代码完整且功能都验证...
基于YOLOv5和ResNet网络实现人体姿态估计项目源码及模型带语音播报(支持树莓派、weindows运行).zip
08-22
基于YOLOv5和ResNet网络实现的人体姿态估计项目是一个结合了目标检测与姿态估计技术的综合性项目。该项目旨在通过深度学习模型，实时地识别图像或视频中的人体，并估计其姿态，即确定人体的关键点位置（如关节点）...
深度学习期末大作业-基于ResNet网络算法实现花卉识别系统python源码+数据集+模型.zip
06-03
深度学习期末大作业-基于ResNet网络算法实现花卉识别系统python源码+数据集+模型.zip 【优质项目推荐】 1.项目代码功能经验证ok，确保稳定可靠运行。欢迎下载使用！在使用过程中，如有问题或建议，请及时私信沟通，...
【ResNet】Pytorch从零构建ResNet18
通过图灵测试的人类的博客_优快云_PYTHON_DeepLearning_数据挖掘
05-21 3万+
Pytorch从零构建ResNet18 ResNet 目前是应用很广的网络基础框架，所以有必要了解一下.本文从简单的ResNet18开始，详细分析了ResNet18的网络结构，并研究BasicBlock的结构。， 使得整个结构非常清晰，再之后手工构建ResNet18网络就没有那么困难了。
ResNet结构图（ResNet18、ResNet50）
Drug discovery
09-09 6884
ResNet18中的"18"指的是网络中的加权层数量。具体来说，它包含了18个卷积层和全连接层。
pytorch 手动顺序搭建resnet18、附带训练代码、测试代码、个人记录，若有错误，你可以去别处参考
雪剑封心
01-09 7555
文件名：mode_resnet18。
模型部署系列 | 01: 基于Triton部署Resnet18(附完整代码，建议收藏)
ljp1919的专栏
07-17 1106
醉后不知天在水，满船清梦压星河。小伙伴们好，我是微信公众号《小窗幽记机器学习》的小编：卖猪脚饭的小女孩。。本文作为作为的开篇，主要介绍如何使用Triton Server部署Pytorch格式的模型，并利用NVIDIA官方提供的工具进行服务性能测试。完整代码其实都在文章里面了，如想进一步交流欢迎在微信公众号：《小窗幽记机器学习》上添加小编微信。。后续会持续整理专题，敬请关注。
写一个resnet18网络
weixin_42584507的博客
02-10 128
很好，您可以使用以下代码来实现ResNet-18网络： ```python import torch import torch.nn as nn import torch.nn.functional as F class ResidualBlock(nn.Module): def init(self, in_channels, out_channels, stride=1, downsam...
【分类网络】Resnet网络结构简述
chen1234520nnn的博客
09-26 1766
残差网络：解决普通深度学习网络中深度到达一定程度时，导致的错误率升高的问题。 文中表示：使用残差网络结构的深度网络，能够获得比浅网络更低的错误率，并且不断加深网络的层数时，性能并没有退化。 plan A B C表示不同的增加维度方式： Identity vs. Projection Shortcuts 比较了三种选择： （A）zero-padding shortcuts用来增加维度（R...
ResNet-18超详细介绍！！！！
热门推荐
m0_64799972的博客
09-08 10万+
残差神经网络(ResNet)是由微软研究院的何恺明、张祥雨、任少卿、孙剑等人提出的。ResNet 在2015 年的ILSVRC（ImageNet Large Scale Visual Recognition Challenge）中取得了冠军。残差神经网络的主要贡献是发现了“退化现象（Degradation）”，并针对退化现象发明了 “快捷连接（Shortcut connection）”，极大的消除了深度过大的神经网络训练困难问题。下面我将一步步引出退化现象和快捷连接。
ResNet18详细原理（含tensorflow版源码）
Code_and516的博客
03-28 2万+
ResNet18详细原理（含tensorflow版源码）
用python写一个resnet18网络
03-31
以下是一个使用PyTorch实现ResNet18的示例代码： ```python import torch import torch.nn as nn class BasicBlock(nn.Module): 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=False) self.bn1 = nn.BatchNorm2d(out_channels) self.relu = nn.ReLU(inplace=True) self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False) self.bn2 = nn.BatchNorm2d(out_channels) self.downsample = downsample 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 ResNet(nn.Module): 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=False) self.bn1 = nn.BatchNorm2d(64) self.relu = nn.ReLU(inplace=True) self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1) self.layer1 = self._make_layer(block, 64, 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=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 = x.reshape(x.shape[0], -1) x = self.fc(x) return x def resnet18(num_classes=1000): return ResNet(BasicBlock, [2, 2, 2, 2], num_classes=num_classes) ``` 以上代码实现了ResNet18网络结构，包括基础块（BasicBlock）和ResNet主体框架（ResNet）的定义，以及ResNet18网络的定义（resnet18）。 其中，BasicBlock为ResNet网络的基础块，ResNet为ResNet网络的主体框架，resnet18为ResNet18网络的定义。在ResNet主体框架中，通过_make_layer函数来构建网络层，并在forward函数中组合各层。最终，通过全局平均池化（AdaptiveAvgPool2d）和全连接层（Linear）将特征图转换为输出类别的概率分布。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值