精华内容
下载资源
问答
  • yolo系列之yolo v3【深度解析】

    万次阅读 多人点赞 2018-09-12 16:24:48
    yolo_v3是我最近一段时间主攻的算法,写下博客,以作分享交流。 看过yolov3论文的应该都知道,这篇论文写得很随意,很多亮点都被作者都是草草描述。很多骚年入手yolo算法都是从v3才开始,这是不可能掌握yolo精髓的...

    版权申明:转载和引用图片,都必须经过书面同意。获得留言同意即可
    本文使用图片多为本人所画,需要高清图片可以留言联系我,先点赞后取图
    这篇博文比较推荐的yolo v3代码是qwe的keras版本,复现比较容易,代码相对来说比较容易理解。同学们可以结合代码和博文共同理解v3的精髓。
    github地址:https://github.com/qqwweee/keras-yolo3


    前言

    前言就是唠唠嗑,想直接看干货可以跳过前言,直接看Yolo v3。
    yolo_v3是我最近一段时间主攻的算法,写下博客,以作分享交流。
    看过yolov3论文的应该都知道,这篇论文写得很随意,很多亮点都被作者都是草草描述。很多骚年入手yolo算法都是从v3才开始,这是不可能掌握yolo精髓的,因为v3很多东西是保留v2甚至v1的东西,而且v3的论文写得很随心。想深入了解yolo_v3算法,是有必要先了解v1和v2的。以下是我关于v1和v2算法解析所写的文章:
    v1算法解析:《yolo系列之yolo v1
    v2算法解析:《yolo系列之yolo v2
    yolo_v3作为yolo系列目前最新的算法,对之前的算法既有保留又有改进。先分析一下yolo_v3上保留的东西:

    1. “分而治之”,从yolo_v1开始,yolo算法就是通过划分单元格来做检测,只是划分的数量不一样。
    2. 采用"leaky ReLU"作为激活函数。
    3. 端到端进行训练。一个loss function搞定训练,只需关注输入端和输出端。
    4. 从yolo_v2开始,yolo就用batch normalization作为正则化、加速收敛和避免过拟合的方法,把BN层和leaky relu层接到每一层卷积层之后。
    5. 多尺度训练。在速度和准确率之间tradeoff。想速度快点,可以牺牲准确率;想准确率高点儿,可以牺牲一点速度。

    yolo每一代的提升很大一部分决定于backbone网络的提升,从v2的darknet-19到v3的darknet-53。yolo_v3还提供替换backbone——tiny darknet。要想性能牛叉,backbone可以用Darknet-53,要想轻量高速,可以用tiny-darknet。总之,yolo就是天生“灵活”,所以特别适合作为工程算法。
    当然,yolo_v3在之前的算法上保留的点不可能只有上述几点。由于本文章主要针对yolo_v3进行剖析,不便跑题,下面切入正题。


    YOLO v3

    网上关于yolo v3算法分析的文章一大堆,但大部分看着都不爽,为什么呢?因为他们没有这个玩意儿:

    图1. yolo_v3结构图
    yolo系列里面,作者只在v1的论文里给出了结构图,而v2和v3的论文里都没有结构图,这使得读者对后两代yolo结构的理解变得比较难。but,对于yolo学习者来说,脑子里没有一个清晰的结构图,就别说自己懂yolo了。上图是我根据官方代码和官方论文以及模型结构可视化工具等经过好几个小时画出来的,修订过几个版本。所以, 上图的准确性是可以保证的

    这里推荐的模型结构可视化工具是Netron
    netron方便好用,可以直观看到yolo_v3的实际计算结构,精细到卷积层。But,要进一步在人性化的角度分析v3的结构图,还需要结合论文和代码。对此,我是下了不少功夫。
    上图表示了yolo_v3整个yolo_body的结构,没有包括把输出解析整理成咱要的[box, class, score]。对于把输出张量包装成[box, class, score]那种形式,还需要写一些脚本,但这已经在神经网络结构之外了(我后面会详细解释这波操作)。
    为了让yolo_v3结构图更好理解,我对图1做一些补充解释:
    DBL: 如图1左下角所示,也就是代码中的Darknetconv2d_BN_Leaky,是yolo_v3的基本组件。就是卷积+BN+Leaky relu。对于v3来说,BN和leaky relu已经是和卷积层不可分离的部分了(最后一层卷积除外),共同构成了最小组件。
    resn:n代表数字,有res1,res2, … ,res8等等,表示这个res_block里含有多少个res_unit。这是yolo_v3的大组件,yolo_v3开始借鉴了ResNet的残差结构,使用这种结构可以让网络结构更深(从v2的darknet-19上升到v3的darknet-53,前者没有残差结构)。对于res_block的解释,可以在图1的右下角直观看到,其基本组件也是DBL。
    concat:张量拼接。将darknet中间层和后面的某一层的上采样进行拼接。拼接的操作和残差层add的操作是不一样的,拼接会扩充张量的维度,而add只是直接相加不会导致张量维度的改变。

    我们可以借鉴netron来分析网络层,整个yolo_v3_body包含252层,组成如下:
    layers

    表0. yolo_v3_layers
    根据表0可以得出,对于代码层面的layers数量一共有252层,包括add层23层(主要用于res_block的构成,每个res_unit需要一个add层,一共有1+2+8+8+4=23层)。除此之外,BN层和LeakyReLU层数量完全一样(72层),在网络结构中的表现为: 每一层BN后面都会接一层LeakyReLU。卷积层一共有75层,其中有72层后面都会接BN+LeakyReLU的组合构成基本组件DBL。看结构图,可以发现上采样和concat都有2次,和表格分析中对应上。每个res_block都会用上一个零填充,一共有5个res_block。

    1. backbone

    整个v3结构里面,是没有池化层和全连接层的。前向传播过程中,张量的尺寸变换是通过改变卷积核的步长来实现的,比如stride=(2, 2),这就等于将图像边长缩小了一半(即面积缩小到原来的1/4)。在yolo_v2中,要经历5次缩小,会将特征图缩小到原输入尺寸的 1 / 2 5 1/2^5 1/25,即1/32。输入为416x416,则输出为13x13(416/32=13)。
    yolo_v3也和v2一样,backbone都会将输出特征图缩小到输入的1/32。所以,通常都要求输入图片是32的倍数。可以对比v2和v3的backbone看看:(DarkNet-19 与 DarkNet-53)

    图2. darknet-19 vs darknet-53
    yolo_v2中对于前向过程中张量尺寸变换,都是通过 最大池化来进行,一共有5次。而v3是通过卷积核 增大步长来进行,也是5次。(darknet-53最后面有一个全局平均池化,在yolo-v3里面没有这一层,所以张量维度变化只考虑前面那5次)。
    这也是416x416输入得到13x13输出的原因。从图2可以看出,darknet-19是不存在残差结构(resblock,从resnet上借鉴过来)的,和VGG是同类型的backbone(属于上一代CNN结构),而darknet-53是可以和resnet-152正面刚的backbone,看下表:

    这里写图片描述

    表1. backbone对比图
    从上表也可以看出,darknet-19在速度上仍然占据很大的优势。其实在其他细节也可以看出(比如bounding box prior采用k=9), yolo_v3并没有那么追求速度,而是在保证实时性(fps>36)的基础上追求performance。不过前面也说了,你要想更快,还有一个 tiny-darknet作为backbone可以替代darknet-53,在官方代码里用一行代码就可以实现切换backbone。搭用tiny-darknet的yolo,也就是tiny-yolo在轻量和高速两个特点上,显然是state of the art级别,tiny-darknet是和squeezeNet正面刚的网络,详情可以看下表:
    表2. 轻量级对比图
    所以,有了yolo v3,就真的用不着yolo v2了,更用不着yolo v1了。这也是[yolo官方网站](https://pjreddie.com/darknet/),在v3出来以后,就没提供v1和v2代码下载链接的原因了。

    2. Output

    对于图1而言,更值得关注的是输出张量:

    yolo v3输出了3个不同尺度的feature map,如上图所示的y1, y2, y3。这也是v3论文中提到的为数不多的改进点:predictions across scales
    这个借鉴了FPN(feature pyramid networks),采用多尺度来对不同size的目标进行检测,越精细的grid cell就可以检测出越精细的物体。
    y1,y2和y3的深度都是255,边长的规律是13:26:52
    对于COCO类别而言,有80个种类,所以每个box应该对每个种类都输出一个概率。
    yolo v3设定的是每个网格单元预测3个box,所以每个box需要有(x, y, w, h, confidence)五个基本参数,然后还要有80个类别的概率。所以3*(5 + 80) = 255。这个255就是这么来的。(还记得yolo v1的输出张量吗? 7x7x30,只能识别20类物体,而且每个cell只能预测2个box,和v3比起来就像老人机和iphoneX一样)
    v3用上采样的方法来实现这种多尺度的feature map,可以结合图1和图2右边来看,图1中concat连接的两个张量是具有一样尺度的(两处拼接分别是26x26尺度拼接和52x52尺度拼接,通过(2, 2)上采样来保证concat拼接的张量尺度相同)。作者并没有像SSD那样直接采用backbone中间层的处理结果作为feature map的输出,而是和后面网络层的上采样结果进行一个拼接之后的处理结果作为feature map。为什么这么做呢? 我感觉是有点玄学在里面,一方面避免和其他算法做法重合,另一方面这也许是试验之后并且结果证明更好的选择,再者有可能就是因为这么做比较节省模型size的。这点的数学原理不用去管,知道作者是这么做的就对了。


    3. some tricks

    上文把yolo_v3的结构讨论了一下,下文将对yolo v3的若干细节进行剖析。
    Bounding Box Prediction
    b-box预测手段是v3论文中提到的又一个亮点。先回忆一下v2的b-box预测:想借鉴faster R-CNN RPN中的anchor机制,但不屑于手动设定anchor prior(模板框),于是用维度聚类的方法来确定anchor box prior(模板框),最后发现聚类之后确定的prior在k=5也能够又不错的表现,于是就选用k=5。后来呢,v2又嫌弃anchor机制线性回归的不稳定性(因为回归的offset可以使box偏移到图片的任何地方),所以v2最后选用了自己的方法:直接预测相对位置。预测出b-box中心点相对于网格单元左上角的相对坐标。

    公式1

    这里写图片描述
    yolo v2直接predict出( t x t_x tx, t y t_y ty, t w t_w tw, t h t_h th, t o t_o to),并不像RPN中anchor机制那样去遍历每一个pixel。可以从上面的公式看出,b-box的位置大小和confidence都可以通过( t x t_x tx, t y t_y ty, t w t_w tw, t h t_h th, t o t_o to)计算得来,v2相当直接predict出了b-box的位置大小和confidence。box宽和高的预测是受prior影响的,对于v2而言,b-box prior数为5,在论文中并没有说明抛弃anchor机制之后是否抛弃了聚类得到的prior(没看代码,所以我不能确定),如果prior数继续为5,那么v2需要对不同prior预测出 t w t_w tw t h t_h th
    对于v3而言,在prior这里的处理有明确解释:选用的b-box priors 的k=9,对于tiny-yolo的话,k=6。priors都是在数据集上聚类得来的,有确定的数值,如下:

    10,13,  16,30,  33,23,  30,61,  62,45,  59,119,  116,90,  156,198,  373,326
    

    每个anchor prior(名字叫anchor prior,但并不是用anchor机制)就是两个数字组成的,一个代表高度另一个代表宽度。
    v3对b-box进行预测的时候,采用了logistic regression。这一波操作sao得就像RPN中的线性回归调整b-box。v3每次对b-box进行predict时,输出和v2一样都是( t x t_x tx, t y t_y ty, t w t_w tw, t h t_h th, t o t_o to),然后通过公式1计算出绝对的(x, y, w, h, c)。
    logistic回归用于对anchor包围的部分进行一个目标性评分(objectness score),即这块位置是目标的可能性有多大。这一步是在predict之前进行的,可以去掉不必要anchor,可以减少计算量。作者在论文种的描述如下:

    If the bounding box prior is not the best but does overlap a ground truth object by more than some threshold we ignore the prediction, following[17]. We use the threshold of 0.5. Unlike [17] our system only assigns one bounding box prior for each ground truth object.

    如果模板框不是最佳的即使它超过我们设定的阈值,我们还是不会对它进行predict。
    不同于faster R-CNN的是,yolo_v3只会对1个prior进行操作,也就是那个最佳prior。而logistic回归就是用来从9个anchor priors中找到objectness score(目标存在可能性得分)最高的那一个。logistic回归就是用曲线对prior相对于 objectness score映射关系的线性建模。
    疑问解答和说明:

    在评论里有同学问我关于输出的问题,看来我在这里没有说的很清楚。了解v3输出的输出是至关重要的。
    
    第一点, 9个anchor会被三个输出张量平分的。根据大中小三种size各自取自己的anchor。
    
    第二点,每个输出y在每个自己的网格都会输出3个预测框,这3个框是9除以3得到的,这是作者设置
    的,我们可以从输出张量的维度来看,13x13x255。255是怎么来的呢,3*(5+80)。80表示80个种类,5表
    示位置信息和置信度,3表示要输出3个prediction。在代码上来看,3*(5+80)中的3是直接由
    num_anchors//3得到的。
    
    第三点,作者使用了logistic回归来对每个anchor包围的内容进行了一个目标性评分(objectness score)。
    根据目标性评分来选择anchor prior进行predict,而不是所有anchor prior都会有输出。
    

    loss function

    对掌握Yolo来讲,loss function不可谓不重要。在v3的论文里没有明确提所用的损失函数,确切地说,yolo系列论文里面只有yolo v1明确提了损失函数的公式。对于yolo这样一种讨喜的目标检测算法,就连损失函数都非常讨喜。在v1中使用了一种叫sum-square error的损失计算方法,就是简单的差方相加而已。想详细了解的可以看我关于v1解释的博文。我们知道,在目标检测任务里,有几个关键信息是需要确定的: ( x , y ) , ( w , h ) , c l a s s , c o n f i d e n c e (x, y), (w, h), class, confidence (x,y),(w,h),class,confidence
    根据关键信息的特点可以分为上述四类,损失函数应该由各自特点确定。最后加到一起就可以组成最终的loss_function了,也就是一个loss_function搞定端到端的训练。可以从代码分析出v3的损失函数,同样也是对以上四类,不过相比于v1中简单的总方误差,还是有一些调整的:

    xy_loss = object_mask * box_loss_scale * K.binary_crossentropy(raw_true_xy, raw_pred[..., 0:2],
                                                                           from_logits=True)
    wh_loss = object_mask * box_loss_scale * 0.5 * K.square(raw_true_wh - raw_pred[..., 2:4])
    confidence_loss = object_mask * K.binary_crossentropy(object_mask, raw_pred[..., 4:5], from_logits=True) + \
                              (1 - object_mask) * K.binary_crossentropy(object_mask, raw_pred[..., 4:5],
                                                                        from_logits=True) * ignore_mask
    class_loss = object_mask * K.binary_crossentropy(true_class_probs, raw_pred[..., 5:], from_logits=True)
    
    xy_loss = K.sum(xy_loss) / mf
    wh_loss = K.sum(wh_loss) / mf
    confidence_loss = K.sum(confidence_loss) / mf
    class_loss = K.sum(class_loss) / mf
    loss += xy_loss + wh_loss + confidence_loss + class_loss
    

    以上是一段keras框架描述的yolo v3 的loss_function代码。忽略恒定系数不看,可以从上述代码看出:除了w, h的损失函数依然采用总方误差之外,其他部分的损失函数用的是二值交叉熵。最后加到一起。那么这个binary_crossentropy又是个什么玩意儿呢?就是一个最简单的交叉熵而已,一般用于二分类,这里的两种二分类类别可以理解为"对和不对"这两种。关于binary_crossentropy的公式详情可参考博文《常见的损失函数》。


    总结

    v3毫无疑问现在成为了工程界首选的检测算法之一了,结构清晰,实时性好。这是我十分安利的目标检测算法,更值得赞扬的是,yolo_v3给了近乎白痴的复现教程,这种气量在顶层算法研究者中并不常见。你可以很快的用上v3,但你不能很快地懂v3,我花了近一个月的时间才对v3有一个清晰的了解(可能是我悟性不够哈哈哈)。在算法学习的过程中,去一些浮躁,好好理解算法比只会用算法难得很多。

    展开全文
  • YOLO bounding box的理解

    万次阅读 2018-05-30 14:38:52
    一、yolov1 bounding boxbounding box是怎么产生的?回归产生的,回归?哎呀,妈呀,回归是什么我都忘记了,好吧,我来举个初中的线性回归例子简单回顾一下有两组数据A和BA = [1,2,3,4,5] B = [2,4,6,8,10]利用回归...

    一、yolov1 bounding box

    bounding box是怎么产生的?回归产生的,回归?哎呀,妈呀,回归是什么我都忘记了,好吧,我来举个初中的线性回归例子简单回顾一下

    有两组数据A和B

    A = [1,2,3,4,5] 

    B = [2,4,6,8,10]

    利用回归的思想预测当A为6的时候B对应的值是多少

    很明显回归参数就是2,回归程为y = 2x,所以A为6的时候B对应的值应该是12,这就是最简单的回归思路了。

    然后yolo1中提到的就是直接利用整幅图像经过网络结构产生7*7的grid cell,每个grid cell预测x,y,w,h,confidence等几个值,其中confidence就是IOU的值啦。关键这个bounding box怎么回归产生的,对我这种小白来说还是纠结了好几天才算理解到一丢丢,所以赶紧小笔记记一下,欢迎各位大佬斧正(请原谅我想多了,就我这个级别的blog还有大佬看[笑哭])

    好,我们去看一下Annotation里面的XML文件,截取一部分看一下


    看到标注文件里面的Bounding box的格式了没,都是由[xmin,xmax,ymin,ymax]组成,中心坐标呢?


    回顾yolov1论文还说要把坐标和长宽归一化,你中心坐标都没有如何回归?最后在scipts找到了vol_label.py文件才知道中心坐标是根据标签中的xmin,xmax,ymin,ymax计算出来的,哈哈哈,详见下面代码注释。


    def convert(size, box):
        dw = 1./size[0] # 归一化的时候就是使用宽度除以整个image_size的宽度 
        dh = 1./size[1] # 归一化的时候就是使用高度除以整个image_size的高度
        x = (box[0] + box[1])/2.0 # 使用(xmin+xmax)/2得到x的中心点
        y = (box[2] + box[3])/2.0 # 使用(ymin+ymax)/2得到y的中心点
        w = box[1] - box[0] # 然后宽度就是使用xmax-xmin计算得到
        h = box[3] - box[2] # 然后高度就是使用ymax-ymin计算得到
        x = x*dw # 归一化中心坐标x
        w = w*dw # 归一化bbox宽度
        y = y*dh # 归一化中心坐标y
        h = h*dh # 归一化bbox高度
        return (x,y,w,h)
    
    def convert_annotation(year, image_id):
        in_file = open('VOCdevkit/VOC%s/Annotations/%s.xml'%(year, image_id))
        out_file = open('VOCdevkit/VOC%s/labels/%s.txt'%(year, image_id), 'w')
        tree=ET.parse(in_file)
        root = tree.getroot()
        size = root.find('size')
        w = int(size.find('width').text)
        h = int(size.find('height').text)
    
        for obj in root.iter('object'):
            difficult = obj.find('difficult').text
            cls = obj.find('name').text
            if cls not in classes or int(difficult) == 1:
                continue
            cls_id = classes.index(cls)
            xmlbox = obj.find('bndbox')
    	# 获取标注中bbox的数据并以元组方式返回
            b = (float(xmlbox.find('xmin').text), float(xmlbox.find('xmax').text), float(xmlbox.find('ymin').text), float(xmlbox.find('ymax').text))
    	# 向convert传入size = (w,h),和b,注释中分别是(xmin,xmax,ymin,ymax)   
    	bb = convert((w,h), b)
            out_file.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')

    有了中心坐标x,y和bbox的w,h这样就可以愉快地训练出回归参数了

    待更... ..

    展开全文
  • Bounding box object detectors: understanding YOLO, You Only Look Once http://christopher5106.github.io/object/detectors/2017/08/10/bounding-box-object-detectors-understanding-yolo.html In this artic...

    Bounding box object detectors: understanding YOLO, You Only Look Once

    http://christopher5106.github.io/object/detectors/2017/08/10/bounding-box-object-detectors-understanding-yolo.html

    In this article, I re-explain the characteristics of the bounding box object detector Yolo since everything might not be so easy to catch. Its first version has been improved in a version 2.

    • You Only Look Once: Unified, Real-Time Object Detection
    • YOLO9000: Better, Faster, Stronger

    The network outputs’ grid

    The convolutions enable to compute predictions at different positions in an image in an optimized way. This avoids using a sliding window to compute separately a prediction at every potential position.

    The deep learning network for prediction is composed of convolution layers of stride 1, and max-pooling layers of stride 2 and kernel size 2.

    To make it easier to align the grid of predictions produced by the network with the image:

    • each max-pooling layer divides the output size by 2, multiplies the network stride by 2, and shifts the position in the image corresponding to the net receptive field center by 1 pixel. The padding mode used is ‘VALID’, meaning it is the floor division in the image size division, the extra values left on the right and the bottom of the image will only be used in the network field but a smaller image without these pixels (as the blue one in the figure below) would lead to the same grid;

    • the padding mode ‘SAME’ used in the convolutions means the output has the same size as the input. This is performed by padding with some zeros (or other new values) each border of the image. If we’d used a ‘VALID’ padding for the convolutions, then the first position on the grid would be shifted by half the network reception field size, which can be huge (~ 200 pixels for a ~400 pixel large network). The problem requires us to predict objects close to the borders, so, to avoid a shift and start predicting values at the image border, borders are padded by half the reception field size, an operation performed by the ‘SAME’ padding mode.

    The following figure displays the impact of the padding modes and the network outputs in a grid. Final stride is 2nb max-pooling layers, and the left and top offsets are half that value, ie 2nb max-pooling layers - 1:

    这里写图片描述

    Positives and negatives, and the cells

    A position on the grid, that is the closest position to the center of one of the ground truth bounding boxes, is positive. Other positions are negative. The cell in the figure below gathers all possible position for the center of a ground truth box to activate the network output as positive:

    这里写图片描述

    So, let us keep these circles as a representation of the net outputs, and for the grid, rather than displaying a grid of the outputs, let us use this grid to separate the zones for which any ground truth box center will make these positions as positive. For that purpose, I can simply shift the grid back by half a stride:

    这里写图片描述

    Note that in a more general case, a position could be considered as positive for bigger or smaller cells than the network stride, and in such a case, it would not be possible to see the separations between the region of attraction of each position in a grid.

    A regressor rather than a classifier

    For every positive position, the network predicts a regression on the bounding box precise position and dimension.

    In the second version of Yolo, these predictions are relative to the grid position and anchor size (instead of the full image) as in the Faster-RCNN models for better performance:

    这里写图片描述

    where (cx, cy) are the grid cell coordinates and (pw, ph) the anchor dimensions.

    这里写图片描述

    Confidence

    Once the bounding box regressor is trained, the model is also trained to predict a confidence score on the final predicted bounding box with the above regressor.

    The natural confidence score value is:
    for a positive position, the intersection over union (IOU) of the predicted box with the ground truth
    for a negative position, zero.

    In the Yolo papers, confidence is trained jointly with the position/dimension regressor, which can cause model instability. To avoid this, they weighted the position/dimension regressor loss 5 times the confidence regressor loss.

    Anchors or prediction specialization

    Yolo V1 and V2 predict B regressions for B bounding boxes. Only one of the B regressors is trained at each positive position, the one that predicts a box that is closest to the ground truth box, so that there is a reinforcement of this predictor, and a specialization of each regressor.

    In Yolo V2, this specialization is ‘assisted’ with predefined anchors as in Faster-RCNN. The predefined anchors are chosen to be as representative as possible of the ground truth boxes, with the following K-means clustering algorithm to define them:
    https://github.com/Jumabek/darknet_scripts/blob/master/gen_anchors.py#L70-L105

    • all ground-truth bounding boxes are centered on (0,0)
    • the algorithm initiates 5 centroids by drawing randomly 5 of the ground-truth bounding boxes
    • then, the following two steps are alternated:
      • each ground truth box is assigned to one of the centroid, using as distance measure the IOU, in order to get 5 clusters or groups of ground-truth bouding boxes
      • new centroids are computed by taking the box inside each cluster that minimizes the mean IOU with all other boxes inside the cluster

    All together

    For each specialization, in Yolo V2, the class probabilities of the object inside the box is trained to be predicted, as the confidence score, but conditionally on positive positions.

    Putting it all together for an example of 5 anchors, 20 object classes, the output of the network at each position can be decomposed into 3 parts:
    anchors: 5
    object classes: 20
    coordinates: 5 * 4
    confidence scores: 5 * 1
    class probabilities: 5 * 20

    这里写图片描述

    For all outputs except the relative width and height, the outputs are followed by the logistic activation function or sigmoid, so that the final outputs fall between 0 and 1. * For the relative width and height, the activation is the exponential function.*

    Multi-scale training

    The multi-scale training consists in augmenting the dataset so that objects will be at multiple scales. Since a neural network works with pixels, resizing the images in the dataset at multiple sizes simply enable to simulate objects of multiple scales.

    这里写图片描述

    Note that some neural network implementations resize all images to a given size, let’s say 500 x 500, as a kind of first layer in the neural network. First, this automatic resizing step cancels the multi-scale training in the dataset. Second, there is also a problem with ratio since the network in this case will learn to deal with square images only: either part of the input image is discarded (crop), or the ratio is not preserved, which is suboptimal in both cases.

    The best way to deal with images of multiple sizes is to let the convolutions do the job: convolutions will automatically add more cells along the width and height dimensions to deal with images of different sizes and ratios. The only thing that you need to remind of is that a neural network works with pixels, that means each output value in the grid is a function of the pixels inside the receptive field, a function of the object resolution and not a function of the image width and height.

    这里写图片描述

    The global image width/height impacts the number of cells in the grid, vertically and horizontally. Locally, each stack of convolutions and max-pooling layers composing the net uses the pixel patch in the receptive field to compute the prediction and ignores the total number of cells and the global image width/height.

    This leads to the following point: anchor sizes can only be expressed in pixels as well. In order to allow multi-scale training, anchors sizes will never be relative to the input image width or height, since the objective of multi-scale training is to modify the ratio between the input dimensions and anchor sizes.

    In Yolo implementations, these sizes are given with respect to the grid size, which is a fixed number of pixels as well (the network stride, ie 32 pixels):

    Yolo anchors for VOC dataset:

    1.3221, 1.73145
    3.19275, 4.00944
    5.05587, 8.09892
    9.47112, 4.84053
    11.2364, 10.0071

    Well done!

    Wordbook
    newsletter [‘njuːzletə]:时事通讯
    regressor [ri’ɡresə]:回归量
    sliding window:滑动窗,推拉窗
    positive [ˈpɒzətɪv]:adj. 积极的,正的,阳性的,确定的,肯定的,实际的,真实的,绝对的
    n. 正数,正片
    negative [‘negətɪv]:adj. 负的,消极的,否定的,阴性的 n. 否定,负数,底片 vt. 否定,拒绝
    anchor [‘æŋkə]:n. 锚,抛锚停泊,靠山,新闻节目主播 vt. 抛锚,使固定,主持节目 vi. 抛锚 adj. 末棒的,最后一棒的
    receptive field:感受野,接受域

    References
    http://christopher5106.github.io/
    http://christopher5106.github.io/object/detectors/2017/08/10/bounding-box-object-detectors-understanding-yolo.html

    展开全文
  • YOLO-3D-盒子 具有3D边界框估计的YOLO模型 参考
  • https://fairyonice.github.io/Part_1_Object_Detection_with_Yolo_for_VOC_2014_data_anchor_box_clustering.html

    https://fairyonice.github.io/Part_1_Object_Detection_with_Yolo_for_VOC_2014_data_anchor_box_clustering.html

    展开全文
  • YOLO

    千次阅读 2017-03-04 10:29:07
    YOLO核心思想:从R-CNN到Fast R-CNN一直... YOLO提供了另一种更为直接的思路: 直接在输出层回归bounding box的位置和bounding box所属的类别(整张图作为网络的输入,把 Object Detection 的问题转化成一个 Regressio
  • 一文看懂YOLO v3

    万次阅读 多人点赞 2019-03-31 09:58:05
    YOLO系列的目标检测算法可以说是目标检测史上的宏篇巨作,接下来我们来详细介绍一下YOLO v3算法内容,v3的算法是在v1和v2的基础上形成的,所以有必要先回忆: 一文看懂YOLO v2,一文看懂YOLO v2...
  • yolo

    2017-05-27 20:37:00
    YOLO学习】使用YOLO v2训练自己的数据 作者:hysteric314 说明 这篇文章是训练YOLO v2过程中的经验总结,我使用YOLO v2训练一组自己的数据,训练后的model,在阈值为.25的情况下,Recall值是95.54%,...
  • YOLO系列Bounding Box方面回溯学习反思 总的来说,便是在每一种scale下每个grid cell设定一些anchor,即论文里说的bounding box先验,然后根据预测出的关于坐标的值来进行微调,微调包括平移和缩放,一般取与GT的IoU...
  • Yolo

    2019-03-10 15:05:20
    yolo 思想 什么是目标检测 找出图片中物体的bounding box(边界框),并判定框内物体的类别。边界框可以用左上角坐标(x,y)和矩形的宽高(w,h)来表示。 目标检测如何做? 一个很自然的想法是,把图片喂给深度...
  • YOLO系列之yolo v1

    万次阅读 多人点赞 2018-09-10 13:17:48
    yolo v1发表在CVPR2016上,是经典的one-stage检测算法。 论文标题: 《You Only Look Once: Unified, Real-Time Object Detection》 论文地址:https://arxiv.org/pdf/1506.02640.pdf v1是yolo系列的开山之作...
  • 对于我们使用yolo做一下research中的其他应用而言,最终目的肯定不是看看预测boundingbox就ok了。 具体对于我而言,就需要在得到boundingbox后再找出目标的局部信息。下面简单介绍一下如何完成。 1.修改源代码 在...
  • YOLO算法(Bounding Box)目标检测

    万次阅读 多人点赞 2018-07-26 20:53:09
    )看到YOLO算法做视频物体检测的效果,也能看到很多YOLO网格的设置。github上( https://github.com/pjreddie/darknet/wiki/YOLO:-Real-Time-Object-Detection )也有一个用神经网络框架darknet实现的YOLO算法实例。...
  • yolo v2会将图片切割成若干个大小...yolo v2中的box中的数据并不是平常的xmin,ymin,xmax,ymax,而是,offset_x,offset_y,w,h,分别代表的意思是:box中心x坐标在小格子的比例,box中心y坐标在小格子的比例,宽和小格...

空空如也

空空如也

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

boxyolo