【扒代码】CCFF跨尺度特征融合

最新推荐文章于 2024-09-18 11:31:30 发布
最新推荐文章于 2024-09-18 11:31:30 发布
阅读量1k 收藏 12
点赞数 7
分类专栏： 扒代码 文章标签： 深度学习 python 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77549977/article/details/141021254
版权 
import torch
import torch.nn as nn
import torch.nn.functional as F

class RepVggBlock(nn.Module):
    def __init__(self, ch_in, ch_out, act='relu'):
        super().__init__()
        self.ch_in = ch_in  # 输入通道数
        self.ch_out = ch_out  # 输出通道数

        # 第一个卷积层，使用 3x3 卷积核，填充为 1
        self.conv1 = ConvNormLayer(ch_in, ch_out, 3, 1, padding=1, act=None)
        # 第二个卷积层，使用 1x1 卷积核，无填充
        self.conv2 = ConvNormLayer(ch_in, ch_out, 1, 1, padding=0, act=None)

        # 初始化激活函数，如果未指定则使用恒等变换
        self.act = nn.Identity() if act is None else get_activation(act)

    def forward(self, x):
        # 前向传播，将输入 x 通过两个卷积层并相加
        y = self.conv1(x) + self.conv2(x)
        # 应用激活函数
        return self.act(y)

    def convert_to_deploy(self):
        # 转换为部署模式，将两个卷积层融合为一个
        if not hasattr(self, 'conv'):
            self.conv = nn.Conv2d(self.ch_in, self.ch_out, 3, 1, padding=1)

        # 获取等效的卷积核和偏置
        kernel, bias = self.get_equivalent_kernel_bias()
        # 更新融合后的卷积层的权重和偏置
        self.conv.weight.data = kernel
        self.conv.bias.data = bias
        # 注释：以下两行被注释掉了，它们原本用于删除 conv1 和 conv2 层
        # self.__delattr__('conv1')
        # self.__delattr__('conv2')

    def get_equivalent_kernel_bias(self):
        # 获取等效的卷积核和偏置
        kernel3x3, bias3x3 = self._fuse_bn_tensor(self.conv1)
        kernel1x1, bias1x1 = self._fuse_bn_tensor(self.conv2)
        # 将 1x1 卷积核填充为 3x3 大小
        return kernel3x3 + self._pad_1x1_to_3x3_tensor(kernel1x1), bias3x3 + bias1x1

    def _pad_1x1_to_3x3_tensor(self, kernel1x1):
        # 如果 1x1 卷积核不存在，则返回 0
        if kernel1x1 is None:
            return 0
        else:
            # 使用 F.pad 对 1x1 卷积核进行填充，使其成为 3x3 大小
            return F.pad(kernel1x1, [1, 1, 1, 1])

    def _fuse_bn_tensor(self, branch: ConvNormLayer):
        # 如果分支层不存在，则返回 0, 0
        if branch is None:
            return 0, 0
        # 获取卷积层的权重
        kernel = branch.conv.weight
        # 获取批量归一化层的参数
        running_mean = branch.norm.running_mean
        running_var = branch.norm.running_var
        gamma = branch.norm.weight
        beta = branch.norm.bias
        eps = branch.norm.eps
        # 计算并返回融合后的卷积核和偏置
        std = (running_var + eps).sqrt()
        t = (gamma / std).reshape(-1, 1, 1, 1)
        return kernel * t, beta - running_mean * gamma / std

功能解释：

  • RepVggBlock 类实现了一个可部署的卷积块，它可以在训练时使用两个卷积层（一个 3x3 卷积和一个 1x1 卷积），并在部署时将它们融合为一个 3x3 卷积层，以减少模型的复杂性和提高推理速度。
  • forward 方法定义了模型的前向传播逻辑，它将输入 x 通过两个卷积层，并将它们的结果相加，然后应用激活函数。
  • convert_to_deploy 方法用于将模型转换为部署模式，通过融合两个卷积层为一个卷积层，并更新其权重和偏置。
  • get_equivalent_kernel_bias 方法用于获取融合后的卷积核和偏置，以便在部署模式下使用。
  • _pad_1x1_to_3x3_tensor 方法用于将 1x1 卷积核填充为 3x3 大小，以便与 3x3 卷积核相加。
  • _fuse_bn_tensor 方法用于融合 BatchNorm 层到卷积层中，计算融合后的卷积核和偏置。

整体而言，RepVggBlock 类提供了一种灵活的方式来构建和部署高效的卷积块，它通过融合卷积和归一化层来简化模型结构，同时保持性能。这种设计在实际应用中有助于提高模型的推理速度和减少内存占用。

import torch
from torch import nn

class CCFF(nn.Module):
    def __init__(self,
                 in_channels,
                 out_channels,
                 num_blocks=3,
                 expansion=1.0,
                 bias=None,
                 act="silu"):
        super(CCFF, self).__init__()  # 调用基类的初始化方法
        # 计算隐藏层的通道数，基于输出通道数和扩展比例
        hidden_channels = int(out_channels * expansion)
        # 第一个1x1卷积层，用于通道混合
        self.conv1 = ConvNormLayer(in_channels, hidden_channels, 1, 1, bias=bias, act=act)
        # 第二个1x1卷积层，用于跨通道特征融合
        self.conv2 = ConvNormLayer(in_channels, hidden_channels, 1, 1, bias=bias, act=act)
        # 构建瓶颈层序列，包含多个 RepVggBlock
        self.bottlenecks = nn.Sequential(*[
            RepVggBlock(hidden_channels, hidden_channels, act=act) for _ in range(num_blocks)
        ])
        # 如果隐藏层通道数不等于输出通道数，则添加第三个1x1卷积层进行通道映射
        if hidden_channels != out_channels:
            self.conv3 = ConvNormLayer(hidden_channels, out_channels, 1, 1, bias=bias, act=act)
        else:
            # 如果相等，则使用恒等变换
            self.conv3 = nn.Identity()

    def forward(self, x):
        # 前向传播方法
        # 通过第一个1x1卷积层和瓶颈层
        x_1 = self.conv1(x)
        x_1 = self.bottlenecks(x_1)
        # 通过第二个1x1卷积层
        x_2 = self.conv2(x)
        # 将两个分支的输出相加，然后通过第三个1x1卷积层或恒等变换
        return self.conv3(x_1 + x_2)

# 测试代码
if __name__ == '__main__':
    # 实例化模型对象，输入和输出通道数均为64
    model = CCFF(in_channels=64, out_channels=64)
    # 创建一个随机初始化的输入张量，大小为 (批量大小, 通道数, 高度, 宽度)
    input = torch.randn(1, 64, 32, 32)
    # 通过模型前向传播得到输出
    output = model(input)
    # 打印输入和输出张量的大小
    print('input_size:', input.size())
    print('output_size:', output.size())

功能解释：

  • CCFF 类是一个深度学习模块，它使用两个1x1卷积层和一个瓶颈层序列来实现特征融合和通道混合。
  • in_channels 和 out_channels 分别指定了输入和输出的通道数。
  • num_blocks 指定了瓶颈层序列中 RepVggBlock 的数量。
  • expansion 用于计算隐藏层的通道数，如果设置为1.0，则隐藏层通道数与输出通道数相同。
  • bias 参数用于控制卷积层是否使用偏置项。
  • act 指定了激活函数的类型，默认为 "silu"。
  • ConvNormLayer 是一个自定义的卷积层，包含卷积和批量归一化操作。
  • RepVggBlock 是一个自定义的卷积块，它可以在训练和部署时进行优化。
  • forward 方法定义了数据通过 CCFF 模块的流程，包括通过卷积层、瓶颈层、相加操作和最后的卷积或恒等变换。

整体而言，CCFF 类实现了一个灵活的特征融合模块，可以用于深度学习模型中的各种任务，如特征提取、特征融合等。通过调整参数，可以适应不同的网络结构和应用需求。

完整代码

import torch
import torch.nn as nn
import torch.nn.functional as F
# https://arxiv.org/abs/2304.08069
'''
论文题目：DETR 在实时目标检测方面击败 YOLO    CVPR 2024
即插即用模块：CCFF跨尺度特征融合模块
CCFF基于跨尺度融合模块进行优化，该模块将多个由卷积层组成的融合块插入到融合路径中。
融合块的作用是将两个相邻的尺度特征融合成一个新的特征，其结构如图 5 所示。
融合块包含两个 1 × 1 卷积来调整通道数，由 RepConv[8]组成的 N 个 RepBlocks 用于特征融合，
两路径输出通过元素加法融合。

'''
# 激活层模块
def get_activation(act: str, inpace: bool = True):
    '''get activation
    '''
    # 将输入的激活函数名称转换为小写
    act = act.lower()

    if act == 'silu': m = nn.SiLU()

    elif act == 'relu': m = nn.ReLU()

    elif act == 'leaky_relu': m = nn.LeakyReLU()

    elif act == 'silu': m = nn.SiLU()

    elif act == 'gelu': m = nn.GELU()

    # 如果没有指定激活函数，使用恒等变换
    elif act is None: m = nn.Identity() 

    # 如果输入的是一个 nn.Module 对象，则直接使用该对象
    elif isinstance(act, nn.Module): m = act

    else: raise RuntimeError('')

    # 如果激活层模块有 inplace 属性，则设置该属性
    if hasattr(m, 'inplace'): m.inplace = inpace

    return m

# 类 ConvNormLayer 用于构建一个包含卷积、归一化和激活函数的卷积层。
class ConvNormLayer(nn.Module):
    def __init__(self, ch_in, ch_out, kernel_size, stride, padding=None, bias=False, act=None):
        super().__init__()
        self.conv = nn.Conv2d(
            ch_in,# 输入通道数
            ch_out,# 输出通道数
            kernel_size,# 卷积核大小
            stride,# 步长
            padding=(kernel_size - 1) // 2 if padding is None else padding,# 计算填充，以保持输出尺寸不变
            bias=bias)# 是否使用偏置项
        
        # 初始化批量归一化层
        self.norm = nn.BatchNorm2d(ch_out)
        # 根据提供的激活函数名称或对象，初始化激活层
        self.act = nn.Identity() if act is None else get_activation(act)

    def forward(self, x):# 前向传播方法，将输入 x 通过卷积层、归一化层和激活层
        return self.act(self.norm(self.conv(x)))


class RepVggBlock(nn.Module):
    def __init__(self, ch_in, ch_out, act='relu'):
        super().__init__()
        self.ch_in = ch_in  # 输入通道数
        self.ch_out = ch_out # 输出通道数

        # 第一个卷积层，使用 3x3 卷积核，填充为 1
        self.conv1 = ConvNormLayer(ch_in, ch_out, 3, 1, padding=1, act=None)
        # 第二个卷积层，使用 1x1 卷积核，无填充
        self.conv2 = ConvNormLayer(ch_in, ch_out, 1, 1, padding=0, act=None)
        # 初始化激活函数，如果未指定则使用恒等变换
        self.act = nn.Identity() if act is None else get_activation(act)

    def forward(self, x):
        # 前向传播，将输入 x 通过两个卷积层并相加
        if hasattr(self, 'conv'):           
            y = self.conv(x)
        else:
            y = self.conv1(x) + self.conv2(x)
        # 应用激活函数
        return self.act(y)

    def convert_to_deploy(self):
        # 此函数将模型转换为部署模式
        # 如果模型中还没有融合的卷积层，则创建一个
        # 转换为部署模式，将两个卷积层融合为一个
        if not hasattr(self, 'conv'):
            self.conv = nn.Conv2d(self.ch_in, self.ch_out, 3, 1, padding=1)
        
        # 获取融合后的卷积核和偏置
        kernel, bias = self.get_equivalent_kernel_bias()

        # 更新融合后的卷积层的权重和偏置
        self.conv.weight.data = kernel
        self.conv.bias.data = bias
        # self.__delattr__('conv1')
        # self.__delattr__('conv2')

    def get_equivalent_kernel_bias(self):
        # 此函数获取等效的卷积核和偏置，将两个卷积层融合为一个
        # 获取等效的卷积核和偏置
        kernel3x3, bias3x3 = self._fuse_bn_tensor(self.conv1)
        kernel1x1, bias1x1 = self._fuse_bn_tensor(self.conv2)
        # 将1x1卷积层的权重扩展为3x3大小，然后与3x3卷积层的权重相加
        return kernel3x3 + self._pad_1x1_to_3x3_tensor(kernel1x1), bias3x3 + bias1x1

    def _pad_1x1_to_3x3_tensor(self, kernel1x1):

        # 如果 1x1 卷积核不存在，则返回 0
        if kernel1x1 is None:
            return 0
        else:
            # 使用 F.pad 对 1x1 卷积核进行填充，使其成为 3x3 大小
            return F.pad(kernel1x1, [1, 1, 1, 1])

    def _fuse_bn_tensor(self, branch: ConvNormLayer):
        # 如果分支层不存在或为None，则返回0, 0
        if branch is None:
            return 0, 0
         # 融合卷积层和批量归一化层的权重和偏置
        kernel = branch.conv.weight
        # 获取批量归一化层的参数
        running_mean = branch.norm.running_mean
        running_var = branch.norm.running_var
        gamma = branch.norm.weight
        beta = branch.norm.bias
        eps = branch.norm.eps
        # 计算并返回融合后的卷积核和偏置
        std = (running_var + eps).sqrt()# 计算标准差
        t = (gamma / std).reshape(-1, 1, 1, 1)# 计算缩放因子
        return kernel * t, beta - running_mean * gamma / std# 返回融合后


class CCFF(nn.Module):
    def __init__(self,
                 in_channels,
                 out_channels,
                 num_blocks=3,
                 expansion=1.0,
                 bias=None,
                 act="silu"):
        super(CCFF, self).__init__()# 调用基类的初始化方法
        # 计算隐藏层的通道数，基于输出通道数和扩展比例
        hidden_channels = int(out_channels * expansion)
        # 第一个1x1卷积层，用于通道混合
        self.conv1 = ConvNormLayer(in_channels, hidden_channels, 1, 1, bias=bias, act=act)
        # 第二个1x1卷积层，用于跨通道特征融合
        self.conv2 = ConvNormLayer(in_channels, hidden_channels, 1, 1, bias=bias, act=act)
        # 构建瓶颈层序列，包含多个 RepVggBlock
        self.bottlenecks = nn.Sequential(*[
            RepVggBlock(hidden_channels, hidden_channels, act=act) for _ in range(num_blocks)
        ])
        # 如果隐藏层通道数不等于输出通道数，则添加第三个1x1卷积层进行通道映射
        if hidden_channels != out_channels:
            self.conv3 = ConvNormLayer(hidden_channels, out_channels, 1, 1, bias=bias, act=act)
        else:
            # 如果相等，则使用恒等变换
            self.conv3 = nn.Identity()

    def forward(self, x):
        # 前向传播方法
        # 通过第一个1x1卷积层和瓶颈层
        x_1 = self.conv1(x)
        x_1 = self.bottlenecks(x_1)
        # 通过第二个1x1卷积层
        x_2 = self.conv2(x)
        # 将两个分支的输出相加，然后通过第三个1x1卷积层或恒等变换
        return self.conv3(x_1 + x_2)

# 输入 N C H W,  输出 N C H W
if __name__ == '__main__':
    # 实例化模型对象
    model = CCFF(in_channels=64, out_channels=64)
    # 创建一个随机初始化的输入张量，大小为 (批量大小, 通道数, 高度, 宽度)
    input = torch.randn(1, 64, 32, 32)
    output = model(input)
    print('input_size:',input.size())
    print('output_size:',output.size())

dearRongerr
关注
专栏目录
YOLOv8改进 | 融合改进篇 | 轻量化CCFM + SENetv2进行融合改进涨点 (全网独家首发)
走向CTO的路上...
07-10 1201
本篇介绍了一种利用轻量化CCFM和SENetv2进行融合改进的YOLOv8改进方法可以显著提升YOLOv8模型在目标检测和图像分割任务上的精度。本篇介绍了一种利用轻量化CCFM和SENetv2进行融合改进的YOLOv8改进方法，该方法可以显著提升YOLOv8模型在目标检测和图像分割任务上的精度，同时减小模型的计算量。
【YOLOv8改进[Head检测头]】YOLOv8换个RT-DETR head助力模型更优秀
静谧、淡雅
04-23 2214
YOLOv8换个RT-DETR head助力模型更优秀
跨尺度特征融合
小嘤熊的博客
11-08 1091
首先，需要通过使用 1 × 1 卷积将 FA2、FA3、FA4、FA5 和 F′A6 的通道维度（即特征图的厚度）从 256 减少到 64，得到 FB2、FB3、FB4、FB5 和 FB6 的五个中间特征。这样，在后续预测的处理中，不仅使用了当前层的特征信息，还考虑了其他四层的上下文特征，使获得的新特征更加强大。然而，当将SE块完全嵌入到backbone中时，推理时间会在一定程度上增加，所以只是将SE块放在具有更多语义信息的深层，然后通过CSFF模块逐步将增强的全局特征传输到所有其他较浅的层。
BiFPN 论文重点研读：高效双向跨尺度连接和加权特征融合
世上安得两全法？
04-04 3595
本文重点在于说明设计了BiFPN特征网络结构，如果能多使用几次BiFPN的话，会使实验效果更好。
【Head-DETR系列（4）】【CVPR2024】DETRs Beat YOLOs on Real-time Object Detection
最新发布
Hali_Botebie的博客
09-18 74
YOLO 系列因其在速度和准确度之间的合理权衡而成为最受欢迎的实时物体检测框架。然而，我们观察到 YOLO 的速度和准确度受到 NMS 的负面影响。最近，基于 Transformer 的端到端检测器 (DETR) 提供了一种消除 NMS 的替代方案。然而，高计算成本限制了它们的实用性，阻碍了它们充分利用排除 NMS 的优势。在本文中，我们提出了实时检测变换器 (RT-DETR)，这是我们所知的第一个解决上述困境的实时端到端物体检测器。我们借鉴先进的 DETR 分两步构建 RT-DETR：首先我们专注于在。
RT-DETR:DETRs Beat YOLOs on Real-time Object Detection (CVPR2024)
qq_40734883的博客
07-29 1370
文中提出了第一个实时端到端对象检测器RT-DETR。通过借鉴高级DETR，分两步构建RT-DETR：首先专注于在不牺牲准确性的同时提高速度，然后在不牺牲速度的同时提高准确性。具体来说，设计了**一个高效的混合编码器**，通过分离同一尺度上的相互作用和跨尺度融合，以加快多尺度特征的处理速度。然后，提出了**不确定性最小化的查询选择**，为解码器提供高质量的初始查询，从而提高了准确性。此外，RT-DETR支持通过调整解码器层数来适应各种场景的灵活速度调整，而无需重新训练。
【笔记】缩放点积注意力、LOCA架构、CCFF跨尺度融合模块
2301_77549977的博客
08-07 194
CCFF：RT-DETR中的CCFF结构代码详解(Pytorch)
Zssss12的博客
08-12 1368
基于上述分析，我们重新思考编码器的结构，提出了一种有效的混合编码器，由基于注意力的尺度内特征交互（AIFI）和基于 CNN 的跨尺度特征融合（CCFF）两个模块组成。然而，由于缺乏语义概念以及重复和与高级特征交互混淆的风险，低级特征的尺度内交互是不必要的。CCFF是作者提出的一种类似于特征金字塔的特征融合模块，S3，S4，S5是backbone的后三层，作者在论文中证明了只对S5进行尺度内交互，而不对更低级别的特征进行尺度内交互，并对次做法的合理性进行了证明，再次不多赘述。省略一部分位置编码的代码。
多尺度特征提取模块 Multi-Scale Module及代码
热门推荐
qq_41917697的博客
01-23 4万+
即插即用的多尺度特征提取模块及代码小结Inception ModuleSPPPPMASPPGPMBig-Little Module(BLM)PAFEMFoldConv_ASPP 现在很多的网络都有多尺度特征提取模块来提升网络性能，这里简单总结一下那些即插即用的小模块。 禁止抄袭或转载！！！ Inception Module 最早的应该算是在ILSVRC2014比赛分类项目获得第一名的GoogLeNet（Incepetion V1），该网络设计了Inception module。 后来出现了很多进化版本：I
AlexNet 结构学习
zoeyunjj的博客
06-12 3930
在2012年的时候，Geoffrey和他学生Alex为了回应质疑者，在ImageNet的竞赛中出手了，刷新了imageclassification的记录，一举奠定了deep learning 在计算机视觉中的地位。后边的故事大家都知道了，deeplearning一统天下，所向披靡。 在这次竞赛中Alex所用的结构被称为作为AlexNet。本部分首先介AlexNet的基本的architecture
目标检测算法之RT-DETR
weixin_52862386的博客
06-27 1342
对RT-DETR的encoder部分，整体看下来像是yolo的backbone+neck。RT-DETR的核心还是在增速上，所以这里它的优化思想是值得借鉴的，但是yolo结构跟DETR结构之间的界限越来越模糊了。对query的优化上，只是做了对齐，使其选择的query更加精确。整体而言模型的创新不大。虽然DETR提倡的是NMS-Free，但是对于某些对精装度要求较高的任务中，如果阈值设置过低，导致最后得出的框过多，仍然需要借助NMS的方法去改进。设置过高则存在丢框的问题。
RT-DETR: 实时目标检测的又一次进化
Warmer_Sweeter
07-22 1475
点击下方卡片，关注“小白玩转Python”公众号实时目标检测是一个具有广泛应用的关键领域，从物体跟踪到自动驾驶。想象一下，一辆能够实时检测行人和其他车辆的自动驾驶汽车，或一个可以同时跟踪多个移动物体的监控系统。这些系统的效率和准确性取决于其快速、准确地处理和分析视觉数据的能力。这就是实时目标检测的重要性所在。在这篇文章中，我们将讨论 RT-DETR 及其实现。虽然 RT-DETR 可能听起来像一个...
可见光与红外图像融合 matlab_部分红外与可见光图像融合算法代码下载
weixin_28812205的博客
01-27 1426
点击笑书神侠读博学关注我文 | 张星辰前几天写了一篇文章整理了一些多曝光图像融合算法(含几种通用图像融合算法)的下载链接，反响还不错。为了进一步方便相关研究人员，在这篇文章里我再提供一些(20 种)红外可见光图像融合算法的下载链接。这些算法是我们在《VIFB: A Visible and Infrared Image Fusion Benchmark》中所使用的，具体实验结果可参考我们的...
基于相似性约束的多尺度融合子空间聚类网络
6658基于相似性约束的党志远1，邓成1，徐阳1，黄恒2，31西安电子科技大学电子工程学院西安2电气与计算机工程系，匹兹堡大学，PA 15260，美国3JD Finance America Corporation，Mountain View，CA 94043，USA{zydang...
【YOLOv8改进 - 检测头】 RT-DETR检测头，解决传统目标检测器中非极大值抑制（NMS）所带来的速度和准确性之间的平衡问题
专注于图像领域，主要研究内容包括计算机视觉和深度学习，特别是在图像分类、目标检测和图像生成等方面有深入的研究和实践经验。
07-02 693
YOLO 系列因其在速度和准确性之间的合理平衡，已成为实时目标检测中最受欢迎的框架。然而，我们观察到 YOLO 的速度和准确性受到非极大值抑制（NMS）的负面影响。最近，基于 Transformer 的端到端检测器（DETRs）提供了一种替代方案来消除 NMS。然而，高计算成本限制了它们的实用性，并阻碍了它们充分利用不使用 NMS 的优势。在本文中，我们提出了实时检测 Transformer（RT-DETR），据我们所知，这是第一个解决上述困境的实时端到端目标检测器。
python写一段多尺度融合的代码
weixin_35749440的博客
01-03 1157
好的，多尺度融合是一种图像处理技术，在计算机视觉中经常用于增强图像的边缘和细节。在 Python 中可以使用 OpenCV 库来实现多尺度融合。 下面是一段简单的多尺度融合代码示例，其中使用了 OpenCV 库中的 pyramids 和 addWeighted 函数： import cv2 # 读取图像 img = cv2.imread('image.jpg') # 生成图像金字塔 pyram...
在 ResNet 中实现多尺度的特征融合（内含代码，用于图像分类）
weixin_57111012的博客
12-05 5770
这个代码示例中，我添加了额外的卷积层和三个特征金字塔层，以便从不同的卷积层获得特征并进行融合。大家可以根据任务需求进行更改和优化。特征金字塔的思想能够提供更好的多尺度信息，有助于提高模型对不同目标大小的适应性。在 ResNet 中实现多尺度的特征融合，类似于特征金字塔网络（Feature Pyramid Network，FPN）的思想。
PaddleDetection-MaskRcnn结构拆分（一）
qq_45684033的博客
12-26 654
模型结构拆分为Backbone、Neck、Head、Post_Process四部分 首先是Backbone,算法结构图： modeling/backbone/resnet.py源码解析 首先是在yaml的配置文件：/configs/_base_/models/mask_rcnn_r50_fpn.yml ''' ResNet:#初始化 # index 0 stands for res2 depth: 50 #网络层数 norm_type: bn #BN类型 freeze_at:
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值