精华内容
下载资源
问答
  • yolov3网络结构
    2021-02-03 22:05:46

    YOLOv3使用的是全连接层,论文中的结构图:
    在这里插入图片描述

    在这里插入图片描述
    每层输出情况:

    layer     filters    size              input                output
       0 conv     32  3 x 3 / 1   416 x 416 x   3   ->   416 x 416 x  32 0.299 BF
       1 conv     64  3 x 3 / 2   416 x 416 x  32   ->   208 x 208 x  64 1.595 BF
       2 conv     32  1 x 1 / 1   208 x 208 x  64   ->   208 x 208 x  32 0.177 BF
       3 conv     64  3 x 3 / 1   208 x 208 x  32   ->   208 x 208 x  64 1.595 BF
       4 Shortcut Layer: 1
       5 conv    128  3 x 3 / 2   208 x 208 x  64   ->   104 x 104 x 128 1.595 BF
       6 conv     64  1 x 1 / 1   104 x 104 x 128   ->   104 x 104 x  64 0.177 BF
       7 conv    128  3 x 3 / 1   104 x 104 x  64   ->   104 x 104 x 128 1.595 BF
       8 Shortcut Layer: 5
       9 conv     64  1 x 1 / 1   104 x 104 x 128   ->   104 x 104 x  64 0.177 BF
      10 conv    128  3 x 3 / 1   104 x 104 x  64   ->   104 x 104 x 128 1.595 BF
      11 Shortcut Layer: 8
      12 conv    256  3 x 3 / 2   104 x 104 x 128   ->    52 x  52 x 256 1.595 BF
      13 conv    128  1 x 1 / 1    52 x  52 x 256   ->    52 x  52 x 128 0.177 BF
      14 conv    256  3 x 3 / 1    52 x  52 x 128   ->    52 x  52 x 256 1.595 BF
      15 Shortcut Layer: 12
      16 conv    128  1 x 1 / 1    52 x  52 x 256   ->    52 x  52 x 128 0.177 BF
      17 conv    256  3 x 3 / 1    52 x  52 x 128   ->    52 x  52 x 256 1.595 BF
      18 Shortcut Layer: 15
      19 conv    128  1 x 1 / 1    52 x  52 x 256   ->    52 x  52 x 128 0.177 BF
      20 conv    256  3 x 3 / 1    52 x  52 x 128   ->    52 x  52 x 256 1.595 BF
      21 Shortcut Layer: 18
      22 conv    128  1 x 1 / 1    52 x  52 x 256   ->    52 x  52 x 128 0.177 BF
      23 conv    256  3 x 3 / 1    52 x  52 x 128   ->    52 x  52 x 256 1.595 BF
      24 Shortcut Layer: 21
      25 conv    128  1 x 1 / 1    52 x  52 x 256   ->    52 x  52 x 128 0.177 BF
      26 conv    256  3 x 3 / 1    52 x  52 x 128   ->    52 x  52 x 256 1.595 BF
      27 Shortcut Layer: 24
      28 conv    128  1 x 1 / 1    52 x  52 x 256   ->    52 x  52 x 128 0.177 BF
      29 conv    256  3 x 3 / 1    52 x  52 x 128   ->    52 x  52 x 256 1.595 BF
      30 Shortcut Layer: 27
      31 conv    128  1 x 1 / 1    52 x  52 x 256   ->    52 x  52 x 128 0.177 BF
      32 conv    256  3 x 3 / 1    52 x  52 x 128   ->    52 x  52 x 256 1.595 BF
      33 Shortcut Layer: 30
      34 conv    128  1 x 1 / 1    52 x  52 x 256   ->    52 x  52 x 128 0.177 BF
      35 conv    256  3 x 3 / 1    52 x  52 x 128   ->    52 x  52 x 256 1.595 BF
      36 Shortcut Layer: 33
      37 conv    512  3 x 3 / 2    52 x  52 x 256   ->    26 x  26 x 512 1.595 BF
      38 conv    256  1 x 1 / 1    26 x  26 x 512   ->    26 x  26 x 256 0.177 BF
      39 conv    512  3 x 3 / 1    26 x  26 x 256   ->    26 x  26 x 512 1.595 BF
      40 Shortcut Layer: 37
      41 conv    256  1 x 1 / 1    26 x  26 x 512   ->    26 x  26 x 256 0.177 BF
      42 conv    512  3 x 3 / 1    26 x  26 x 256   ->    26 x  26 x 512 1.595 BF
      43 Shortcut Layer: 40
      44 conv    256  1 x 1 / 1    26 x  26 x 512   ->    26 x  26 x 256 0.177 BF
      45 conv    512  3 x 3 / 1    26 x  26 x 256   ->    26 x  26 x 512 1.595 BF
      46 Shortcut Layer: 43
      47 conv    256  1 x 1 / 1    26 x  26 x 512   ->    26 x  26 x 256 0.177 BF
      48 conv    512  3 x 3 / 1    26 x  26 x 256   ->    26 x  26 x 512 1.595 BF
      49 Shortcut Layer: 46
      50 conv    256  1 x 1 / 1    26 x  26 x 512   ->    26 x  26 x 256 0.177 BF
      51 conv    512  3 x 3 / 1    26 x  26 x 256   ->    26 x  26 x 512 1.595 BF
      52 Shortcut Layer: 49
      53 conv    256  1 x 1 / 1    26 x  26 x 512   ->    26 x  26 x 256 0.177 BF
      54 conv    512  3 x 3 / 1    26 x  26 x 256   ->    26 x  26 x 512 1.595 BF
      55 Shortcut Layer: 52
      56 conv    256  1 x 1 / 1    26 x  26 x 512   ->    26 x  26 x 256 0.177 BF
      57 conv    512  3 x 3 / 1    26 x  26 x 256   ->    26 x  26 x 512 1.595 BF
      58 Shortcut Layer: 55
      59 conv    256  1 x 1 / 1    26 x  26 x 512   ->    26 x  26 x 256 0.177 BF
      60 conv    512  3 x 3 / 1    26 x  26 x 256   ->    26 x  26 x 512 1.595 BF
      61 Shortcut Layer: 58
      62 conv   1024  3 x 3 / 2    26 x  26 x 512   ->    13 x  13 x1024 1.595 BF
      63 conv    512  1 x 1 / 1    13 x  13 x1024   ->    13 x  13 x 512 0.177 BF
      64 conv   1024  3 x 3 / 1    13 x  13 x 512   ->    13 x  13 x1024 1.595 BF
      65 Shortcut Layer: 62
      66 conv    512  1 x 1 / 1    13 x  13 x1024   ->    13 x  13 x 512 0.177 BF
      67 conv   1024  3 x 3 / 1    13 x  13 x 512   ->    13 x  13 x1024 1.595 BF
      68 Shortcut Layer: 65
      69 conv    512  1 x 1 / 1    13 x  13 x1024   ->    13 x  13 x 512 0.177 BF
      70 conv   1024  3 x 3 / 1    13 x  13 x 512   ->    13 x  13 x1024 1.595 BF
      71 Shortcut Layer: 68
      72 conv    512  1 x 1 / 1    13 x  13 x1024   ->    13 x  13 x 512 0.177 BF
      73 conv   1024  3 x 3 / 1    13 x  13 x 512   ->    13 x  13 x1024 1.595 BF
      74 Shortcut Layer: 71
      75 conv    512  1 x 1 / 1    13 x  13 x1024   ->    13 x  13 x 512 0.177 BF
      76 conv   1024  3 x 3 / 1    13 x  13 x 512   ->    13 x  13 x1024 1.595 BF
      77 conv    512  1 x 1 / 1    13 x  13 x1024   ->    13 x  13 x 512 0.177 BF
      78 conv   1024  3 x 3 / 1    13 x  13 x 512   ->    13 x  13 x1024 1.595 BF
      79 conv    512  1 x 1 / 1    13 x  13 x1024   ->    13 x  13 x 512 0.177 BF
      80 conv   1024  3 x 3 / 1    13 x  13 x 512   ->    13 x  13 x1024 1.595 BF
      81 conv     18  1 x 1 / 1    13 x  13 x1024   ->    13 x  13 x  18 0.006 BF
      82 yolo
      83 route  79
      84 conv    256  1 x 1 / 1    13 x  13 x 512   ->    13 x  13 x 256 0.044 BF
      85 upsample            2x    13 x  13 x 256   ->    26 x  26 x 256
      86 route  85 61
      87 conv    256  1 x 1 / 1    26 x  26 x 768   ->    26 x  26 x 256 0.266 BF
      88 conv    512  3 x 3 / 1    26 x  26 x 256   ->    26 x  26 x 512 1.595 BF
      89 conv    256  1 x 1 / 1    26 x  26 x 512   ->    26 x  26 x 256 0.177 BF
      90 conv    512  3 x 3 / 1    26 x  26 x 256   ->    26 x  26 x 512 1.595 BF
      91 conv    256  1 x 1 / 1    26 x  26 x 512   ->    26 x  26 x 256 0.177 BF
      92 conv    512  3 x 3 / 1    26 x  26 x 256   ->    26 x  26 x 512 1.595 BF
      93 conv     18  1 x 1 / 1    26 x  26 x 512   ->    26 x  26 x  18 0.012 BF
      94 yolo
      95 route  91
      96 conv    128  1 x 1 / 1    26 x  26 x 256   ->    26 x  26 x 128 0.044 BF
      97 upsample            2x    26 x  26 x 128   ->    52 x  52 x 128
      98 route  97 36
      99 conv    128  1 x 1 / 1    52 x  52 x 384   ->    52 x  52 x 128 0.266 BF
     100 conv    256  3 x 3 / 1    52 x  52 x 128   ->    52 x  52 x 256 1.595 BF
     101 conv    128  1 x 1 / 1    52 x  52 x 256   ->    52 x  52 x 128 0.177 BF
     102 conv    256  3 x 3 / 1    52 x  52 x 128   ->    52 x  52 x 256 1.595 BF
     103 conv    128  1 x 1 / 1    52 x  52 x 256   ->    52 x  52 x 128 0.177 BF
     104 conv    256  3 x 3 / 1    52 x  52 x 128   ->    52 x  52 x 256 1.595 BF
     105 conv     18  1 x 1 / 1    52 x  52 x 256   ->    52 x  52 x  18 0.025 BF
     106 yolo
    
    
    更多相关内容
  • 文章目录1 总体介绍2 YOLOv3主干网络3 FPN特征融合4 利用Yolo Head获得预测结果5 不同尺度的先验框anchor box5.1 理论介绍5.2 代码读取6 YOLOv3整体网络结构代码理解7 感谢链接 1 总体介绍 YOLOv3网络主要包括两部分...

    1 总体介绍

    YOLOv3网络主要包括两部分,一个是主干网络(backbone)部分,一个是使用特征金字塔(FPN)融合、加强特征提取并利用卷积进行预测部分。

    yolov3网络总体框图如下:
    yolov3网络结构框图

    2 YOLOv3主干网络

    以采用darknet53网络为例,详解见YOLOv3 backbone Darknet-53 详解

    3 FPN特征融合

    YOLOv3提取多特征层进行目标检测,一共提取三个特征层。

    三个特征层位于主干部分Darknet53的不同位置,分别位于中间层,中下层,底层,三个特征层的shape分别为(52,52,256)、(26,26,512)、(13,13,1024)。

    在获得三个有效特征层后,利用这三个有效特征层进行FPN层的构建。

    3.1 构建方式解读1

    • 13x13x1024的特征层进行5次卷积处理,处理完后的结果分两路走,一路利用**YoloHead(检测头)获得预测结果,一路用于进行卷积(降低通道数)+上采样UmSampling2d(c通道数不变,w,h尺寸变为原来2倍)**后与26x26x512特征层进行concat拼接,拼接后特征层的shape为(26,26,768)。
    • 拼接后的特征层再次进行5次卷积处理,处理完后的结果 分两路 走,一路利用 YoloHead 获得预测结果,一路用于进行 卷积(降低通道数)+上采样UmSampling2d(c通道数不变,w,h尺寸变为原来2倍) 后与52x52x256特征层进行concat拼接,拼接后特征层的shape为(52,52,384)。
    • 拼接后的特征层再次进行5次卷积处理,处理完后利用YoloHead获得预测结果。

    3.2 构建方式解读2

    • backbone最后一层经过5次卷积得到一层特征图,从这儿分成两路,一路去做预测,一路上采样和上一个Block进行concat拼接,类推形成特征金字塔(FPN,Feature Pyramid Networks,用于解决目标检测中的多尺度变化问题)
    • 预测那一路包括分类预测和回归预测,使用的是3x3的卷积和1x1的卷积,最后得到的特征图尺寸为13x13,75的由来,每个像素点(网格思想)上有3个先验框,每个先验框属于每一类的概率(voc有20类)、是否有物体(1个参数)、对应的调整参数(4个参数,中心点x,y坐标,框宽w和高h),因此最后的13,13,75的理解为:13,13,75 ->13,13,3x25 -> 13,13,3x[20(属于某一类的概率,voc有20类)+1(是否有物体)+4(调整参数)]
    • 上采样那一路,和上一层的输出特征图融合后,做5次卷积得到一层特征图,然后分成两路,一路去做预测,一路去。。。

    ps:先验框是预设的( 9种尺度的先验框 ),经过网络训练,参数调整后才能变成 预测框

    特征金字塔可以将不同shape的特征层进行特征融合,有利于提取出更好的特征。

    4 利用Yolo Head获得预测结果

    利用FPN特征金字塔,可以获得三个加强特征,这三个加强特征的shape分别为(13,13,512)、(26,26,256)、(52,52,128),然后利用这三个shape的特征层传入Yolo Head获得预测结果。

    Yolo Head本质上是一次3x3卷积加上一次1x1卷积,3x3卷积的作用是特征整合,1x1卷积的作用是调整通道数。

    对所获得的三个加强特征层分别进行处理,假设预测是的VOC数据集,则输出层的shape分别为(13,13,75),(26,26,75),(52,52,75),最后一个维度为75是因为该例子是基于voc数据集的,它的类别数为20种,YoloV3针对每一个特征层的每一个特征点存在3个先验框,所以预测结果的通道数为3x25(20个类别,每个类别都有一个概率 + 4调整参数 + 1是否有物体);

    如果使用的是coco训练集,类别数则为80种,最后的维度应该为255 = 3x85,三个特征层的shape为(13,13,255),(26,26,255),(52,52,255)。小总结: 输入N张416x416的图片,在经过多层的运算后,会输出三个shape分别为(N,13,13,255),(N,26,26,255),(N,52,52,255)的数据,分别对应每个图为13x13、26x26、52x52的网格上3个先验框的位置预测情况。

    5 不同尺度的先验框anchor box

    5.1 理论介绍

    定义: anchor box是从训练集的所有ground truth box中统计(使用k-means)出来的在训练集中最经常出现的几个box形状和尺寸。

    9种尺度先验框: 随着输出的特征图的数量和尺度的变化,先验框的尺寸也需要相应的调整。YOLOv2已经开始采用K-means聚类得到先验框的尺寸,YOLOv3延续了这种方法,为每种下采样尺度设定3种先验框,总共聚类出9种尺寸的先验框。在COCO数据集这9个先验框(voc用这个也ok,一般不改)是:(10x13),(16x30),(33x23),(30x61),(62x45),(59x119),(116x90),(156x198),(373x326)。

    如何分配: 在最小的13x13特征图上(有最大的感受野)应用较大的先验框(116x90),(156x198),(373x326),适合检测较大的对象。中等的26x26特征图上(中等感受野)应用中等的先验框(30x61),(62x45),(59x119),适合检测中等大小的对象。较大的52x52特征图上(较小的感受野)应用较小的先验框(10x13),(16x30),(33x23),适合检测较小的对象。
    特征图-感受野-先验框

    5.2 代码读取

    yolo_anchors.txt中存有下列数据

    10,13,  16,30,  33,23,  30,61,  62,45,  59,119,  116,90,  156,198,  373,326
    
    import numpy as np
    #---------------------------------------------------#
    #   获得先验框
    #---------------------------------------------------#
    def get_anchors(anchors_path):
        '''loads the anchors from a file'''
        with open(anchors_path, encoding='utf-8') as f:
            anchors = f.readline()
        anchors = [float(x) for x in anchors.split(',')]
        anchors = np.array(anchors).reshape(-1, 2)
        return anchors, len(anchors)
    
    anchors_path    = 'model_data/yolo_anchors.txt'
    # anchors: ndarray:(9,2)        num_anchors:int  9   
    anchors, num_anchors     = get_anchors(anchors_path)
    print(anchors)
    
    [[ 10.  13.]
     [ 16.  30.]
     [ 33.  23.]
     [ 30.  61.]
     [ 62.  45.]
     [ 59. 119.]
     [116.  90.]
     [156. 198.]
     [373. 326.]]
    

    6 YOLOv3整体网络结构代码理解

    结合backbone------darknet53的代码,可直接运行下列代码

    from collections import OrderedDict
    import torch
    import torch.nn as nn
    # darknet53的分析可见https://blog.csdn.net/weixin_45377629/article/details/124078580?spm=1001.2014.3001.5501
    from nets.darknet import darknet53      
    
    
    def conv2d(filter_in, filter_out, kernel_size):
        pad = (kernel_size - 1) // 2 if kernel_size else 0
        return nn.Sequential(OrderedDict([
            ("conv", nn.Conv2d(filter_in, filter_out, kernel_size=kernel_size, stride=1, padding=pad, bias=False)),
            ("bn", nn.BatchNorm2d(filter_out)),
            ("relu", nn.LeakyReLU(0.1)),
        ]))
    
    #------------------------------------------------------------------------#
    #   make_last_layers里面一共有七个卷积,前五个用于提取特征。
    #   后两个用于获得yolo网络的预测结果,称之为yolo head
    #------------------------------------------------------------------------#
    def make_last_layers(filters_list, in_filters, out_filter):
        m = nn.Sequential(
            conv2d(in_filters, filters_list[0], 1),         # 1表示kernel_size
            conv2d(filters_list[0], filters_list[1], 3),
            conv2d(filters_list[1], filters_list[0], 1),
            conv2d(filters_list[0], filters_list[1], 3),
            conv2d(filters_list[1], filters_list[0], 1),
            conv2d(filters_list[0], filters_list[1], 3),
            nn.Conv2d(filters_list[1], out_filter, kernel_size=1, stride=1, padding=0, bias=True)
        )
        return m
    
    # ---------------------------------------------------#
    #   获得类,`voc_classes.txt`中包含voc数据集中所有类别名称
    # ---------------------------------------------------#
    def get_classes(classes_path):
        with open(classes_path, encoding='utf-8') as f:
            class_names = f.readlines()
        class_names = [c.strip() for c in class_names]
        return class_names, len(class_names)
    
    class YoloBody(nn.Module):
        def __init__(self, anchors_mask, num_classes):
            super(YoloBody, self).__init__()
            #---------------------------------------------------#   
            #   生成darknet53的主干模型
            #   获得三个有效特征层,他们的shape分别是:
            #   52,52,256
            #   26,26,512
            #   13,13,1024
            #---------------------------------------------------#
            self.backbone = darknet53()
    
            #---------------------------------------------------#
            #   out_filters : [64, 128, 256, 512, 1024],利用最后三个进行FPN融合
            #---------------------------------------------------#
            out_filters = self.backbone.layers_out_filters      # 表示Darknet53网络几个结构块的输出通道数,make_last_layers中用到此处
    
            #------------------------------------------------------------------------#
            #   计算yolo_head的输出通道数,对于voc数据集而言
            #   final_out_filter0 = final_out_filter1 = final_out_filter2 = 75
            #   final_out_filter0 = len(anchors_mask[0]) * (num_classes + 5) = 3*(20+5)
            #   3*(20+5)含义:
            #       3表示网格点上先验框个数,
            #       20表示voc分类类别数,coco是80类,5:
            #       4个先验框框调整参数+1表示网格内是否有物体
            #   anchors_mask:表示先验框尺寸变化,通常有9种,一般不改,具体详见正文分析
            #------------------------------------------------------------------------#
            self.last_layer0            = make_last_layers([512, 1024], out_filters[-1], len(anchors_mask[0]) * (num_classes + 5))
    
            self.last_layer1_conv       = conv2d(512, 256, 1)   # 2D卷积,降低通道数
            self.last_layer1_upsample   = nn.Upsample(scale_factor=2, mode='nearest')   # 上采样:c通道数不变,w,h尺寸变为原来2倍
            self.last_layer1            = make_last_layers([256, 512], out_filters[-2] + 256, len(anchors_mask[1]) * (num_classes + 5))
    
            self.last_layer2_conv       = conv2d(256, 128, 1)
            self.last_layer2_upsample   = nn.Upsample(scale_factor=2, mode='nearest')
            self.last_layer2            = make_last_layers([128, 256], out_filters[-3] + 128, len(anchors_mask[2]) * (num_classes + 5))
    
        def forward(self, x):
            #---------------------------------------------------#   
            #   获得三个有效特征层,他们的shape分别是:
            #   52,52,256;26,26,512;13,13,1024
            #---------------------------------------------------#
            x2, x1, x0 = self.backbone(x)       # backbone return out3, out4, out5
    
            #---------------------------------------------------#
            #   第一个特征层
            #   out0 = (batch_size,255,13,13)
            #---------------------------------------------------#
            # 13,13,1024 -> 13,13,512 -> 13,13,1024 -> 13,13,512 -> 13,13,1024 -> 13,13,512
            # yolo head中有七层卷积(nn.Sequential整合的),前5层提取特征,同时其输出要进行 卷积+上采样 去和上一个layer输出融合形成FPN。
            # 故这个地方[:5]和[5:]
            out0_branch = self.last_layer0[:5](x0)
            out0        = self.last_layer0[5:](out0_branch)     # torch.size([1,75,13,13])
    
            # 13,13,512 -> 13,13,256 -> 26,26,256
            x1_in = self.last_layer1_conv(out0_branch)      # {Tensor:1}
            x1_in = self.last_layer1_upsample(x1_in)        # {Tensor:1}
    
            # 26,26,256 + 26,26,512 -> 26,26,768
            x1_in = torch.cat([x1_in, x1], 1)       # 所谓融合也就是特征图拼接,层数变多   # 后一个参数1的作用  {Tensor:1}  torch.size([1,768,26,26])
            #---------------------------------------------------#
            #   第二个特征层
            #   out1 = (batch_size,255,26,26)
            #---------------------------------------------------#
            # 26,26,768 -> 26,26,256 -> 26,26,512 -> 26,26,256 -> 26,26,512 -> 26,26,256
            out1_branch = self.last_layer1[:5](x1_in)
            out1        = self.last_layer1[5:](out1_branch)     # torch.size([1,75,26,26])
    
            # 26,26,256 -> 26,26,128 -> 52,52,128
            x2_in = self.last_layer2_conv(out1_branch)
            x2_in = self.last_layer2_upsample(x2_in)
    
            # 52,52,128 + 52,52,256 -> 52,52,384
            x2_in = torch.cat([x2_in, x2], 1)           # torch.size([1,384,52,52])
            #---------------------------------------------------#
            #   第一个特征层
            #   out3 = (batch_size,255,52,52)
            #---------------------------------------------------#
            # 52,52,384 -> 52,52,128 -> 52,52,256 -> 52,52,128 -> 52,52,256 -> 52,52,128
            out2 = self.last_layer2(x2_in)      # torch.size([1,75,52,52])
            return out0, out1, out2
    
    if __name__ == '__main__':
        # ------------------------------------------------#
        # 	voc_classes.txt内容见下方
        # ------------------------------------------------#
        classes_path = './model_data/voc_classes.txt'
        class_names, num_classes = get_classes(classes_path)
        anchors_mask = [[6, 7, 8], [3, 4, 5], [0, 1, 2]]  # 10,13,  16,30,  33,23,  30,61,  62,45,  59,119,  116,90,  156,198,  373,326
        model = YoloBody(anchors_mask, num_classes)
        print(model)      # 包括网络结构和参数
    
        from thop import profile            # 用来测试网络能够跑通,同时可查看FLOPs和params
        input = torch.randn(1, 3, 416, 416)     # 1张3通道尺寸为416x416的图片作为输入
        flops, params = profile(model, (input,))
        print(flops, params)
    

    voc_classes.txt内容如下:

    aeroplane
    bicycle
    bird
    boat
    bottle
    bus
    car
    cat
    chair
    cow
    diningtable
    dog
    horse
    motorbike
    person
    pottedplant
    sheep
    sofa
    train
    tvmonitor
    

    7 感谢链接

    https://blog.csdn.net/weixin_44791964/article/details/105310627
    
    展开全文
  • yolov3网络结构

    2021-09-08 20:09:13
    参考:YOLOv3网络结构和解析 【论文笔记】YOLOv3 网络结构图 特征提取主干:Darknet-53 YOLO主体是由许多这种残差模块组成,减小了梯度爆炸的风险,加强了网络的学习能力。 输出大小和尺度 YOLO有3个尺度的输出 ...

    参考:YOLOv3网络结构和解析
    【论文笔记】YOLOv3
    【论文理解】yolov3损失函数
    yolov3损失函数具体是什么?

    目标检测——目标检测方法的综述
    计算机视觉四大基本任务(分类、定位、检测、分割)

    网络结构图

    特征提取主干:Darknet-53
    在这里插入图片描述
    深入浅出Yolo系列之Yolov3&Yolov4&Yolov5&Yolox核心基础知识完整讲解
    在这里插入图片描述

    在这里插入图片描述
    YOLO主体是由许多这种残差模块组成,减小了梯度爆炸的风险,加强了网络的学习能力。

    yolov3网络结构补充
    参考: yolo系列理论合集
    在这里插入图片描述

    输出大小和尺度

    参考:【论文理解】理解yolov3的anchor、置信度和类别概率添加链接描述

    YOLO有3个尺度的输出

    分别在52×52,26×26,13×13。嗯,都是奇数,使得网格会有个中心位置。同时YOLO输出为3个尺度,每个尺度之间还有联系。比如说,13×13这个尺度输出用于检测大型目标,对应的26×26为中型的,52×52用于检测小型目标

    S×S×3×(5+class_number)

    所以其输出需要构造为

    Anchor BOx

    Anchor box其实就是从训练集中将所有的矩形框的大小尺寸统计处最常出现的某几个矩形框,这里我们可以采用K-Means来得到。这样也就不难理解使用anchor的目的了:目标先验。即我们提前告诉模型,应该去用多大的矩形框去寻找目标,帮助模型快速收敛。

    作者:烟花如雨旧故里
    链接:https://www.jianshu.com/p/f2c5afe26750
    来源:简书
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

    损失函数

    【论文笔记】YOLOv3

    在这里插入图片描述
    分类使用二值交叉熵损失
    每个框预测分类,bounding box使用多标签分类(multi-label classification)。论文中说没有使用softmax分类,只是使用了简单的逻辑回归进行分类,采用的二值交叉熵损失(binary cross-entropy loss)。

    预测对象类别时不使用softmax,改成使用logistic的输出进行预测。这添加链接描述添加链接描述样能够支持多标签对象(比如一个人有Woman 和 Person两个标签)。
    训练期间,使用平方误差损失的和
    在训练期间,我们使用平方误差损失的和。如果一些坐标预测的ground truth是t* ,梯度就是ground truth值(从ground truth box计算出来)减去预测,即:t*-t 。 通过翻转上面的方程可以很容易地计算出这个ground truth值。

    2021.10

    yolov3——yaml格式网络实现
    下载好代码以后看yolov3-master\models文件下的yolo.py和common.py

    标准卷积 Conv + BN + activate

    图片链接
    在这里插入图片描述

    Bottleneck瓶颈层

    参数:
    图片链接
    在这里插入图片描述
    在这里插入图片描述

    实际网络结构:
    在这里插入图片描述
    说明:
    输入:-1 上一层
    数量:一个
    输出:64通道
    默认shortcut为ture,是残差结构

    在这里插入图片描述

    在这里插入图片描述
    参数说明:输出512层通道
    shortcut为false,无残差结构,只有一个11和33卷积
    在这里插入图片描述

    展开全文
  • 为了方便理解,放了来自木盏的yoloV3网络结构图 DBL: 即代码中的Darknetconv2d_BN_Leaky,是yolo_v3的基本组件。就是卷积+BN+Leaky relu。 resn:n代表数字,有res1,res2, … ,res8等等,表示这个res_block里...
  • yolov3网络结构

    2021-07-09 16:07:48
    yolov3.cfg上传Netron 就可以查看网络结构。 下面把我自己的yolov3.cfg把类别从80改为3的文件上传该网址生成的网络结构图贴在下面参考学习。 因为图片很长只能截成一段一段的查看。 ...

    把yolov3.cfg上传Netron 就可以查看网络结构。

    下面把我自己的yolov3.cfg把类别从80改为3的文件上传该网址生成的网络结构图贴在下面参考学习。
    因为图片很长只能截成一段一段的查看。

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 本文将详细介绍Yolov3网络结构相关内容。
  • YOLOv3网络结构的理解

    千次阅读 多人点赞 2020-08-07 13:55:32
    YOLOv3网络结构的理解 第一次写博客,参考一些资料总结了一些有关YOLOv3目标检测网络理解方面的内容。如有不当之处欢迎大家批评指正! 一、模块说明 模块名称 模块含义 模块作用 ...
  • YOLOv3网络结构和解析

    万次阅读 多人点赞 2019-05-09 23:03:07
    YOLOv3网络结构细致解析 基于keras-yolov3,原理及代码细节的理解 论文地址:https://pjreddie.com/media/files/papers/YOLOv3.pdf yolov3官网:https://pjreddie.com/darknet/yolo/ Keras版本推荐:...
  • YOLOv3 网络结构

    千次阅读 2019-07-31 11:17:57
    YOLOv3一共107层,其中,0到74层为卷积层和res层;75-105为yolo层,具备检测功能,分类和回归。采用逻辑回归预测box 1.每一个小的卷积层内容: conv2d+BatchNorm2d+LeakyRELU 这样的卷积结构先是有4个, 2....
  • 原文链接:https://blog.csdn.net/dz4543/article/details/90049377 学了这么久的YOLOv3,把自己的学习心得记
  • yolov3-tiny检测网络

    2018-11-09 16:16:01
    基于tensorflow实现yolov3-tiny的检测网络,直接加载官方提供的权重文件给模型中的参数赋值,而不是网上说的什么.h5或者是pb模型。 tensorflow版本:1.11 python版本:3.5 文件中包含权重文件,若想要使用纯...
  • YOLOV3 网络结构学习笔记

    万次阅读 多人点赞 2019-10-23 22:02:39
    yolo系列之yolo v3【深度解析】_木盏的博客-CSDN博客_yolo3 YOLO v3算法详解_‘Atlas’的博客-CSDN博客_yolov3算法详解 YOLO v3网络结构分析_太阳花的小绿豆的博客-CSDN博客_yolov3模型 目标检测3: yolov3结构原理...
  • YOLOv3网络结构分析以及工作流程

    千次阅读 2020-02-10 00:32:31
    注意:本文章有很多图,但是都是YOLOv3结构图,只是每张图表达出的信息都各有特色,可将这些结构图结合起来,能更好的理解。 1.Darknet-53 模型结构 在论文中虽然有给网络的图,但我还是简单说一下。这个网络主要...
  • 深度学习-yolov3网络结构

    千次阅读 2018-07-12 21:31:44
    可结合第一张与第二张理解网络结构layer filters size input output 0 conv 32 3 x 3 / 1 416 x 416 x 3 -> 416 x 416 x 32 1 conv 64 3 x 3 / 2 416 x 416 x ...
  • 可视化的V3网络结构为 [net] # Testing 测试模式 # batch=1 # subdivisions=1 # Training 训练模式 batch=64 一批训练样本的样本数量,每bat...
  • YOLOV5网络结构

    万次阅读 多人点赞 2020-07-22 14:08:57
    YOLOV5网络结构 github代码地址:ultralytics\yolov5,v5还在开发当中,目前的网络结构如下图,要是网络结构有更新,笔者也会更新结构图。 下图括号中四个数字代表:(输入通道、输出通道、卷积核大小、步长); 两个...
  • YOLOv5网络结构图-visio源文件,可直接编辑修改
  • Yolov3网络架构分析

    2021-08-04 12:04:27
     CBL:Yolov3网络结构中的最小组件,由Conv+Bn+Leaky_relu激活函数三者组成。  Res unit:借鉴Resnet网络中的残差结构,让网络可以构建的更深。  ResX:由一个CBL和X个残差组件构成,是Yolov3中的大组件。每个...
  • yolov3yolov4、yolov5s的网络结构对比
  • Yolov5 网络结构

    千次阅读 2022-03-17 03:46:16
    yolov5 的网络结构 yolov5 的网络结构的配置文件在models文件夹下,有yolov5n.yaml, yolov5s.yaml, yolov5m.yaml等等。几个网络结构其实都一样,通过depth_multiple和width_multiple参数来控制网络结构的深度和宽度...
  • YOLOv3YOLOv4、YOLOv5、YOLOx的网络结构图(清晰版)

    万次阅读 多人点赞 2021-09-13 15:54:41
    1. Yolov3网络结构图 2. Yolov4网络结构3. Yolov5网络结构图 4. Yolox网络结构
  • yolov4.zip,Yolov4.pdf,CSPDarkNet53.pdf
  • Yolov5s网络结构

    千次阅读 2022-04-25 22:39:07
    model( ... (conv): Conv2d(12, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) (bn): BatchNorm2d(32, eps=0.001, momentum=0.03, affine=True, track_running_stats=True)
  • 初析yolov3 tiny 网络模型结构

    万次阅读 2019-09-26 17:16:54
    想上网了解下yolov3 tiny的网络结构,竟然没看到一篇文章详细讲解它的( 可能有,没看到而已。。。)。 Yolo3 tiny网络结构 想知道yolo3 tiny网络模型层次架构,其实很简单。使用下面的命令就可以把它打印出来。 ...
  • yolov3-tiny 网络结构

    千次阅读 2020-11-07 11:18:48
    写一个脚本,test_yolov3-tiny.bat,内容如下: darknet detector test cfg/coco.data cfg/yolov3-tiny.cfg cfg/yolov3-tiny.weights data/dog.jpg -thresh 0.6 pause 双击执行,输出: darknet detector test...
  • YOLOv3 最完整网络结构

    千次阅读 多人点赞 2020-04-12 20:02:51
    1.其中方框前面的红色序号是网络层的层数(从0开始排序),方便辨别route层的连接位置。 2.方框内前面的序号是卷积层的层数,方便查看Darknet-53大概到什么位置,以及包含的75层卷积位置。 3.所有层后面都有做好...
  • YOLOv5网络结构学习

    万次阅读 多人点赞 2021-05-07 16:29:20
    最近在学习yolov5的代码(因为项目需要),其实陆陆续续接触...我们就先从yolov5的网络结构开始讲起吧~ 一、Focus层 Focus层的代码如下: class Focus(nn.Module): # Focus wh information into c-space def __ini

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,892
精华内容 3,956
关键字:

yolov3网络结构

友情链接: TestXML.rar