ConvNext做Backbone的Faster R-CNN和YOLOV4（结合博主Bubbliiing的TF2实现代码）

已于 2022-06-17 17:45:29 修改
阅读量1.6k 收藏 15
点赞数 3
文章标签： cnn tensorflow 深度学习
于 2022-06-17 17:04:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39910747/article/details/125334866
版权

参考

Bubbliiing：睿智的目标检测45——TF2搭建Faster R-CNN目标检测平台

太阳花的小绿豆：ConvNeXt网络详解

立Sir:【神经网络】(19) ConvNeXt 代码复现，网络解析，附Tensorflow完整代码

facebook：A ConvNet for the 2020s

ConvNext 结构

ConvNext 结构简单易懂，没有什么新颖的东西，新人可以看着结构图就能写。甚至连类都不用写。
下图为博主太阳花的小绿豆做的ConvNext-T( C = (96, 192, 384, 768), B = (3, 3, 9, 3))的结构图，但是我代码中用的ConvNext-B( C = (128, 256, 512, 1024), B = (3, 3, 27, 3))，甚至魔改ConvNext用的还是较多的

在这里插入图片描述

代码

YOLOV4

在修改bubbliiing的YOLOv4的Backbone时，我去掉了最后的Global Avg Pooling、Layer Norm以及Linear部分。直接输出，如果需要多尺度，输出后三个Stage的结果。借鉴了FaceBook团队源码以及太阳花的小绿豆动态的Dropout，实际影响不大。

import tensorflow as tf
import numpy as np

from tensorflow.keras import backend as K
from tensorflow.keras import Model
from tensorflow.keras.initializers import Constant
from tensorflow.keras.layers import (Conv2D, LayerNormalization,DepthwiseConv2D,Activation,Dropout,Layer,add,Dense)
from tensorflow.keras.utils import get_custom_objects

KERNEL_INITIALIZER = {
    "class_name": "TruncatedNormal",
    "config": {
        "stddev": 0.2
    }
}

BIAS_INITIALIZER = "Zeros"


class Mish(Layer):
    def __init__(self, **kwargs):
        super(Mish, self).__init__(**kwargs)
        self.supports_masking = True

    def call(self, inputs):
        return inputs * K.tanh(K.softplus(inputs))

    def get_config(self):
        config = super(Mish, self).get_config()
        return config

    def compute_output_shape(self, input_shape):
        return input_shape


def stem(inputs, num_filters):
    x = Conv2D(num_filters,
               kernel_size = (4,4),
               strides = 4,
               padding ='same',
               kernel_initializer = KERNEL_INITIALIZER,
               bias_initializer = BIAS_INITIALIZER)(inputs)
    x = LayerNormalization(epsilon=1e-6)(x)

    return x

def DownSample(inputs,num_filters):
    x = LayerNormalization(epsilon=1e-6)(inputs)

    x = Conv2D(num_filters,
               kernel_size = (2,2),
               strides = 2,
               padding = 'same',
               kernel_initializer = KERNEL_INITIALIZER,
               bias_initializer = BIAS_INITIALIZER)(x)
    return x

def ConvNext_Block(inputs, dropout_rate=0.,layer_scale_init_value = 1e-6):
    num_filters = inputs.shape[-1]

    residual = inputs

    x = DepthwiseConv2D(7,
                        strides = 1,
                        padding = 'same',
                        depthwise_initializer = KERNEL_INITIALIZER,
                        bias_initializer = BIAS_INITIALIZER)(inputs)

    x = LayerNormalization(epsilon=1e-6)(x)

    x = Conv2D(4*num_filters, 
                kernel_size=(1,1),
                 strides=1, 
                 padding='same',
                 kernel_initializer=KERNEL_INITIALIZER,
                 bias_initializer=BIAS_INITIALIZER)(x)
    
    # 1x1卷积等价于拉直
    # x = Dense(4 * dim,kernel_initializer=KERNEL_INITIALIZER,bias_initializer=BIAS_INITIALIZER)
    
    x = Activation('gelu')(x)
   
    x = Conv2D(num_filters, 
                kernel_size=(1,1),
                 strides=1, 
                 padding='same',
                 kernel_initializer=KERNEL_INITIALIZER,
                 bias_initializer=BIAS_INITIALIZER)(x)
    # Layer Scale
    gamma = Layer().add_weight(shape=[num_filters],
                               initializer=Constant(layer_scale_init_value),
                               dtype = tf.float32,
                               trainable = True)    

    if gamma is not None:
        x = gamma*x
    
    if dropout_rate > 0:
        x = Dropout(rate = dropout_rate)(x)

    x = add([x, residual])

    return x

def Res_stage(x, num, num_filters, dropout_rate, downsample = True,  layer_scale_init_value = 1e-6):
    '''
    num: 每个stage执行的block数
    out_channel: 输出通道数
    downsample: 是否下采样
    dropout_rate: 数组,为了动态DropOut
    '''
    if downsample is not False:
        x = DownSample(x, num_filters)

    for i in range(num):
        x = ConvNext_Block(x, dropout_rate = dropout_rate[i], layer_scale_init_value = layer_scale_init_value)
    
    return x

def ConvNext_Body(inputs, 
                  depths = [3,3,27,3], 
                  num_filters = [128,256,512,1024],
                  drop_path_rate = 0.25): # ConvNext_Base
    
    x = stem(inputs, num_filters[0])    # 416,416,3 -> 104, 104, 128
    
    dp_rates = np.linspace(start = 0, stop=drop_path_rate, num=sum(depths))
    sum_depths =[sum(depths[:1]),sum(depths[:2]),sum(depths[:3]),sum(depths[:4])]

    stage1_dp_rate = dp_rates[0:sum_depths[0]]
    x = Res_stage(x, num = depths[0], dropout_rate=stage1_dp_rate, num_filters = num_filters[0], downsample = False) # 104,104,128 -> 104,104,128

    stage2_dp_rate = dp_rates[sum_depths[0]:sum_depths[1]]
    x = Res_stage(x, num = depths[1], dropout_rate=stage2_dp_rate, num_filters = num_filters[1], downsample = True) # 104,104,128 -> 52,52,256
    feat1 = x

    stage3_dp_rate = dp_rates[sum_depths[1]:sum_depths[2]]
    x = Res_stage(x, num = depths[2], dropout_rate=stage3_dp_rate, num_filters = num_filters[2], downsample = True) # 104,104,128 -> 52,52,256
    feat2 = x

    stage4_dp_rate = dp_rates[sum_depths[2]:sum_depths[3]]
    x = Res_stage(x, num = depths[3], dropout_rate=stage4_dp_rate, num_filters = num_filters[3], downsample = True) # 52,52,256 -> 26,26,1024
    feat3 = x

    return feat1, feat2, feat3 # 输出多尺度

在文件./nets/yolo.py中，修改函数yolo_body即可

	# feat1,feat2,feat3 = darknet_body(inputs, weight_decay=weight_decay)
	feat1,feat2,feat3 = ConvNext_Body(inputs)

Faster R-CNN

在修改bubbliiing的Faster R-CNN的Backbone时，仿照他对Vgg16和ResNet50的处理方法。将前三个Stage提取特征图，最后一个Stage作为分类层。

from pyexpat import model
from unicodedata import name
import tensorflow as tf
import numpy as np

from tensorflow.keras import backend as K
from tensorflow.keras import Model
from tensorflow.keras.initializers import Constant
from tensorflow.keras.layers import (Conv2D, LayerNormalization,DepthwiseConv2D,Activation,Dropout,Layer,add,Dense,
                                    TimeDistributed,GlobalAveragePooling2D)



KERNEL_INITIALIZER = {
    "class_name": "TruncatedNormal",
    "config": {
        "stddev": 0.2
    }
}

BIAS_INITIALIZER = "Zeros"


def stem(inputs, num_filters):
    x = Conv2D(num_filters,
               kernel_size = (4,4),
               strides = 4,
               padding ='same',
               kernel_initializer = KERNEL_INITIALIZER,
               bias_initializer = BIAS_INITIALIZER)(inputs)
    x = LayerNormalization(epsilon=1e-6)(x)

    return x

def DownSample(inputs,num_filters):
    x = LayerNormalization(epsilon=1e-6)(inputs)

    x = Conv2D(num_filters,
               kernel_size = (2,2),
               strides = 2,
               padding = 'same',
               kernel_initializer = KERNEL_INITIALIZER,
               bias_initializer = BIAS_INITIALIZER)(x)
    return x

def ConvNext_Block(inputs, dropout_rate=0.,layer_scale_init_value = 1e-6):
    num_filters = inputs.shape[-1]

    residual = inputs

    x = DepthwiseConv2D(7,
                        strides = 1,
                        padding = 'same',
                        depthwise_initializer = KERNEL_INITIALIZER,
                        bias_initializer = BIAS_INITIALIZER)(inputs)

    x = LayerNormalization(epsilon=1e-6)(x)

    x = Conv2D(4*num_filters, 
                kernel_size=(1,1),
                 strides=1, 
                 padding='same',
                 kernel_initializer=KERNEL_INITIALIZER,
                 bias_initializer=BIAS_INITIALIZER)(x)
    
    # 1x1卷积等价于拉直
    # x = Dense(4 * dim,kernel_initializer=KERNEL_INITIALIZER,bias_initializer=BIAS_INITIALIZER)
    
    x = Activation('gelu')(x)
    # x = Activation('Mish')(x)

    x = Conv2D(num_filters, 
                kernel_size=(1,1),
                 strides=1, 
                 padding='same',
                 kernel_initializer=KERNEL_INITIALIZER,
                 bias_initializer=BIAS_INITIALIZER)(x)
    # Layer Scale
    gamma = Layer().add_weight(shape=[num_filters],
                               initializer=Constant(layer_scale_init_value),
                               dtype = tf.float32,
                               trainable = True)    

    if gamma is not None:
        x = gamma*x
    
    if dropout_rate > 0:
        x = Dropout(rate = dropout_rate)(x)

    x = add([x, residual])

    return x

def Res_stage(x, num, num_filters, dropout_rate, downsample = True,  layer_scale_init_value = 1e-6):
    '''
    num: 每个stage执行的block数
    out_channel: 输出通道数
    downsample: 是否下采样
    dropout_rate: 数组,为了动态DropOut
    '''
    if downsample is not False:
        x = DownSample(x, num_filters)

    for i in range(num):
        x = ConvNext_Block(x, dropout_rate = dropout_rate[i], layer_scale_init_value = layer_scale_init_value)
    
    return x

#  记得把也改了convnext_classifier_layers
def ConvNext_Body(inputs, 
                  depths = [3,3,9,3], 
                  # depths = [2,4,4,2],
                  num_filters = [96,192,384,768],
                  drop_path_rate = 0.25): # ConvNext_Base
    
    x = stem(inputs, num_filters[0])    #
    
    dp_rates = np.linspace(start = 0, stop=drop_path_rate, num=sum(depths))
    sum_depths =[sum(depths[:1]),sum(depths[:2]),sum(depths[:3]),sum(depths[:4])]

    stage1_dp_rate = dp_rates[0:sum_depths[0]]
    x = Res_stage(x, num = depths[0], dropout_rate=stage1_dp_rate, num_filters = num_filters[0], downsample = False) # 

    stage2_dp_rate = dp_rates[sum_depths[0]:sum_depths[1]]
    x = Res_stage(x, num = depths[1], dropout_rate=stage2_dp_rate, num_filters = num_filters[1], downsample = True) # 
    # feat1 = x

    stage3_dp_rate = dp_rates[sum_depths[1]:sum_depths[2]]
    x = Res_stage(x, num = depths[2], dropout_rate=stage3_dp_rate, num_filters = num_filters[2], downsample = True) # 
    # feat2 = x

    # return feat1, feat2, feat3
    return x

    # model = Model(inputs, x)
    # return model

#--------------------------------------------------#
#                  分类部分                         #
#--------------------------------------------------#
def DownSample_td(inputs,num_filters):
    x = TimeDistributed(LayerNormalization(epsilon=1e-6))(inputs)

    x = TimeDistributed(Conv2D(num_filters,
               kernel_size = (2,2),
               strides = 2,
               padding = 'same',
               kernel_initializer = KERNEL_INITIALIZER,
               bias_initializer = BIAS_INITIALIZER))(x)
    return x

def ConvNext_Block_td(inputs, dropout_rate=0.,layer_scale_init_value = 1e-6):
    num_filters = inputs.shape[-1]

    residual = inputs

    x = TimeDistributed(DepthwiseConv2D(7,
                        strides = 1,
                        padding = 'same',
                        depthwise_initializer = KERNEL_INITIALIZER,
                        bias_initializer = BIAS_INITIALIZER))(inputs)

    x = TimeDistributed(LayerNormalization(epsilon=1e-6))(x)

    x = TimeDistributed(Conv2D(4*num_filters, 
                kernel_size=(1,1),
                 strides=1, 
                 padding='same',
                 kernel_initializer=KERNEL_INITIALIZER,
                 bias_initializer=BIAS_INITIALIZER))(x)
    
    # 1x1卷积等价于拉直
    # x = Dense(4 * dim,kernel_initializer=KERNEL_INITIALIZER,bias_initializer=BIAS_INITIALIZER)
    
    x = Activation('gelu')(x)
    # x = Activation('Mish')(x)

    x = TimeDistributed(Conv2D(num_filters, 
                kernel_size=(1,1),
                 strides=1, 
                 padding='same',
                 kernel_initializer=KERNEL_INITIALIZER,
                 bias_initializer=BIAS_INITIALIZER))(x)
    # Layer Scale
    gamma = Layer().add_weight(shape=[num_filters],
                               initializer=Constant(layer_scale_init_value),
                               dtype = tf.float32,
                               trainable = True)    

    if gamma is not None:
        x = gamma*x
    
    if dropout_rate > 0:
        x = TimeDistributed(Dropout(rate = dropout_rate))(x)

    x = add([x, residual])

    return x
def Res_stage_td(x, num, num_filters, dropout_rate, downsample = True,  layer_scale_init_value = 1e-6):
    '''
    num: 每个stage执行的block数
    out_channel: 输出通道数
    downsample: 是否下采样
    dropout_rate: 数组,为了动态DropOut
    '''
    if downsample is not False:
        x = DownSample_td(x, num_filters)

    for i in range(num):
        x = ConvNext_Block_td(x, dropout_rate = dropout_rate[i], layer_scale_init_value = layer_scale_init_value)
    
    return x

def convnext_classifier_layers(x, 
                  depths = [3,3,9,3], 
                  # depths = [2,4,4,2],
                  num_filters = [96,192,384,768],
                  drop_path_rate = 0.25):
    
    dp_rates = np.linspace(start = 0, stop=drop_path_rate, num=sum(depths))
    sum_depths =[sum(depths[:1]),sum(depths[:2]),sum(depths[:3]),sum(depths[:4])]

    stage3_dp_rate = dp_rates[sum_depths[2]:sum_depths[3]]
    x = Res_stage_td(x, num = depths[3], dropout_rate=stage3_dp_rate, num_filters = num_filters[3], downsample = True)

    x = TimeDistributed(GlobalAveragePooling2D(),name='avg_pool')(x)
    
    return x


# 查看网络时记得修改
if __name__ == "__main__":
    input_shape=[600,600,3]
    input = tf.keras.Input(input_shape,4)

    model = ConvNext_Body(input)

    model.summary()

在./nets/frcnn.py中加入convnext相关函数，如下（注意我把vgg，resnet和convnext放入了./nets/backbone文件夹下）

from tensorflow.keras.layers import Input
from tensorflow.keras.models import Model

from nets.classifier import get_resnet50_classifier, get_vgg_classifier,get_convnext_classifier
from nets.rpn import get_rpn
from nets.backbones.resnet import ResNet50
from nets.backbones.vgg import VGG16
from nets.backbones.ConvNext import ConvNext_Body


def get_model(num_classes, backbone, num_anchors = 9, input_shape=[None, None, 3]):
    inputs      = Input(shape=input_shape)
    roi_input   = Input(shape=(None, 4))
    
    if backbone == 'vgg':
        #----------------------------------------------------#
        #   假设输入为600,600,3
        #   获得一个37,37,512的共享特征层base_layers
        #----------------------------------------------------#
        base_layers = VGG16(inputs)
        #----------------------------------------------------#
        #   将共享特征层传入建议框网络
        #   该网络结果会对先验框进行调整获得建议框
        #----------------------------------------------------#
        rpn         = get_rpn(base_layers, num_anchors)
        #----------------------------------------------------#
        #   将共享特征层和建议框传入classifier网络
        #   该网络结果会对建议框进行调整获得预测框
        #----------------------------------------------------#
        classifier  = get_vgg_classifier(base_layers, roi_input, 7, num_classes)

    if backbone == 'resnet50':
        #----------------------------------------------------#
        #   假设输入为600,600,3
        #   获得一个38,38,1024的共享特征层base_layers
        #----------------------------------------------------#
        base_layers = ResNet50(inputs)
        #----------------------------------------------------#
        #   将共享特征层传入建议框网络
        #   该网络结果会对先验框进行调整获得建议框
        #----------------------------------------------------#
        rpn         = get_rpn(base_layers, num_anchors)
        #----------------------------------------------------#
        #   将共享特征层和建议框传入classifier网络
        #   该网络结果会对建议框进行调整获得预测框
        #----------------------------------------------------#
        classifier  = get_resnet50_classifier(base_layers, roi_input, 14, num_classes)
    if backbone == 'convnext':
        #----------------------------------------------------#
        #   假设输入为600,600,3
        #   获得一个38,38,512的共享特征层base_layers
        #----------------------------------------------------#
        base_layers = ConvNext_Body(inputs)  
        #----------------------------------------------------#
        #   将共享特征层传入建议框网络
        #   该网络结果会对先验框进行调整获得建议框
        #----------------------------------------------------#
        rpn         = get_rpn(base_layers, num_anchors)
        #----------------------------------------------------#
        #   将共享特征层和建议框传入classifier网络
        #   该网络结果会对建议框进行调整获得预测框
        #----------------------------------------------------#
        classifier = get_convnext_classifier(base_layers, roi_input, 14, num_classes)
    model_rpn   = Model(inputs, rpn)
    model_all   = Model([inputs, roi_input], rpn + classifier)
    return model_rpn, model_all


def get_predict_model(num_classes, backbone, num_anchors = 9):
    inputs              = Input(shape=(None, None, 3))
    roi_input           = Input(shape=(None, 4))
    
    if backbone == 'vgg':
        feature_map_input = Input(shape=(None, None, 512))
        #----------------------------------------------------#
        #   假设输入为600,600,3
        #   获得一个37,37,512的共享特征层base_layers
        #----------------------------------------------------#
        base_layers = VGG16(inputs)
        #----------------------------------------------------#
        #   将共享特征层传入建议框网络
        #   该网络结果会对先验框进行调整获得建议框
        #----------------------------------------------------#
        rpn         = get_rpn(base_layers, num_anchors)
        #----------------------------------------------------#
        #   将共享特征层和建议框传入classifier网络
        #   该网络结果会对建议框进行调整获得预测框
        #----------------------------------------------------#
        classifier  = get_vgg_classifier(feature_map_input, roi_input, 7, num_classes)
    if backbone == 'resnet50':
        feature_map_input = Input(shape=(None, None, 1024))
        #----------------------------------------------------#
        #   假设输入为600,600,3
        #   获得一个38,38,1024的共享特征层base_layers
        #----------------------------------------------------#
        base_layers = ResNet50(inputs)
        #----------------------------------------------------#
        #   将共享特征层传入建议框网络
        #   该网络结果会对先验框进行调整获得建议框
        #----------------------------------------------------#
        rpn         = get_rpn(base_layers, num_anchors)
        #----------------------------------------------------#
        #   将共享特征层和建议框传入classifier网络
        #   该网络结果会对建议框进行调整获得预测框
        #----------------------------------------------------#
        classifier  = get_resnet50_classifier(feature_map_input, roi_input, 14, num_classes)
    if backbone == 'convnext':
        feature_map_input = Input(shape=(None, None, 512))
        #----------------------------------------------------#
        #   假设输入为600,600,3
        #   获得一个38,38,1024的共享特征层base_layers
        #----------------------------------------------------#
        base_layers = ConvNext_Body(inputs)
        #----------------------------------------------------#
        #   将共享特征层传入建议框网络
        #   该网络结果会对先验框进行调整获得建议框
        #----------------------------------------------------#
        rpn         = get_rpn(base_layers, num_anchors)

        #----------------------------------------------------#
        #   将共享特征层和建议框传入classifier网络
        #   该网络结果会对建议框进行调整获得预测框
        #----------------------------------------------------#
        classifier  = get_convnext_classifier(feature_map_input, roi_input, 14, num_classes)
        
    model_rpn   = Model(inputs, rpn + [base_layers])
    model_classifier_only = Model([feature_map_input, roi_input], classifier)
    return model_rpn, model_classifier_only
shAd0wst0rm
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
YOLOv9改进策略 ：主干backbone优化 | PKIBlock多尺度卷积核，优势无需膨胀，即插即用小目标涨点 | CVPR2024 PKINet 遥感图像目标检测
各专栏持续更新中，改进创新YOLO，适用v5、v7、v8、v9，订阅者私信添加本人微信！！！ By AI小怪兽
04-01 802
PKINet利用不同大小的多个深度卷积核，优势：无需膨胀即可提取不同感受野中的多尺度纹理特征。
理解ConvNeXt网络（结合代码）
Orange_sparkle的博客
09-13 1万+
ConvNeXt网络本身没有什么亮点，全是应用的现有的方法来进行网络的调整，特别是大量细节的设计都是参考了swin transformer的网络结构的。并且ConvNeXt是以ResNet50网络为backbone来进行调整的，所以ConvNeXt的网络结构非常简单，一目了然，理解起来也是非常容易的。并且不仅精度比swin Transformer高，推理速度还快。综合来说，ConvNeXt是一个非常好的文章。这里放上我看到的一个网友对ConvNeXt网络的评价。“感觉这篇论文的思路是照着swin-
DepthwiseConv2D和Conv2D详解
热门推荐
u010879745的博客
08-17 1万+
depthwise_conv2d和conv2d的不同之处在于conv2d在每一深度上卷积，然后求和，depthwise_conv2d卷积，不求和。 [https://www.cnblogs.com/itmorn/p/11250371.html] depthwise_conv2d 如下张量x和卷积核K进行depthwise_conv2d卷积 结果为： import tensorflow as tf # [batch, in_height, in_width, in_channels] input =t
ConvNeXt网络介绍,搭建以及训练
博客首页
05-01 1万+
ConvNeXt网络介绍 今年(2022)一月份，Facebook AI Research和UC Berkeley一起发表了一篇文章A ConvNet for the 2020s，在文章中提出了ConvNeXt纯卷积神经网络，它对标的是2021年非常火的Swin Transformer，通过一系列实验比对，在相同的FLOPs下，ConvNeXt相比Swin Transformer拥有更快的推理速度以及更高的准确率，在ImageNet 22K上ConvNeXt-XL达到了87.8%的准确率，参看下图。 原
ConvNeXt实战：使用ConvNeXt实现植物幼苗分类（自创，非官方）(1)
最新发布
m0_61549591的博客
04-17 376
先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！因此收集整理了一份《2024年最新Python全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。 既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Python知识点，真正体系化！由于文件比较多，这里只是将部分目录截图出来，全套
目标检测算法改进系列之Backbone替换为ConvNextV2
DM_zx的博客
09-28 702
目标检测算法改进系列之Backbone替换为ConvNextV2
ConvNeXt
xxd6167369958的博客
04-05 3859
ConvNeXt 研究思路 基于ResNet50进行改进，使用VIT的策略去训练原始的原始的ResNet50模型 1宏观设计 改变模型比例， ResNet50中stage1到stage4堆叠block的次数是(3, 4, 6, 3)比例大概是1:1:2:1，调整成(3, 3, 9, 3)和Swin-T拥有相似的计算速度（FLOPs），准确率由78.8%提升到了79.4%。 改变stem为patchify 作者将ResNet中的stem也换成了和Swin Transformer一样的patchify。替换后准
ConvNeXt+YOLOv7改进方案
ZzzzzKnight的博客
10-25 3235
改进代码
YOLOv9 网络结构 backbone 中的 RepNCSPELAN4 和 ADown 模块
weixin_46875627的博客
03-14 4436
看了YOLOv9的论文和代码，整理了一下网络中的模块，以方便理解和日后参考使用。
【神经网络】(19) ConvNeXt 代码复现，网络解析，附Tensorflow完整代码
博观而约取，厚积而薄发
03-28 6004
各位同学好，今天和大家分享一下如何使用 Tensorflow 构建 ConvNeXt 卷积神经网络模型。 论文地址：https://arxiv.org/pdf/2201.03545.pdf 完整代码在我的Gitee中：https://gitee.com/dgvv4/neural-network-model/tree/master/ 21年Transformer频频跨界视觉领域，先是在图像分类上被谷歌ViT突破，后来在目标检测和图像分割又被微软Swin Transformer拿下。随着投身视觉Trans
keras 卷积 conv1D conv2D SeparableConv depthwiseConv
陈泊舟的博客
03-20 5800
一句话卷积 本讲提要 这次结合代码跟大家分享四种卷积：一维卷积，二维卷积，以及基于它们的可分离卷积。 一维卷积 keras接口 keras.layers.Conv1D(filters, kernel_size, strides=1, padding='valid', data_format='channels_last', dilation_rate=1, activation=None, use...
Faster R-CNN backbone - ResNet101.zip
07-03
Faster R-CNN 的基础网络，ckpt 文件
Faster R-CNN backbone - VGG16.zip
05-19
Faster R-CNN 的基础网络，ckpt 文件
tf-faster-rcnn:Tensorflow 2 Faster-RCNN实施从零开始支持到使用MobileNetV2和VGG16主干进行批处理
05-24
要创建虚拟环境（tensorflow-2 gpu环境）： conda env create -f environment.yml 有两个不同的主干网，第一个是传统vgg16主干网，第二个和默认主干网是mobilenet_v2 。 您可以轻松地与--backbone参数一起指定要...
mobile-yolov5-pruning-distillation:mobilev2-yolov5s剪枝，蒸馏，支持ncnn，tensorRT部署。超轻但性能更好！
03-19
移动式yolov5修剪蒸馏mobilev2-yolov5s的通道修剪和蒸馏。超轻但性能更好！ TensorRT版本===> Android版本===> 背景yolov5s在640x640分辨率下的计算量和参数量分别为8.39G和7.07M。在速度上仍然有提升空间，通过替换...
第P9周：YOLOv5-Backbone模块实现
12-30
第P9周：YOLOv5-Backbone模块实现
DepthwiseConv2D深度卷积
weixin_38740463的博客
05-07 8369
1.DepthwiseConv2D（深度可分离 2D 卷积） 仅执行深度空间卷积中的第一步（其分别作用于每个输入通道） 普通卷积： 可以发现，卷积计算时卷积核每一个out_channel的两个通道分别和输入的两个通道做卷积相加，得到feature map的一个channel 即，每个每张特征图（3通道），可与卷积核（3维），分别通道进行卷积，相加后生成一维的特征图 ...
深度学习网络模型——ConvNeXt网络详解、ConvNeXt网络训练花分类数据集整体项目实现
guoqingru0311的博客
02-17 2701
深度学习网络模型——ConvNeXt网络详解、ConvNeXt网络训练花分类数据集整体项目实现
Faster R-CNN和SSD的优缺点
05-03
Faster R-CNN和SSD都是目标检测领域常用的算法，它们各自有优缺点。 Faster R-CNN的优点包括： - 检测精度高：使用RPN网络生成候选框，再使用RoI pooling对候选框进行特征提取和分类，相比于SSD在精度上有一定的优势。 - 灵活性好：可以使用不同的backbone网络，适用于各种不同的场景和数据集。 - 相对较快：相对于其他一些算法，Faster R-CNN的速度较快。 Faster R-CNN的缺点包括： - 训练和推理速度较慢：由于需要在RPN网络中生成候选框，因此在训练和推理时均需要对整张图片进行处理，速度较慢。 - 对小目标检测效果不佳：由于RPN网络生成的候选框较大，因此对于小目标的检测效果不佳。 SSD的优点包括： - 训练和推理速度较快：SSD直接在特征图上生成候选框，因此在训练和推理时只需要对特征图进行处理，速度较快。 - 对小目标检测效果较好：SSD在多个不同尺度的特征图上进行检测，可以较好地检测小目标。 - 训练过程简单：相对于Faster R-CNN，SSD的训练过程更加简单。 SSD的缺点包括： - 检测精度相对较低：相比于Faster R-CNN，在精度上存在一定的劣势。 - 对不同尺度目标的检测效果不一致：由于SSD在不同尺度的特征图上进行检测，因此对于不同尺度的目标的检测效果可能不一致。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值