精华内容
下载资源
问答
  • SSD目标检测算法论文-英文原版,SSD: Single Shot MultiBox Detector
  • SSD目标检测算法

    2017-01-17 22:07:42
    在征得的算法中,由IBM公司提出的算法lucifer中选。1975年3月,NBS向社会公布了此算法,以求得公众的评论。于1976年11月被美国政府采用,DES随后被美国国家标准局和美国国家标准协会(American National Sta

    SSD特点

    • 从YOLO中继承了将detection转化为regression的思路,一次完成目标定位与分类
    • 基于Faster RCNN中的Anchor,提出了相似的Prior box
    • 加入基于特征金字塔(Pyramidal FeatureHierarchy)的检测方式,即在不同感受野的feature map上预测目标。

    SSD结构简述

    在这里插入图片描述

    主网络结构是VGG16,将最后两个全连接层改成卷积层,并随后增加了4个卷积层来构造网络结构。对其中5种不同的卷积层的输出(feature map)分别用两个不同的 3×3的卷积核进行卷积,一个输出分类用的confidence,每个default box 生成21个类别confidence;一个输出回归用的 localization,每个 default box生成4个坐标值(x, y, w, h)。

    Multi-scale feature maps for detection(多尺度特征映射)

    在这里插入图片描述
    SSD(右图)在base network之后加入多个卷积层,获得不同尺度的feature map, 这些层的大小逐渐减小,可以进行多尺度预测。

    Convolutional predictors for detection

    对于一个大小为mn、p通道的特征层,使用33的卷积核进行预测,在某个位置上预测出一个值,该值可以是某一类别的得分,也可以是相对于default bounding boxes的偏移量,并且在图像的每个位置都将产生一个值。

    Default boxes and aspect ratio

    SSD在不同的特征层的feature map上的每个feature map cell生成K个default boxes。
    在这里插入图片描述
    对于每个box,预测C个类别得分,以及相对于default bounding box的4个偏移值,这样需要(C+4)k个预测器,在mn的特征图上将产生(C+4)km*n个预测值。

    Choosing scales and aspect ratios for default boxes(default boxes 生成规则)

    以feature map上每个点的中点为中心(offset=0.5)生成一系列同心的Defult box(然后中心点的坐标会乘以step,相当于从feature map位置映射回原图位置)。

    对于每个feature map,default box的尺度计算如下:
    在这里插入图片描述
    其中,smin = 0.2,smax = 0.9
    default box的aspect ratios 有:{1, 2, 3,1/2,1/3},对于 aspect ratio = 1,额外增加一个default box,该box的尺度为在这里插入图片描述
    每一个default box,宽度、高度、中心点计算如下:
    在这里插入图片描述
    在这里插入图片描述
    可以看出这种default box在不同的feature层有不同的scale,在同一个feature层又有不同的aspect ratio,因此基本上可以覆盖输入图像中的各种形状和大小的object。

    Matching strategy

    在训练过程中,需要从不同位置,不同大小,不同长宽比的一系列Default boxes中选出与Ground truth 拥有最佳jaccard overlap的boxes,在SSD中,当jaccard overlap大于某一阈值(0.5),则认为该box与ground truth匹配成功, 作为训练的正样本,如果匹配失败,则作为负样本。
    Jaccard overlap
    在这里插入图片描述
    显然,负样本的数据要远远多于正样本,为了控制正负样本的数量满足一定比例(1:3),所以采用Hard negative mining对负样本进行选择。

    Hard negative mining

    先将每一个物体位置上对应 predictions(default boxes)是 negative 的 boxes 进行排序,按照 default boxes 的 confidence 的大小。 选择最高的几个,保证最后 negatives、positives 满足比例 。
    Trainning objective
    总的损失函数是localization loss (loc) 和 confidence loss (conf) 的加权和。
    在这里插入图片描述
    localization loss:
    在这里插入图片描述
    confidence loss:
    在这里插入图片描述

    展开全文
  • 为提升原始SSD算法的小目标检测精度及鲁棒性,提出一种基于通道注意力机制的SSD目标检测算法。在原始SSD算法的基础上对高层特征图进行全局池化操作,结合通道注意力机制增强高层特征图的语义信息,并利用膨胀卷积...
  • ❝上期一起学了SSD算法的框架流程,如下:目标检测算法SSD结构详解❞今天我们一起学下成功训练SSD算法的一些注意点:Loss计算Match策略数据增强性能分析Loss计算SSD算法的目标函数分两部分:计算相应的预选框与目标...

    上期一起学了SSD算法的框架流程,如下:
    目标检测算法SSD结构详解

    今天我们一起学下成功训练SSD算法的一些注意点:

    • Loss计算
    • Match策略
    • 数据增强
    • 性能分析

    Loss计算

    SSD算法的目标函数分两部分:计算相应的预选框与目标类别的confidence loss以及相应的位置回归。如下公式:

    其中NmatchGround Truth的预选框数量(具体的match策略下面讲),参数用于调整confidence losslocation loss之间的比例,默认. 其中confidence loss具体如下:

    其中i表示第i个预选框,j表示第j个真实框,p表示第p个类别。其中表示第i个预选框是否匹配到了第j个类别为p的真实框,匹配到就为1,否则为0
    而我们在最小化上面代价函数的时候,就是将逼近于1的过程。而对于location loss,如下:

    其实,位置回归的loss是跟前面学的Faster RCNN中位置回归损失是一样,不在赘述,如下:
    目标检测算法Faster RCNN的损失函数以及如何训练?

    其中,

    • g:ground truth box
    • l:predicted box
    • d:prior box
    • w:width
    • h:heigth

    Match策略

    在训练时,ground truth boxesprior boxes按照如下方式进行配对:首先,寻找与每一个ground truth box有最大交并比(IoU)的prior box,这样就能保证每一个真实标注框与至少会有一个预选框与之对应,之后又将剩余还没有配对到的预选框与任意一个真实标注框尝试配对,只要两者之间的IoU大于阈值,则认为match上了。显然在训练的时候,配对到真实标注框的预选框就是正样本,而没有配对上的则为负样本。如下图:c14eed924a74bd5d9fec6df827e6fd5e.png在进行match的时候,首先计算每个预选框和真实框的IoU,将IoU最大的预选框和大于阈值的预选框作为正样本,其余的作为负样本进行分类器训练。其中公式中的x表示预选框信息,c为置信度,l为预测框,g为真实标注。

    数据增强

    值得注意的是,一般情况下负样本预选框的数量是远远大于正样本预选框的数量,如果直接进行训练的话,会导致网络过于重视负样本,从而导致loss不稳定。所以SSD在抽样时按照置信度误差(预测背景的置信度越小,误差越大)进行降序排列,选取误差较大的top-k作为训练的负样本,控制正负样本比例为1:3,这样可以导致模型更快的优化和更稳定的训练。
    另外为了使模型对于各种输入对象大小和形状更加鲁棒,每个训练图像通过以下选项之一进行随机采样:

    • 使用整个原始输入图像
    • 采样一个区域,使得采样区域和原始图片最小的交并比重叠为0.10.30.50.70.9.
    • 随机采样一个区域

    每个采样区域的大小为原始图像大小的[0.1,1],长宽比在1/22之间。如果真实标签框中心在采样区域内,则保留两者重叠部分作为新图片的真实标注。在上述采样步骤之后,将每个采样区域大小调整为固定大小,并以0.5的概率水平翻转。如下图:2b93a054aa5ed6f45b32e639d09ded48.png上图左图为输入图片及真实标注,右侧的a,b,c,d为随机采样得到的4张图片及标注。

    性能分析

    SSD算法和我们前面学的Faster RCNN以及后面要学的YOLO的性能对比如下表:85c9c0e613381b463908523fd6936b45.png从上表中可以看到SSD算法相比Faster RCNNYOLO都有较高的mAPFPS也比Faster RCNN高。而由于SSD512输入图片比300大,所以SSD512相对于SSD300有更好的mAP

    SSD缺点

    • 需要人工设置预选框的min-size,max_sizeaspect_ratio值。网络中预选框的基础大小和形状需要手工设置。而网络中每一层feature使用的预选框大小和形状不一样,导致调试过程非常依赖经验。
    • 虽然采用了特征金字塔的思路,但是对小目标的识别效果依然一般,可能是因为SSD使用了VGG16中的conv4_3低级feature去检测小目标,而低级特征卷积层数少,存在特征提取不充分的问题。

    至此结果上期,我们基本上了解了SSD算法的大致原理,下期,我们一起看下另一个牛哄哄的检测算法YOLO,一起加油!a93521bf5df2b52663456868f7d23a00.png

    展开全文
  • 传统SSD算法的特征金字塔检测方法很难融合不同尺度的特征,并且由于底层的卷积神经网络层具有较弱的语义信息,也不利于小物体的识别,因此本论文提出了以SSD算法的网络结构为基础的一种新颖的目标检测算法RF_SSD,...
  • SSD目标检测算法出现在Faster-RCNN和YOLOv1算法之后,融合了二者的优点的one-stage算法。速度比faster-RCNN更快,比YOLOv1算法准确率更高。 如果你对YOLOv1算法不了解的话,可以先了解一下。 关于YOLOv1目标检测算法...

    算法介绍

    SSD目标检测算法出现在Faster-RCNN和YOLOv1算法之后,融合了二者的优点的one-stage算法。速度比faster-RCNN更快,比YOLOv1算法准确率更高。
    如果你对YOLOv1算法不了解的话,可以先了解一下。
    关于YOLOv1目标检测算法的理解

    英文名 SSD: Single Shot MultiBox Detector
    论文地址:https://arxiv.org/abs/1512.02325

    下面是该算法的具体表现:
    在这里插入图片描述
    可以看出SSD算法比Faster-RCNN的mAP还高出一点点,而且FPS高出三倍以上。而相比于YOLOv1,mAP有很大的提升。所以SSD算法不仅兼顾速度也兼顾准确率。但是遗憾的是还是无法满足实时性的要求,依然只能在高端硬件上面运行。

    算法分析

    我们先介绍一下网络结构,以下是YOLOv1和SSD算法的网络结构:
    在这里插入图片描述
    SSD算法前段网络采用的是改进后的VGG-16的网络结构,后端是用多个卷积层多尺度进行预测图片位置和种类,运用3x3xp的小卷积进行识别预测,大的特征图预测小的特征,小的特征图预测大的特征。他所用的思想和YOLO一样,把整个问题看成是个回归问题。

    我们先来说一下VGG-16。
    VGG-16是牛津大学2016年提出来的卷积神经网络模型,一经提出,就在简洁性和实用性方面表现突出,并迅速成为主流的神经网络结构。
    在这里插入图片描述D组的模型就是VGG-16,由16层结构,包括卷积层、最大池化层和全连接层加最后的soft-max层。

    本文采用的是VGG-16前面的卷积层,保留部分网络到VGG-16的conv3-512层,去掉了后面的全链接层。
    以上改进的VGG-16网络的作用是用来对图片进行特征提取。

    后面不同尺度的卷积层用于多尺度特征的识别。
    后面结构的目的是用来在不同的卷积层上进行检测。对于一个mxn大小p个通道的特征图。预测目标的基本元素是用3x3xp的小卷积核,用来产生种类的分数和默认框坐标的偏移值。SSD提取了不同尺度的特征图来做检测,大尺度特征图(较靠前的特征图)可以用来检测小物体,而小尺度特征图(较靠后的特征图)用来检测大物体。

    默认框及它的长宽比:
    把每个默认框与每个特征图的cell用卷积层的方式相关联,因此每个框与特征图的cell是一一对应的。在每个特征图的cell中,我们预测在cell里面的默认框的偏移值及每个种类的分数,每个点都有k个默认框,每个默认框由c个种类分数及4个坐标位置信息(xy坐标,及xy的偏移量),假设特征图为mxn,那么会产生(c+4)mnk个输出结果。

    默认框的思想就是来自于Faster-RCNN的anchor和YOLO的回归思想。SSD算法是用多个个卷积层分别预测大小不同的物体。生成的特征图由大到小,大的特征图预测小物体,小的特征图预测大物体。

    例如第一个特征图是38x38x1024,那么那张特征图的就有38x38个点,由于卷积的位置不变性可知,每个点都对应了输入图像的一个位置。那问题来了,为什么要有默认框呢?为什么不直接回归呢?就像YOLO算法一样。

    为了提高速度,从而降低训练难度,每个点都有4个默认框或者6个。如下图:
    在这里插入图片描述
    那初始默认框是怎么产生的了?
    初始的默认框也叫prior box

    包括两个方面:中心点和长宽。
    中心点的生成:
    就以conv6那一层为例子,输入的图片为300x300x3,输出的特征图为19x19x1024,也就是每张特征图的大小为19x19。根据卷积神经网络的的位置不变性,那么特征图的每个点都对应着输入图像的一个中心点。
    例如特征图的(2,2)位置对应在原图片的位置为(300/19x2,300/19x2)即(31,31)
    长宽的生成:

    在这里插入图片描述
    本文中的 Smin为0.2,Smax为0.9
    所以最靠前的prior boxes的Sk为0.2,最靠后的prior boxes为0.9,中间层按照上面公式来。

    使用不同的ratio值[1,2,3,1/2,1/3] 用下面的公式计算默认框的长宽:
    w=skratio1/2,w=sk/ratio1/2 w=sk*ratio^{1/2}, w=sk/ratio^{1/2}
    当ratio为1时,
    sk2=(sksk+1)1/2 sk^2=({sk*s{k+1}})^{1/2}
    这样的话我们就可以生成6个不同的 prior boxes

    匹配策略:
    安装上面的方式,我们每个不同大小的特征图上面的每个点都会生成6个prior boxes,那么一共会生成
    38x38x4+19x19x6+10x10x6+5x5x6+3x3x4+1x1x4=8732
    为啥有的特征图每个点只有4个prior box,有些却有6个呢?
    我也不知道!

    问题来了,一张图片上面真的需要这么多prior boxes,显然是不需要的。这会大幅度增加耗时而且准确率也不高。

    我们在生成prior box后,与原图的每个ground truth boxes相匹配,选择与其IOU最大的的先验框(best jaccard overlap),保证每个ground truth boxes都有一个prior boxes相匹配。被选择出来的prior boxes就是default boxes,保证每一个default boxes预测一个ground truth boxes,其他的prior boxes作为负样本,这也造成了大量的负样本。面对如此大的负样本,我们不可能全都加入训练中,所以以1:3的正负比例提取负样本,这也会使优化更快训练更稳定。

    同时,该算法为了取得更好的效果使用了数据增强
    每个训练图像从以下中随机选择一个:
    1.使用整个原始图像
    2.从图像中采样一个patch,与目标的最小值IOU为0.1,0.3,0.5,0.7,0.9
    3.随机采样这个patch:
    每个采样的patch为原图像的0.1到1,长宽比为0.5到2之间。当ground truth boxes的采样中心在采样的patch中时,保留重叠部分。在这个采样步骤之后,每个采样的patch转化为固定尺寸,以0.5的概率翻转。

    我们现在已经得到了相当数量的样本
    下面我们继续说一下如何从default box实现目标检测
    以conv6为例,生成19x19x1024特征图
    本文舍弃了传统的全连接层,而是用3x3的卷积层代替它的工作,这样做的目的是减少参数,加快运算速度。
    试想一下如果用全链接层来进行检测工作,那么将19x19x1024的参数铺平后,就有19x19x1024=369664,如果后面接100个全链接的神经元,那么参数高达369966400。这将大大拖慢运算速度。

    下面是整体的损失函数
    在这里插入图片描述
    N代表的是匹配的default boxes的数量,N为0时损失值也为零。

    你看的没错,位置和置信度的损失函数是一个公式。
    在这里插入图片描述位置回归是典型的smooth L1 loss
    在这里插入图片描述
    下面是置信度的回归
    在这里插入图片描述
    采用的是softmax的损失函数

    重要补充

    IOU是目标检测算法中一个非常重要的函数
    全称是Intersection over Union,也就是交并比
    也就是default boxes和ground truth boxes的交并比
    在这里插入图片描述
    NMS算法:由于直接由神经网络训练出来的结果有大量重复和重叠的框,这将大大加大训练的难度,所以论文采用了NMS算法来抑制默认框的产生以加快运算速度。
    在这里就不详细介绍了。
    以上是SSD算法的细节流程,可能有很多遗落的,希望指正!

    展开全文
  • 针对SSD算法在计算机视觉中检测多目标时出现的漏检现象,在SSD算法的基础上,将VGG-16网络替换为密集型网络,并对目标检测后的所有预测框进行非极大值抑制算法改进,使得每层网络都直接连接输入和损失,保证所提取到...
  • SSD目标检测算法简介: 论文地址:https://arxiv.org/abs/1512.02325 全称:Singel Shot MultiBox Detector(那么为什么不叫SSMD呢,可能因为不太好听吧) SSD属于one-stage目标检测算法,就是目标的分类和检测任务是...

    SSD目标检测算法简介:
    论文地址:https://arxiv.org/abs/1512.02325
    全称:Singel Shot MultiBox Detector(那么为什么不叫SSMD呢,可能因为不太好听吧)
    SSD属于one-stage目标检测算法,就是目标的分类和检测任务是同时完成的(从始至终都是用一个网络)。
    SSD其实是在Yolo上进行了改进:如下图所示,简单来说SSD最明显的特征就是:多尺度检测。(就是对图片在经过主干网络VGG-16得到的feature map,再进行多次卷积,得到多个不同尺寸的feature map, 分别对这些不同尺寸的feature map进行Detect)
    在这里插入图片描述
    SSD基础网络是基于VGG16,后续在其基础上做了些调整,具体如下:
    1.将VGG16的Fc6 Fc7层转化为卷积层;
    2.去掉了Dropout层和Fc8层
    3.Fc7层后新增了4个卷积层

    SSD的基础网络结构可以用下表表示清楚:(以输入3003003为例子)
    在这里插入图片描述
    以上就是SSD特征提取网络的整体结构,其实看起来还是非常清晰的。其中从input到FC6其实就是传统的VGG16网络结构。

    可以看出SSD的特征提取网络,实际上就是生成了我们需要的6个 feature map ,其shape分别为:(38,38,512),(19,19,1024),(10, 10, 512),(5,5,256),(3, 3, 256),(1, 1, 256)。

    PS:
    1x1的卷积就是为了调整通道数。
    没有标padding的都是默认padding==same,这种卷积方式不会改变feature map的宽和高。

    使用Keras来搭建SSD特征提取网络:

    import keras
    import numpy as py
    from keras.models import Model
    from keras.layers import Conv2D, MaxPooling2D, ZeroPadding2D, Input, Reshape, GlobalAveragePooling2D
    def VGG16(input_tensor):
        #用来存放所有的中间层
        net = {}
        #block1   两个卷积 一个maxpooling
        #input:300 300 3    output:150 150 64
        net['input'] = input_tensor #input_tensor就是输入图像
        net['conv1_1'] = Conv2D( 64, kernel_size=(3,3),
                                 activation='relu',
                                 padding='same',
                                 name='conv1_1')(net['input'])
        net['conv1_2'] = Conv2D(64, kernel_size=(3, 3),
                                activation='relu',
                                padding='same',
                                name='conv1_2')(net['conv1_1'])
        net['pool1'] = MaxPooling2D(pool_size=(2,2),
                                    strides=(2,2),
                                    padding='same',
                                    name='pool1')(net['conv1_2'])
        #block2  两个卷积一个maxpooling
        # input:150 150 64    output:75 75 128
        net['conv2_1'] = Conv2D(128, kernel_size=(3,3),
                                 activation='relu',
                                 padding='same',
                                 name='conv2_1')(net['pool1'])
        net['conv2_2'] = Conv2D(128, kernel_size=(3, 3),
                                activation='relu',
                                padding='same',
                                name='conv2_2')(net['conv2_1'])
        net['pool2'] = MaxPooling2D(pool_size=(2,2),
                                    strides=(2,2),
                                    padding='same',
                                    name='pool2')(net['conv2_2'])
        # block3  3个卷积一个maxpooling
        # input: 75 75 128   output:38 38 256
        net['conv3_1'] = Conv2D(256, kernel_size=(3, 3),
                                activation='relu',
                                padding='same',
                                name='conv3_1')(net['pool2'])
        net['conv3_2'] = Conv2D(256,kernel_size=(3, 3),
                                activation='relu',
                                padding='same',
                                name='conv3_2')(net['conv3_1'])
        net['conv3_3'] = Conv2D(256, kernel_size=(3, 3),
                                activation='relu',
                                padding='same',
                                name='conv3_3')(net['conv3_2'])
        net['pool3'] = MaxPooling2D(pool_size=(2, 2),
                                    strides=(2, 2),
                                    padding='same',
                                    name='pool3')(net['conv3_3'])
        # block4  3个卷积一个maxpooling
        # input: 38 38 256   output:19 19 512
        net['conv4_1'] = Conv2D(512, kernel_size=(3, 3),
                                activation='relu',
                                padding='same',
                                name='conv4_1')(net['pool3'])
        net['conv4_2'] = Conv2D(512, kernel_size=(3, 3),
                                activation='relu',
                                padding='same',
                                name='conv4_2')(net['conv4_1'])
        net['conv4_3'] = Conv2D(512, kernel_size=(3, 3),
                                activation='relu',
                                padding='same',
                                name='conv4_3')(net['conv4_2'])
        #nets['conv4_3'] 是一个有效特征层
        y1 = net['conv4_3']
        net['pool4'] = MaxPooling2D(pool_size=(2, 2),
                                    strides=(2, 2),
                                    padding='same',
                                    name='pool4')(net['conv4_3'])
        # block5  3个卷积一个maxpooling
        # input: 19 19 512   output:19 19 512
        net['conv5_1'] = Conv2D(512, kernel_size=(3, 3),
                                activation='relu',
                                padding='same',
                                name='conv5_1')(net['pool4'])
        net['conv5_2'] = Conv2D(512, kernel_size=(3, 3),
                                activation='relu',
                                padding='same',
                                name='conv5_2')(net['conv5_1'])
        net['conv5_3'] = Conv2D(512, kernel_size=(3, 3),
                                activation='relu',
                                padding='same',
                                name='conv5_3')(net['conv5_2'])
        y2 = net['conv5_3']
        net['pool5'] = MaxPooling2D(pool_size=(2, 2),
                                    strides=(1, 1),#这里maxpooing 的步长为1  所以不会改变长宽
                                    padding='same',
                                    name='pool5')(net['conv5_3'])
        #FC6利用卷积代替传统vgg里面的全连接层
        #19 19 512     --->  19 19 1024
        #改变通道数
        net['fc6'] = Conv2D(1024, kernel_size=(3, 3),
                                activation='relu',
                                padding='same',
                                name='fc6')(net['pool5'])
        #FC7
        #19 19 1024     --->  19 19 1024
        #改变通道数
        net['fc7'] = Conv2D(1024, kernel_size=(1, 1),
                                activation='relu',
                                padding='same',
                                name='fc7')(net['fc6'])
        #nets['fc7']是一个有效特征层
        #block6  1个卷积 + 1个zeropadding + 1个卷积
        #input:19 19 1024   ouput:10 10 512
        net['conv6_1'] = Conv2D(256, kernel_size=(1,1),
                                activation='relu',
                                padding='same',
                                name='conv6_1')(net['fc7'])
        net['conv6_2'] = ZeroPadding2D(padding=((1, 1), (1, 1)), name='conv6_padding')(net['conv6_1'])
        net['conv6_2'] = Conv2D(512, kernel_size=(3, 3),
                                strides=(2, 2),
                                activation='relu',
                                name='conv6_2')(net['conv6_2'])
        y3 = net['conv6_2']
        #nets['conv6_2']是一个有效特征层
        
        #block7 1个卷积 + 1个zeropadding + 1个卷积
        #input 10 10 512   output 5 5 256
        net['conv7_1'] = Conv2D(128, kernel_size=(1, 1),
                                activation='relu',
                                padding='same',
                                name='conv7_1')(net['conv6_2'])
        net['conv7_2'] = ZeroPadding2D(padding=((1, 1), (1, 1)), name='conv7_padding')(net['conv7_1'])
        net['conv7_2'] = Conv2D(256, kernel_size=(3, 3),
                                strides=(2, 2),
                                activation='relu',
                                padding='valid',
                                name='conv7_2')(net['conv7_2'])
        y4 = net['conv7_2']
        # nets['conv7_2']是一个有效特征层
        
        #block8 1个卷积 + 1个卷积
        #input 5 5 256   output 3 3 256
        net['conv8_1'] = Conv2D(128, kernel_size=(1, 1),
                                activation='relu',
                                padding='same',
                                name='conv8_1')(net['conv7_2'])
        net['conv8_2'] = Conv2D(256, kernel_size=(3, 3),
                                strides=(1, 1), activation='relu', padding='valid',
                                name='conv8_2')(net['conv8_1'])
        y5 = net['conv8_2']
        # nets['conv8_2']是一个有效特征层
    
        # block9 1个卷积 + 1个卷积
        # input 3 3 256   output 1 1 256
        net['conv9_1'] = Conv2D(128, kernel_size=(1, 1),
                                activation='relu',
                                padding='same',
                                name='conv9_1')(net['conv8_2'])
        net['conv9_2'] = Conv2D(256, kernel_size=(3, 3),
                                strides=(1, 1), activation='relu', padding='valid',
                                name='conv9_2')(net['conv9_1'])
        y6 = net['conv9_2']
        # nets['conv9_2']是一个有效特征层
    
        model = Model(input_tensor, nets, name="VGG16")
        return model
    
    if __name__ == '__main__':
       inputs = Input(shape=(300,300,3))
       model = VGG16(inputs)
       #打印网络结构
       model.summary()
    
    展开全文
  • SSD目标检测算法详解 (二)代码详解 这一篇
  • pytorch下实现ssd目标检测算法运行时遇到的错误 代码地址:https://github.com/amdegroot/ssd.pytorch 版本:pytorch1.0 运行test.py遇到错误 ValueError: not enough values to unpack (expected 2, got 0) 如下图...
  • AI SSD目标检测算法

    2019-03-20 16:42:00
    Single Shot multibox Detector,简称SSD,是一种目标检测算法。 Single Shot意味着SSD属于one stage方法,multibox表示多框预测。 CNN 多尺度 特征图 参考链接: https://arxiv.org/pdf/1711.06897.pdf ...
  • SSD算法中,每个feature map的像素点都会生成prior box,SSD通过prior box进而对feature map进行训练。 文章中提到,SSD在训练过程中,prior box与GroundTruth的之间ROI 达到0.5才会放到网络里面进行训练。大的...
  • 上一章我们了解到,物体识别检测算法是在传统CNN算法基础上加上目标区域建议策略和边框回归算法得到的。前辈们的工作主要体现在目标区域建议的改进策略上,从最开始的穷举建议框,到划分图像区域,再到从特征图上...
  • 目前基于深度学习的目标检测算法主要分为两类,分别是one-stage和two-stage,其中,two-stage算法典型算法有R-CNN,先通过启发式方法或者CNN网络产生一系列稀疏的候选框,然后对这些候选框进行分类与回归;...
  • 论文代码:https://github.com/weiliu89/caffe/tree/ssd SSD全称:Single Shot MultiBox Detector 是2016年...是目前为止主要的目标检测算法。 算法的主要优点: 1. 速度比Faster-Rcnn快,精度比YOLO高。(在...
  • SSD目标检测算法详解 (一)论文讲解 这一篇讲几个方面: 一、提要 二、论文详解: (1) SSD算法的特点 (2) SSD算法总体结构 (3) 前馈神经网络——VGG (4) 不同特征层的提取 (5) ...
  • SSD目标检测算法解读

    2020-01-01 15:26:30
    SSD:Single Shot MultiBox Detector. one-stage和two-stage网络说明 one-stage网络会讲图片分成许多image patch,之后在每个patch上设置不同宽高的anchor框,网络对该框的数据进行分类和回归即可得到结果。two-...
  • 参考链接: 睿智的目标检测23——Pytorch搭建SSD目标检测平台 参考链接: 参考源代码: ssd_layers.py from __future__ import division import torch import torch.nn as nn import torch.nn.init as init from torch....
  • 左边就是SSD算法检测部分,右边是DSOD的,整个其实还是DenseNet的思想,即将前面层的feature map和后面层的feature map连接到一起。 这个过程并没有什么新意。 以上就是DSOD,如果看过R-FCN的话就会...
  • ❝上期一起学了SSD算法的框架流程,如下:目标检测算法SSD结构详解❞今天我们一起学下成功训练SSD算法的一些注意点:Loss计算Match策略数据增强性能分析Loss计算SSD算法的目...
  • https://blog.csdn.net/qq_41368247/article/details/88027340
  • SSD目标检测算法改进DSSD(反卷积)

    万次阅读 2018-01-20 17:19:14
    论文:DSSD : Deconvolutional Single Shot Detector 论文地址:https://arxiv.org/abs/1701.06659 代码:...DSSD是2017年的CVPR,二作就是SSD的一作Wei Liu。另外值得
  • ssd_pascal.py中对default boxes(prior boxes)的设置由如下代码完成: # parameters for generating priors. # minimum dimension of input image min_dim = 300 # conv4_3 ==> 38 x 38 # fc7 ==> 19 x 19 # ...
  • 参考了一些网上的SSD的实现,现在对其进行tensorflow的...附一个我写的SSD算法的详解链接。 一、Backbone函数(基于VGG16) # 基于vgg16函数的backbone #b1 net = self.conv2d(x,filter=64,k_size=[3,3],scope=...
  • SSD目标检测网络 1、SSD目标检测网络的整体结构 SSD网络输入图片的大小为300×300×3,特征提取网络使用的是VGG16模型,提取到6个不同大小的特征层。特征层可以看做是把图片划分成不同的网格,每一个网格上对应有多...
  • import torch print(torch.version.cuda)

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,624
精华内容 4,649
关键字:

ssd目标检测算法