这是继RCNN，fast-RCNN 和 faster-RCNN之后，rbg（Ross Girshick）大神挂名的又一大作，起了一个很娱乐化的名字：YOLO。&虽然目前版本还有一些硬伤，但是解决了目前基于DL检测中一个大痛点，就是速度问题。&其增强版本GPU中能跑45fps，简化版本155fps。
论文下载：&代码下载：
本篇博文focus到方法上。实验结果等整理全了再奉上。&1.&YOLO的核心思想
YOLO的核心思想就是利用整张图作为网络的输入，直接在输出层回归bounding box的位置和bounding box所属的类别。
没记错的话faster RCNN中也直接用整张图作为输入，但是faster-RCNN整体还是采用了RCNN那种 proposal+classifier的思想，只不过是将提取proposal的步骤放在CNN中实现了。
2.YOLO的实现方法
将一幅图像分成SxS个网格(grid cell)，如果某个object的中心 落在这个网格中，则这个网格就负责预测这个object。&
每个网格要预测B个bounding box，每个bounding box除了要回归自身的位置之外，还要附带预测一个confidence值。&这个confidence代表了所预测的box中含有object的置信度和这个box预测的有多准两重信息，其值是这样计算的：&&其中如果有object落在一个grid cell里，第一项取1，否则取0。 第二项是预测的bounding box和实际的groundtruth之间的IoU值。
每个bounding box要预测(x, y, w, h)和confidence共5个值，每个网格还要预测一个类别信息，记为C类。则SxS个网格，每个网格要预测B个bounding box还要预测C个categories。输出就是S x S x (5*B+C)的一个tensor。&注意：class信息是针对每个网格的，confidence信息是针对每个bounding box的。
举例说明:&在PASCAL VOC中，图像输入为448x448，取S=7，B=2，一共有20个类别(C=20)。则输出就是7x7x30的一个tensor。&整个网络结构如下图所示：&
在test的时候，每个网格预测的class信息和bounding box预测的confidence信息相乘，就得到每个bounding box的class-specific confidence score:&等式左边第一项就是每个网格预测的类别信息，第二三项就是每个bounding box预测的confidence。这个乘积即encode了预测的box属于某一类的概率，也有该box准确度的信息。
得到每个box的class-specific confidence score以后，设置阈值，滤掉得分低的boxes，对保留的boxes进行NMS处理，就得到最终的检测结果。
3.YOLO的实现细节
每个grid有30维，这30维中，8维是回归box的坐标，2维是box的confidence，还有20维是类别。&其中坐标的x,y用对应网格的offset归一化到0-1之间，w,h用图像的width和height归一化到0-1之间。
在实现中，最主要的就是怎么设计损失函数，让这个三个方面得到很好的平衡。作者简单粗暴的全部采用了sum-squared error loss来做这件事。&这种做法存在以下几个问题：&第一，8维的localization error和20维的classification error同等重要显然是不合理的；&第二，如果一个网格中没有object（一幅图中这种网格很多），那么就会将这些网格中的box的confidence push到0，相比于较少的有object的网格，这种做法是overpowering的，这会导致网络不稳定甚至发散。&解决办法：
更重视8维的坐标预测，给这些损失前面赋予更大的loss weight, 记为在pascal VOC训练中取5。
对没有object的box的confidence loss，赋予小的loss weight，记为在pascal VOC训练中取0.5。
有object的box的confidence loss和类别的loss的loss weight正常取1。
对不同大小的box预测中，相比于大box预测偏一点，小box预测偏一点肯定更不能被忍受的。而sum-square error loss中对同样的偏移loss是一样。&为了缓和这个问题，作者用了一个比较取巧的办法，就是将box的width和height取平方根代替原本的height和width。这个参考下面的图很容易理解，小box的横轴值较小，发生偏移时，反应到y轴上相比大box要大。&
一个网格预测多个box，希望的是每个box predictor专门负责预测某个object。具体做法就是看当前预测的box与ground truth box中哪个IoU大，就负责哪个。这种做法称作box predictor的specialization。
最后整个的损失函数如下所示：&这个损失函数中：&
只有当某个网格中有object的时候才对classification error进行惩罚。
只有当某个box predictor对某个ground truth box负责的时候，才会对box的coordinate error进行惩罚，而对哪个ground truth box负责就看其预测值和ground truth box的IoU是不是在那个cell的所有box中最大。
其他细节，例如使用激活函数使用leak RELU，模型用ImageNet预训练等等，在这里就不一一赘述了。
4.YOLO的缺点
YOLO对相互靠的很近的物体，还有很小的群体 检测效果不好，这是因为一个网格中只预测了两个框，并且只属于一类。
对图像中，同一类物体出现的新的不常见的长宽比和其他情况是泛化能力偏弱.
由于损失函数的问题，定位误差是影响检测效果的主要原因。尤其是大小物体的处理上，还有待加强。
二、YOLO9000
提出YOLO v2 ：代表着目前业界最先进物体检测的水平，它的速度要快过其他检测系统（FasterR-CNN，ResNet，SSD），使用者可以在它的速度与精确度之间进行权衡。
提出YOLO9000 ：这一网络结构可以实时地检测超过9000种物体分类，这归功于它使用了WordTree，通过WordTree来混合检测数据集与识别数据集之中的数据。
提出了一种新的联合训练算法（ Joint Training Algorithm ），使用这种联合训练技术同时在ImageNet和COCO数据集上进行训练。YOLO9000进一步缩小了监测数据集与识别数据集之间的代沟。
目前的检测数据集（Detection Datasets）有很多限制，分类标签的信息太少，图片的数量小于分类数据集（Classification Datasets），而且检测数据集的成本太高，使其无法当作分类数据集进行使用。而现在的分类数据集却有着大量的图片和十分丰富分类信息。&文章提出了一种新的训练方法–联合训练。这种算法可以把这两种的数据集混合到一起。使用一种分层的观点对物体进行分类，用巨量的分类数据集数据来扩充检测数据集，从而把两种不同的数据集混合起来。&联合训练算法的基本思路就是：同时在检测数据集和分类数据集上训练物体检测器（Object Detectors ），用监测数据集的数据学习物体的准确位置，用分类数据集的数据来增加分类的类别量、提升健壮性。&YOLO9000就是使用联合训练算法训练出来的，他拥有9000类的分类信息，这些分类信息学习自ImageNet分类数据集，而物体位置检测则学习自COCO检测数据集。
All of our code and pre-trained models are available online at&
YOLO一代有很多缺点，作者希望改进的方向是:改善recall，提升定位的准确度，同时保持分类的准确度。&目前计算机视觉的趋势是更大更深的网络，更好的性能表现通常依赖于训练更大的网络或者把多种model综合到一起。但是YOLO v2则着力于简化网络。具体的改进见下表：&
Batch Normalization
使用Batch Normalization对网络进行优化，让网络提高了收敛性，同时还消除了对其他形式的正则化（regularization）的依赖。通过对YOLO的每一个卷积层增加Batch Normalization，最终使得mAP提高了2%，同时还使model正则化。使用Batch Normalization可以从model中去掉Dropout，而不会产生过拟合。
High resolution classifier
目前业界标准的检测方法，都要先把分类器（classifier）放在ImageNet上进行预训练。从Alexnet开始，大多数的分类器都运行在小于256*256的图片上。而现在YOLO从224*224增加到了448*448，这就意味着网络需要适应新的输入分辨率。&为了适应新的分辨率，YOLO v2的分类网络以448*448的分辨率先在ImageNet上进行Fine Tune，Fine Tune10个epochs，让网络有时间调整他的滤波器（filters），好让其能更好的运行在新分辨率上，还需要调优用于检测的Resulting Network。最终通过使用高分辨率，mAP提升了4%。
Convolution with anchor boxes
YOLO一代包含有全连接层，从而能直接预测Bounding Boxes的坐标值。 Faster R-CNN的方法只用卷积层与Region Proposal Network来预测Anchor Box的偏移值与置信度，而不是直接预测坐标值。作者发现通过预测偏移量而不是坐标值能够简化问题，让神经网络学习起来更容易。&所以最终YOLO去掉了全连接层，使用Anchor Boxes来预测 Bounding Boxes。作者去掉了网络中一个Pooling层，这让卷积层的输出能有更高的分辨率。收缩网络让其运行在416*416而不是448*448。由于图片中的物体都倾向于出现在图片的中心位置，特别是那种比较大的物体，所以有一个单独位于物体中心的位置用于预测这些物体。YOLO的卷积层采用32这个值来下采样图片，所以通过选择416*416用作输入尺寸最终能输出一个13*13的Feature Map。 使用Anchor Box会让精确度稍微下降，但用了它能让YOLO能预测出大于一千个框，同时recall达到88%，mAP达到69.2%。
Dimension clusters
之前Anchor Box的尺寸是手动选择的，所以尺寸还有优化的余地。 为了优化，在训练集（training set）Bounding Boxes上跑了一下k-means聚类，来找到一个比较好的值。&如果我们用标准的欧式距离的k-means，尺寸大的框比小框产生更多的错误。因为我们的目的是提高IOU分数，这依赖于Box的大小，所以距离度量的使用：&
通过分析实验结果（Figure 2），左图：在model复杂性与high recall之间权衡之后，选择聚类分类数K=5。右图：是聚类的中心，大多数是高瘦的Box。&Table1是说明用K-means选择Anchor Boxes时，当Cluster IOU选择值为5时，AVG IOU的值是61，这个值要比不用聚类的方法的60.9要高。选择值为9的时候，AVG IOU更有显著提高。总之就是说明用聚类的方法是有效果的。
Direct location prediction
用Anchor Box的方法，会让model变得不稳定，尤其是在最开始的几次迭代的时候。大多数不稳定因素产生自预测Box的（x,y）位置的时候。按照之前YOLO的方法，网络不会预测偏移量，而是根据YOLO中的网格单元的位置来预测坐标，这就让Ground Truth的值介于0到1之间。而为了让网络的结果能落在这一范围内，网络使用一个 Logistic Activation来对于网络预测结果进行限制，让结果介于0到1之间。 网络在每一个网格单元中预测出5个Bounding Boxes，每个Bounding Boxes有五个坐标值tx，ty，tw，th，t0，他们的关系见下图（Figure3）。假设一个网格单元对于图片左上角的偏移量是cx，cy，Bounding Boxes Prior的宽度和高度是pw，ph，那么预测的结果见下图右面的公式：&
因为使用了限制让数值变得参数化，也让网络更容易学习、更稳定。&Dimension clusters和Direct location prediction，improves YOLO by almost 5% over the version with anchor boxes.
Fine-Grained Features
YOLO修改后的Feature Map大小为13*13，这个尺寸对检测图片中尺寸大物体来说足够了，同时使用这种细粒度的特征对定位小物体的位置可能也有好处。Faster F-CNN、SSD都使用不同尺寸的Feature Map来取得不同范围的分辨率，而YOLO采取了不同的方法，YOLO加上了一个Passthrough Layer来取得之前的某个26*26分辨率的层的特征。这个Passthrough layer能够把高分辨率特征与低分辨率特征联系在一起，联系起来的方法是把相邻的特征堆积在不同的Channel之中，这一方法类似与Resnet的Identity Mapping，从而把26*26*512变成13*13*2048。YOLO中的检测器位于扩展后（expanded ）的Feature Map的上方，所以他能取得细粒度的特征信息，这提升了YOLO 1%的性能。
Multi-ScaleTraining
作者希望YOLO v2能健壮的运行于不同尺寸的图片之上，所以把这一想法用于训练model中。&区别于之前的补全图片的尺寸的方法，YOLO v2每迭代几次都会改变网络参数。每10个Batch，网络会随机地选择一个新的图片尺寸，由于使用了下采样参数是32，所以不同的尺寸大小也选择为32的倍数{320，352…..608}，最小320*320，最大608*608，网络会自动改变尺寸，并继续训练的过程。&这一政策让网络在不同的输入尺寸上都能达到一个很好的预测效果，同一网络能在不同分辨率上进行检测。当输入图片尺寸比较小的时候跑的比较快，输入图片尺寸比较大的时候精度高，所以你可以在YOLO v2的速度和精度上进行权衡。&Figure4，Table 3：在voc2007上的速度与精度
Further Experiments
YOLO使用的是Googlelent，比VGG-16快，YOLO完成一次前向过程只用8.52 billion 运算，而VGG-16要30.69billion，但是YOLO精度稍低于VGG-16。
YOLO v2基于一个新的分类model，有点类似与VGG。YOLO v2使用3*3filter，每次Pooling之后都增加一倍Channels的数量。YOLO v2使用全局平均Pooling，使用Batch Normilazation来让训练更稳定，加速收敛，使model规范化。&最终的model–Darknet19，有19个卷积层和5个maxpooling层，处理一张图片只需要5.58 billion次运算，在ImageNet上达到72.9%top-1精确度，91.2%top-5精确度。
Training for classification
网络训练在 ImageNet 1000类分类数据集，训练了160epochs，使用随机梯度下降，初始学习率为0.1， polynomial&rate decay with a power of 4, weight decay of 0.0005 and momentum of 0.9 。训练期间使用标准的数据扩大方法：随机裁剪、旋转、变换颜色（hue）、变换饱和度（saturation）， 变换曝光度（exposure shifts）。&在训练时，把整个网络在更大的448*448分辨率上Fine Turnning 10个 epoches，初始学习率设置为0.001，这种网络达到达到76.5%top-1精确度，93.3%top-5精确度。
Training for detection
网络去掉了最后一个卷积层，而加上了三个3*3卷积层，每个卷积层有1024个Filters，每个卷积层紧接着一个1*1卷积层， with&the number of outputs we need for detection。&对于VOC数据，网络预测出每个网格单元预测五个Bounding Boxes，每个Bounding Boxes预测5个坐标和20类，所以一共125个Filters，增加了Passthough层来获取前面层的细粒度信息，网络训练了160epoches，初始学习率0.001，dividing it by 10 at 60 and 90 epochs，a weight decay of 0.0005 and momentum of 0.9，数据扩大方法相同，对COCO与VOC数据集的训练对策相同。
在训练的过程中，当网络遇到一个来自检测数据集的图片与标记信息，那么就把这些数据用完整的YOLO v2 loss功能反向传播这个图片。当网络遇到一个来自分类数据集的图片和分类标记信息，只用整个结构中分类部分的loss功能反向传播这个图片。&但是检测数据集只有粗粒度的标记信息，像“猫“、“ 狗”之类，而分类数据集的标签信息则更细粒度，更丰富。比如狗这一类就包括”哈士奇“”牛头梗“”金毛狗“等等。所以如果想同时在监测数据集与分类数据集上进行训练，那么就要用一种一致性的方法融合这些标签信息。&再者，用于分类的方法，大多是用softmax layer方法，softmax意味着分类的类别之间要互相独立的。而盲目地混合数据集训练，就会出现比如：检测数据集的分类信息中”狗“这一分类，在分类数据集合中，就会有的不同种类的狗”哈士奇“”牛头梗“”金毛“这些分类，这两种数据集之间的分类信息不相互独立。所以使用一种多标签的model来混合数据集，假设一个图片可以有多个分类信息，并假定分类信息必须是相互独立的规则可以被忽略。
Hierarchical classification
WordNet的结构是一个直接图表（directed graph），而不是树型结构。因为语言是复杂的，狗这个词既属于‘犬科’又属于‘家畜’两类，而‘犬科’和‘家畜’两类在wordnet中则是同义词，所以不能用树形结构。&作者希望根据ImageNet中包含的概念来建立一个分层树，为了建立这个分层树，首先检查ImagenNet中出现的名词，再在WordNet中找到这些名词，再找到这些名词到达他们根节点的路径（在这里设为所有的根节点为实体对象（physical object））。在WordNet中，大多数同义词只有一个路径，所以首先把这条路径中的词全部都加到分层树中。接着迭代地检查剩下的名词，并尽可能少的把他们添加到分层树上，添加的原则是取最短路径加入到树中。&为了计算某一结点的绝对概率，只需要对这一结点到根节点的整条路径的所有概率进行相乘。所以比如你想知道一个图片是否是Norfolk terrier的概率，则进行如下计算：&
为了验证这一个方法，在WordTree上训练Darknet19的model，使用1000类的ImageNet进行训练，为了建立WordtTree 1K，把所有中间词汇加入到WordTree上，把标签空间从1000扩大到了1369。在训练过程中，如果有一个图片的标签是”Norfolk terrier“，那么这个图片还会获得”狗“（dog）以及“哺乳动物”（mammal）等标签。总之现在一张图片是多标记的，标记之间不需要相互独立。&如Figure5所示，之前的ImageNet分类是使用一个大softmax进行分类。而现在，WordTree只需要对同一概念下的同义词进行softmax分类。&使用相同的训练参数，这种分层结构的Darknet19达到71.9%top-1精度和90.4%top-5精确度，精度只有微小的下降。&这种方法的好处：在对未知或者新的物体进行分类时，性能降低的很优雅（gracefully）。比如看到一个狗的照片，但不知道是哪种种类的狗，那么就高置信度（confidence）预测是”狗“，而其他狗的种类的同义词如”哈士奇“”牛头梗“”金毛“等这些则低置信度。&
Datasets combination with wordtree
用WordTree 把数据集合中的类别映射到分层树中的同义词上，例如上图Figure 6，WordTree混合ImageNet与COCO。
Joint classification and detection
作者的目的是：训练一个Extremely Large Scale检测器。所以训练的时候使用WordTree混合了COCO检测数据集与ImageNet中的Top9000类，混合后的数据集对应的WordTree有9418个类。另一方面，由于ImageNet数据集太大了，作者为了平衡一下两个数据集之间的数据量，通过过采样（oversampling）COCO数据集中的数据，使COCO数据集与ImageNet数据集之间的数据量比例达到1：4。&YOLO9000的训练基于YOLO v2的构架，但是使用3priors而不是5来限制输出的大小。当网络遇到检测数据集中的图片时则正常地反方向传播，当遇到分类数据集图片的时候，只使用分类的loss功能进行反向传播。同时作者假设IOU最少为 .3。最后根据这些假设进行反向传播。
使用联合训练法，YOLO9000使用COCO检测数据集学习检测图片中的物体的位置，使用ImageNet分类数据集学习如何从大量的类别中进行分类。&为了评估这一方法，使用ImageNet Detection Task对训练结果进行评估。&评估结果：&YOLO9000取得19.7mAP。&在未学习过的156个分类数据上进行，mAP达到16.0。&YOLO9000的mAP比DPM高，而且YOLO有更多先进的特征，YOLO9000是用部分监督的方式在不同训练集上进行训练，同时还能检测9000个物体类别，并保证实时运行。
虽然YOLO9000对动物的识别性能很好，但是对类别为”sungalsses“或者”swimming trunks“这些衣服或者装备的类别，它的识别性能不是很好，见table 7。这跟数据集的数据组成有很大关系。&
YOLO v2 代表着目前最先进物体检测的水平，在多种监测数据集中都要快过其他检测系统，并可以在速度与精确度上进行权衡。
YOLO 9000 的网络结构允许实时地检测超过9000种物体分类，这归功于它能同时优化检测与分类功能。使用WordTree来混合来自不同的资源的训练数据，并使用联合优化技术同时在ImageNet和COCO数据集上进行训练，YOLO9000进一步缩小了监测数据集与识别数据集之间的大小代沟。
文章还提出了WordTree，数据集混合训练，多尺寸训练等全新的训练方法。
阅读(...) 评论()yolo 是怎样通过划分的网格得到预测框?_ansys吧_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：54,035贴子：
yolo 是怎样通过划分的网格得到预测框?收藏
一楼喂百度。
登录百度帐号推荐应用
为兴趣而生，贴吧更懂你。或1387人阅读
YOLO源码详解（7）
本系列作者：木凌
时间：2016年12月。
文章连接：
一直不知道7×7的网格到底是干什么的，不就是结果预测7×7×2个框吗，这跟把原图分成7×7有什么关系？不分成7×7就不能预测7×7×2个框吗？
之前跟一个朋友讨论，他说7×7的网格是作为回归框的初始位置，我后来的很长一段时间一直这么认为，后来想想不对啊，bbox的初始位置不是根据各层的权重得到的吗？各层权重是随机初始化的，7×7的grid怎么能作为bbox的初始位置？我脑子被驴踢了么，竟然一直这么认为。
看了源码之后又看了faster-rcnn的论文中关于rpn的介绍，又看了rpn的代码，然后豁然开朗，我们来分析一下
首先你应该看完，之后问题就简单了，只有一句话：grid和anchor的唯一作用就是为了计算IOU，从而来确定正负样本。在YOLO中，计算完IOU后确定loss function中的1obji,1objij,λcoord,λnocoord的值。
二、PRN的anchors
YOLO中的理解了，我们再来看一下PRN中的anchors，如下图所示：
假设原始图像尺寸是，最左边的一层就是VGG的第5层卷积层，下一层是rpn_conv/3*3层，千万不要被他迷惑了，说是rpn_conv/3×3其实还是普通的卷积层，也就是说这里跟普通的卷积层没有任何区别，这里的输出是64×39×512，在这里，每个feature map一共有64×39个点，这里每个点对应到原始图像上是16×16的区域（注意这里并不是感受野），16×16怎么算出来的呢？ceil(1000/64)×ceil(600/39)，为什么向上取整呢？因为有padding啊～
假设每个点要搞到9个anchors，也就是原始图像上每隔16×16的区域就搞9个网格，因为这9个网格大小不一样，就取名叫anchors，这里是不是跟YOLO一样了？只不过YOLO整副图就搞了7×7个网格。到这里是不是豁然开朗了，两种算法有异曲同工之妙。
继续往下走，rpn_cls_score层，这里输出39×64×18，每个位置有9个anchors，预测每个anchor是否是物体，所以是2×9=18，继续到了rpn-data层（就是AnchorTargetLayer层，层的结构如下prototxt），这一层就是要算IOU的，也就是体现了：grid和anchor的唯一作用就是为了计算IOU，从而来确定正负样本。你理解了吗？
name: 'rpn-data'
type: 'Python'
bottom: 'rpn_cls_score'
bottom: 'gt_boxes'
bottom: 'im_info'
bottom: 'data'
top: 'rpn_labels'
top: 'rpn_bbox_targets'
top: 'rpn_bbox_inside_weights'
top: 'rpn_bbox_outside_weights'
python_param {
module: 'rpn.anchor_target_layer'
layer: 'AnchorTargetLayer'
param_str: "'feat_stride': 16"
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：42114次
排名：千里之外
原创：30篇
评论：99条
阅读：23126
(3)(1)(1)(8)(14)(7)(1)(4)3528人阅读
目标检测（4）
前面介绍了论文的思想与模型，以及使用darknet实践，接下来让我们深入到源码。
首先追踪主函数。主函数开始解析命令行参数，然后根据不同的命令行参数进入不同的调用方法。接下来我们以YOLO为主线，进行追踪与分析。
int main(int argc, char **argv)
if(argc & 2){
fprintf(stderr, "usage: %s &function&\n", argv[0]);
gpu_index = find_int_arg(argc, argv, "-i", 0);
if(find_arg(argc, argv, "-nogpu")) {
gpu_index = -1;
#ifndef GPU
gpu_index = -1;
if(gpu_index &= 0){
cudaError_t status = cudaSetDevice(gpu_index);
check_error(status);
if(0==strcmp(argv[1], "imagenet")){
run_imagenet(argc, argv);
} else if (0 == strcmp(argv[1], "average")){
average(argc, argv);
} else if (0 == strcmp(argv[1], "yolo")){
run_yolo(argc, argv);
} else if (0 == strcmp(argv[1], "cifar")){
run_cifar(argc, argv);
} else if (0 == strcmp(argv[1], "go")){
run_go(argc, argv);
} else if (0 == strcmp(argv[1], "rnn")){
run_char_rnn(argc, argv);
} else if (0 == strcmp(argv[1], "vid")){
run_vid_rnn(argc, argv);
} else if (0 == strcmp(argv[1], "coco")){
run_coco(argc, argv);
} else if (0 == strcmp(argv[1], "classifier")){
run_classifier(argc, argv);
} else if (0 == strcmp(argv[1], "art")){
run_art(argc, argv);
} else if (0 == strcmp(argv[1], "tag")){
run_tag(argc, argv);
} else if (0 == strcmp(argv[1], "compare")){
run_compare(argc, argv);
} else if (0 == strcmp(argv[1], "dice")){
run_dice(argc, argv);
} else if (0 == strcmp(argv[1], "writing")){
run_writing(argc, argv);
} else if (0 == strcmp(argv[1], "3d")){
composite_3d(argv[2], argv[3], argv[4]);
} else if (0 == strcmp(argv[1], "test")){
test_resize(argv[2]);
} else if (0 == strcmp(argv[1], "captcha")){
run_captcha(argc, argv);
} else if (0 == strcmp(argv[1], "nightmare")){
run_nightmare(argc, argv);
} else if (0 == strcmp(argv[1], "change")){
change_rate(argv[2], atof(argv[3]), (argc & 4) ? atof(argv[4]) : 0);
} else if (0 == strcmp(argv[1], "rgbgr")){
rgbgr_net(argv[2], argv[3], argv[4]);
} else if (0 == strcmp(argv[1], "denormalize")){
denormalize_net(argv[2], argv[3], argv[4]);
} else if (0 == strcmp(argv[1], "normalize")){
normalize_net(argv[2], argv[3], argv[4]);
} else if (0 == strcmp(argv[1], "rescale")){
rescale_net(argv[2], argv[3], argv[4]);
} else if (0 == strcmp(argv[1], "partial")){
partial(argv[2], argv[3], argv[4], atoi(argv[5]));
} else if (0 == strcmp(argv[1], "stacked")){
stacked(argv[2], argv[3], argv[4]);
} else if (0 == strcmp(argv[1], "visualize")){
visualize(argv[2], (argc & 3) ? argv[3] : 0);
} else if (0 == strcmp(argv[1], "imtest")){
test_resize(argv[2]);
fprintf(stderr, "Not an option: %s\n", argv[1]);
接下来分析yolo.c文件，该文件主要是使用darknet 实现YOLO论文的思想。
run_yolo(int argc, char **argv)
该函数是yolo.c文件的主函数。
char *voc_names[] = {"aeroplane", "bicycle", "bird", "boat", "bottle", "bus", "car", "cat", "chair", "cow", "diningtable", "dog", "horse", "motorbike", "person", "pottedplant", "sheep", "sofa", "train", "tvmonitor"};
void run_yolo(int argc, char **argv)
for(i = 0; i & 20; ++i){
char buff[256];
sprintf(buff, "data/labels/%s.png", voc_names[i]);
voc_labels[i] = load_image_color(buff, 0, 0);
float thresh = find_float_arg(argc, argv, "-thresh", .2);
int cam_index = find_int_arg(argc, argv, "-c", 0);
if(argc & 4){
fprintf(stderr, "usage: %s %s [train/test/valid] [cfg] [weights (optional)]\n", argv[0], argv[1]);
char *cfg = argv[3];
char *weights = (argc & 4) ? argv[4] : 0;
char *filename = (argc & 5) ? argv[5]: 0;
if(0==strcmp(argv[2], "test")) test_yolo(cfg, weights, filename, thresh);
else if(0==strcmp(argv[2], "train")) train_yolo(cfg, weights);
else if(0==strcmp(argv[2], "valid")) validate_yolo(cfg, weights);
else if(0==strcmp(argv[2], "recall")) validate_yolo_recall(cfg, weights);
else if(0==strcmp(argv[2], "demo")) demo_yolo(cfg, weights, thresh, cam_index, filename);
test_yolo(char *cfgfile, char *weightfile, char *filename, float thresh)
该函数主要
void test_yolo(char *cfgfile, char *weightfile, char *filename, float thresh)
network net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights(&net, weightfile);
detection_layer l = net.layers[net.n-1];
set_batch_network(&net, 1);
srand(2222222);
char buff[256];
char *input =
float nms=.5;
bounding_box *boxes = calloc(l.side*l.side*l.n, sizeof(bounding_box));
float **probs = calloc(l.side*l.side*l.n, sizeof(float *));
for(j = 0; j & l.side*l.side*l.n; ++j) probs[j] = calloc(l.classes, sizeof(float *));
if(filename){
strncpy(input, filename, 256);
printf("Enter Image Path: ");
fflush(stdout);
input = fgets(input, 256, stdin);
if(!input) return;
strtok(input, "\n");
image im = load_image_color(input,0,0);
image sized = resize_image(im, net.w, net.h);
float *X = sized.
time=clock();
float *predictions = network_predict(net, X);
printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time));
convert_yolo_detections(predictions, l.classes, l.n, l.sqrt, l.side, 1, 1, thresh, probs, boxes, 0);
if (nms) do_nms_sort(boxes, probs, l.side*l.side*l.n, l.classes, nms);
draw_detections(im, l.side*l.side*l.n, thresh, boxes, probs, voc_names, voc_labels, 20);
show_image(im, "predictions");
save_image(im, "predictions");
show_image(sized, "resized");
free_image(im);
free_image(sized);
#ifdef OPENCV
cvWaitKey(0);
cvDestroyAllWindows();
if (filename) break;
yolo_demo.c文件主要实现yolo处理视频文件。
demo_yolo(char *cfgfile, char *weightfile, float thresh, int cam_index, char *filename)
demo_yolo函数是演示通过摄像头去做目标检测。
void demo_yolo(char *cfgfile, char *weightfile, float thresh, int cam_index, char *filename)
demo_thresh =
printf("YOLO demo\n");
net = parse_network_cfg(cfgfile);
if(weightfile){
load_weights(&net, weightfile);
set_batch_network(&net, 1);
srand(2222222);
if(filename){
cap = cvCaptureFromFile(filename);
cap = cvCaptureFromCAM(cam_index);
if(!cap) error("Couldn't connect to webcam.\n");
cvNamedWindow("YOLO", CV_WINDOW_NORMAL);
cvResizeWindow("YOLO", 512, 512);
detection_layer l = net.layers[net.n-1];
boxes = (box *)calloc(l.side*l.side*l.n, sizeof(box));
probs = (float **)calloc(l.side*l.side*l.n, sizeof(float *));
for(j = 0; j & l.side*l.side*l.n; ++j) probs[j] = (float *)calloc(l.classes, sizeof(float *));
pthread_t fetch_
pthread_t detect_
fetch_in_thread(0);
det_s = in_s;
fetch_in_thread(0);
detect_in_thread(0);
det_s = in_s;
struct timeval tval_before, tval_after, tval_
gettimeofday(&tval_before, NULL);
if(pthread_create(&fetch_thread, 0, fetch_in_thread, 0)) error("Thread creation failed");
if(pthread_create(&detect_thread, 0, detect_in_thread, 0)) error("Thread creation failed");
show_image(disp, "YOLO");
free_image(disp);
cvWaitKey(1);
pthread_join(fetch_thread, 0);
pthread_join(detect_thread, 0);
det_s = in_s;
gettimeofday(&tval_after, NULL);
timersub(&tval_after, &tval_before, &tval_result);
float curr = 1000000.f/((long int)tval_result.tv_usec);
fps = .9*fps + .1*
fetch_in_thread(void *ptr)
void *fetch_in_thread(void *ptr)
in = get_image_from_stream(cap);
in_s = resize_image(in, net.w, net.h);
detect_in_thread(void *ptr)
void *detect_in_thread(void *ptr)
float nms = .4;
detection_layer l = net.layers[net.n-1];
float *X = det_s.
float *predictions = network_predict(net, X);
free_image(det_s);
convert_yolo_detections(predictions, l.classes, l.n, l.sqrt, l.side, 1, 1, demo_thresh, probs, boxes, 0);
if (nms & 0) do_nms(boxes, probs, l.side*l.side*l.n, l.classes, nms);
printf("\033[2J");
printf("\033[1;1H");
printf("\nFPS:%.0f\n",fps);
printf("Objects:\n\n");
draw_detections(det, l.side*l.side*l.n, demo_thresh, boxes, probs, voc_names, voc_labels, 20);
image.c文件主要处理图像相关的工作。
get_image_from_stream(CvCapture *cap)
get_image_from_stream函数主要完成从视频内抽帧的工作。
image get_image_from_stream(CvCapture *cap)
IplImage* src = cvQueryFrame(cap);
image im = ipl_to_image(src);
rgbgr_image(im);
resize_image(image im, int w, int h)
image resize_image(image im, int w, int h)
image resized = make_image(w, h, im.c);
image part = make_image(w, im.h, im.c);
float w_scale = (float)(im.w - 1) / (w - 1);
float h_scale = (float)(im.h - 1) / (h - 1);
for(k = 0; k & im.c; ++k){
for(r = 0; r & im.h; ++r){
for(c = 0; c & ++c){
float val = 0;
if(c == w-1 || im.w == 1){
val = get_pixel(im, im.w-1, r, k);
float sx = c*w_
int ix = (int)
float dx = sx -
val = (1 - dx) * get_pixel(im, ix, r, k) + dx * get_pixel(im, ix+1, r, k);
set_pixel(part, c, r, k, val);
for(k = 0; k & im.c; ++k){
for(r = 0; r & ++r){
float sy = r*h_
int iy = (int)
float dy = sy -
for(c = 0; c & ++c){
float val = (1-dy) * get_pixel(part, c, iy, k);
set_pixel(resized, c, r, k, val);
if(r == h-1 || im.h == 1) continue;
for(c = 0; c & ++c){
float val = dy * get_pixel(part, c, iy+1, k);
add_pixel(resized, c, r, k, val);
free_image(part);
重要数据结构定义
typedef struct network{
learning_rate_
float learning_
#ifdef GPU
float **input_
float **truth_
struct layer{
LAYER_TYPE
ACTIVATION
COST_TYPE cost_
int batch_
int h,w,c;
int out_h, out_w, out_c;
float coord_
float object_
float noobject_
float class_
float *filter_
float *state_
float *concat_
float *binary_
float *bias_
float *scale_
float *weight_
float *col_
float * spatial_
float * mean_
float * variance_
float * rolling_
float * rolling_
float * x_
struct layer *input_
struct layer *self_
struct layer *output_
struct layer *input_gate_
struct layer *state_gate_
struct layer *input_save_
struct layer *state_save_
struct layer *input_state_
struct layer *state_state_
struct layer *input_z_
struct layer *state_z_
struct layer *input_r_
struct layer *state_r_
struct layer *input_h_
struct layer *state_h_
size_t workspace_
#ifdef GPU
int *indexes_
float * prev_state_
float * forgot_state_
float * forgot_delta_
float * state_
float * state_delta_
float * gate_
float * gate_delta_
float * save_
float * save_delta_
float * concat_
float * concat_delta_
float * filters_
float * filter_updates_
float *binary_input_
float *binary_filters_
float * mean_
float * variance_
float * rolling_mean_
float * rolling_variance_
float * variance_delta_
float * mean_delta_
float * col_image_
float * x_
float * x_norm_
float * weights_
float * weight_updates_
float * biases_
float * bias_updates_
float * scales_
float * scale_updates_
float * output_
float * delta_
float * rand_
float * squared_
float * norms_
#ifdef CUDNN
cudnnTensorDescriptor_t srcTensorDesc, dstTensorD
cudnnTensorDescriptor_t dsrcTensorDesc, ddstTensorD
cudnnFilterDescriptor_t filterD
cudnnFilterDescriptor_t dfilterD
cudnnConvolutionDescriptor_t convD
cudnnConvolutionFwdAlgo_t fw_
cudnnConvolutionBwdDataAlgo_t bd_
cudnnConvolutionBwdFilterAlgo_t bf_
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：17043次
排名：千里之外
原创：15篇
评论：11条