【AI全栈二】视频流多目标多类别无延迟高精度高召回目标追踪 YOLO+Deepsort 全解

首先介绍跟踪：

目标跟踪又分为单目标跟踪和多目标跟踪

单目标跟踪在视频的初始帧画面上框出单个目标，预测后续帧中该目标的大小与位置。典型算法有 Mean shift（用卡尔曼滤波、粒子滤波进行状态预测）、TLD（基于在线学习的跟踪）、KCF（基于相关性滤波）等。

像 Opencv 等库内置了许多跟踪算法，KCF 是一种很经典的单目标跟踪算法，速度不是很快，但是精度不错，但是他也

多目标追踪不像单目标追踪一样先在初始帧上框出单个目标，而是追踪多个目标的大小和位置，且每一帧中目标的数量和位置都可能变化。此外，多目标的追踪中还存在下列问题:

处理新目标的出现和老目标的消失；

跟踪目标的运动预测和相似度判别，即上一帧与下一帧目标的匹配；

跟踪目标之间的重叠和遮挡处理；

跟踪目标丢失一段时间后再重新出现的再识别。

针对这样的情况，有哪些解决方法呢？下面来综合叙述。

浅析 SORT

SORT 部分原理：

在跟踪之前，对所有目标已经完成检测，实现了特征建模过程。1 第一帧进来时，以检测到的目标初始化并创建新的跟踪器，标注 id。2 后面帧进来时，先到卡尔曼滤波器中得到由前面帧 box 产生的状态预测和协方差预测。求跟踪器所有目标状态预测与本帧检测的 box 的 IOU，通过匈牙利指派算法得到 IOU 最大的唯一匹配（数据关联部分），再去掉匹配值小于 iou_threshold 的匹配对。3 用本帧中匹配到的目标检测 box 去更新卡尔曼跟踪器，计算卡尔曼增益、状态更新和协方差更新，并将状态更新值输出，作为本帧的跟踪 box。对于本帧中没有匹配到的目标重新初始化跟踪器。

其中，卡尔曼跟踪器联合了历史跟踪记录，调节历史 box 与本帧 box 的残差，更好的匹配跟踪 id。

SORT 的贡献主要有三：
利用强大的 CNN 检测器的检测结果来进行多目标跟踪

使用基于卡尔曼滤波（Kalman filter）与匈牙利算法（Hungarian algorithm）的方法来进行跟踪

开源了代码，为 MOT 领域提供一个新的 baseline

SORT 将这种二阶段匹配算法改进为了一阶段方法，并且可以在线跟踪。

具体而言，SORT 引入了线性速度模型与卡尔曼滤波来进行位置预测，在无合适匹配检测框的情况下，使用运动模型来预测物体的位置。

SORT 代码实现+解读：

from __future__ import print_function
 
from numba import jit      #是python的一个JIT库，通过装饰器来实现运行时的加速
import os.path
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as patches  #用于绘制常见图像（如矩形，椭圆，圆形，多边形）
from skimage import io
from sklearn.utils.linear_assignment_ import linear_assignment
import glob
import time
import argparse
from filterpy.kalman import KalmanFilter  #filterpy包含了一些常用滤波器的库
 
@jit  #用了jit装饰器，可加速for循环的计算
def iou(bb_test,bb_gt):
  """
  Computes IOU between two bboxes in the form [x1,y1,x2,y2]
  """
  xx1 = np.maximum(bb_test[0], bb_gt[0])
  yy1 = np.maximum(bb_test[1], bb_gt[1])
  xx2 = np.minimum(bb_test[2], bb_gt[2])
  yy2 = np.minimum(bb_test[3], bb_gt[3])
  w = np.maximum(0., xx2 - xx1)
  h = np.maximum(0., yy2 - yy1)
  wh = w * h
  o = wh / ((bb_test[2]-bb_test[0])*(bb_test[3]-bb_test[1])   #IOU=（bb_test和bb_gt框相交部分面积）/(bb_test框面积+bb_gt框面积 - 两者相交面积)
    + (bb_gt[2]-bb_gt[0])*(bb_gt[3]-bb_gt[1]) - wh)
  return(o)
 
def convert_bbox_to_z(bbox): #将bbox由[x1,y1,x2,y2]形式转为 [框中心点x,框中心点y,框面积s,宽高比例r]^T
  """
  Takes a bounding box in the form [x1,y1,x2,y2] and returns z in the form
    [x,y,s,r] where x,y is the centre of the box and s is the scale/area and r is
    the aspect ratio
  """
  w = bbox[2]-bbox[0]
  h = bbox[3]-bbox[1]
  x = bbox[0]+w/2.
  y = bbox[1]+h/2.
  s = w*h    #scale is just area
  r = w/float(h)
  return np.array([x,y,s,r]).reshape((4,1))  #将数组转为4行一列形式，即[x,y,s,r]^T
 
def convert_x_to_bbox(x,score=None): #将[x,y,s,r]形式的bbox，转为[x1,y1,x2,y2]形式
  """
  Takes a bounding box in the centre form [x,y,s,r] and returns it in the form
    [x1,y1,x2,y2] where x1,y1 is the top left and x2,y2 is the bottom right
  """
  w = np.sqrt(x[2]*x[3])  #w=sqrt(w*h * w/h)
  h = x[2]/w              #h=w*h/w
  if(score==None): #如果检测框不带置信度
    return np.array([x[0]-w/2.,x[1]-h/2.,x[0]+w/2.,x[1]+h/2.]).reshape((1,4))  #返回[x1,y1,x2,y2]
  else:            #如果加测框带置信度
    return np.array([x[0]-w/2.,x[1]-h/2.,x[0]+w/2.,x[1]+h/2.,score]).reshape((1,5)) #返回[x1,y1,x2,y2,score]
 
 
class KalmanBoxTracker(object):
  """
  This class represents the internel state of individual tracked objects observed as bbox.
  """
  count = 0
  def __init__(self,bbox):
    """
    Initialises a tracker using initial bounding box.  使用初始边界框初始化跟踪器
    """
    #define constant velocity model                #定义匀速模型
    self.kf = KalmanFilter(dim_x=7, dim_z=4)       #状态变量是7维， 观测值是4维的，按照需要的维度构建目标
    self.kf.F = np.array([[1,0,0,0,1,0,0],[0,1,0,0,0,1,0],[0,0,1,0,0,0,1],[0,0,0,1,0,0,0],[0,0,0,0,1,0,0],[0,0,0,0,0,1,0],[0,0,0,0,0,0,1]])
    self.kf.H = np.array([[1,0,0,0,0,0,0],[0,1,0,0,0,0,0],[0,0,1,0,0,0,0],[0,0,0,1,0,0,0]])
 
    self.kf.R[2:,2:] *= 10.
    self.kf.P[4:,4:] *= 1000. #give high uncertainty to the unobservable initial velocities 对未观测到的初始速度给出高的不确定性
    self.kf.P *= 10.          # 默认定义的协方差矩阵是np.eye(dim_x)，将P中的数值与10， 1000相乘，赋值不确定性
    self.kf.Q[-1,-1] *= 0.01
    self.kf.Q[4:,4:] *= 0.01
 
    self.kf.x[:4] = convert_bbox_to_z(bbox)  #将bbox转为 [x,y,s,r]^T形式，赋给状态变量X的前4位
    self.time_since_update = 0
    self.id = KalmanBoxTracker.count
    KalmanBoxTracker.count += 1
    self.history = []
    self.hits = 0
    self.hit_streak = 0
    self.age = 0
 
  def update(self,bbox):
    """
    Updates the state vector with observed bbox.
    """
    self.time_since_update = 0
    self.history = []
    self.hits += 1
    self.hit_streak += 1
    self.kf.update(convert_bbox_to_z(bbox))
 
  def predict(self):
    """
    Advances the state vector and returns the predicted bounding box estimate.
    """
    if((self.kf.x[6]+self.kf.x[2])<=0):
      self.kf.x[6] *= 0.0
    self.kf.predict()
    self.age += 1
    if(self.time_since_update>0):
      self.hit_streak = 0
    self.time_since_update += 1
    self.history.append(convert_x_to_bbox(self.kf.x))
    return self.history[-1]
 
  def get_state(self):
    """
    Returns the current bounding box estimate.
    """
    return convert_x_to_bbox(self.kf.x)
 
def associate_detections_to_trackers(detections,trackers,iou_threshold = 0.3):  #用于将检测与跟踪进行关联
  """
  Assigns detections to tracked object (both represented as bounding boxes)
  Returns 3 lists of matches, unmatched_detections and unmatched_trackers
  """
  if(len(trackers)==0):  #如果跟踪器为空
    return np.empty((0,2),dtype=int), np.arange(len(detections)), np.empty((0,5),dtype=int)
  iou_matrix = np.zeros((len(detections),len(trackers)),dtype=np.float32) # 检测器与跟踪器IOU矩阵
 
  for d,det in enumerate(detections):
    for t,trk in enumerate(trackers):
      iou_matrix[d,t] = iou(det,trk)   #计算检测器与跟踪器的IOU并赋值给IOU矩阵对应位置
  matched_indices = linear_assignment(-iou_matrix)    # 参考：https://blog.csdn.net/herr_kun/article/details/86509591    加上负号是因为linear_assignment求的是最小代价组合，而我们需要的是IOU最大的组合方式，所以取负号
 
  unmatched_detections = []    #未匹配上的检测器
  for d,det in enumerate(detections):
    if(d not in matched_indices[:,0]):  #如果检测器中第d个检测结果不在匹配结果索引中，则d未匹配上
      unmatched_detections.append(d)
  unmatched_trackers = []      #未匹配上的跟踪器
  for t,trk in enumerate(trackers):
    if(t not in matched_indices[:,1]):  #如果跟踪器中第t个跟踪结果不在匹配结果索引中，则t未匹配上
      unmatched_trackers.append(t)
 
  #filter out matched with low IOU   过滤掉那些IOU较小的匹配对
  matches = []  #存放过滤后的匹配结果
  for m in matched_indices:   #遍历粗匹配结果
    if(iou_matrix[m[0],m[1]]<iou_threshold):   #m[0]是检测器ID， m[1]是跟踪器ID，如它们的IOU小于阈值则将它们视为未匹配成功
      unmatched_detections.append(m[0])
      unmatched_trackers.append(m[1])
    else:
      matches.append(m.reshape(1,2))          #将过滤后的匹配对维度变形成1x2形式
  if(len(matches)==0):           #如果过滤后匹配结果为空，那么返回空的匹配结果
    matches = np.empty((0,2),dtype=int)  
  else:                          #如果过滤后匹配结果非空，则按0轴方向继续添加匹配对
    matches = np.concatenate(matches,axis=0)
 
  return matches, np.array(unmatched_detections), np.array(unmatched_trackers)  #其中跟踪器数组是5列的（最后一列是ID）
 
 
 
class Sort(object):
  def __init__(self,max_age=1,min_hits=3):
    """
    Sets key parameters for SORT
    """
    self.max_age = max_age
    self.min_hits = min_hits
    self.trackers = []
    self.frame_count = 0
 
  def update(self,dets):  #输入的是检测结果[x1,y1,x2,y2,score]形式
    """
    Params:
      dets - a numpy array of detections in the format [[x1,y1,x2,y2,score],[x1,y1,x2,y2,score],...]
    Requires: this method must be called once for each frame even with empty detections.   #每一帧都得调用一次，即便检测结果为空
    Returns the a similar array, where the last column is the object ID.                    #返回相似的数组，最后一列是目标ID
    NOTE: The number of objects returned may differ from the number of detections provided.  #返回的目标数量可能与提供的检测数量不同
    """
    self.frame_count += 1   #帧计数
    #get predicted locations from existing trackers.
    trks = np.zeros((len(self.trackers),5)) # 根据当前所有卡尔曼跟踪器的个数创建二维零矩阵，维度为：卡尔曼跟踪器ID个数x 5 (这5列内容为bbox与ID)
    to_del = []                             #存放待删除
    ret = []                                #存放最后返回的结果
    for t,trk in enumerate(trks):      #循环遍历卡尔曼跟踪器列表
      pos = self.trackers[t].predict()[0]           #用卡尔曼跟踪器t 预测 对应物体在当前帧中的bbox
      trk[:] = [pos[0], pos[1], pos[2], pos[3], 0]
      if(np.any(np.isnan(pos))):                     #如果预测的bbox为空，那么将第t个卡尔曼跟踪器删除
        to_del.append(t)
    trks = np.ma.compress_rows(np.ma.masked_invalid(trks))  #将预测为空的卡尔曼跟踪器所在行删除，最后trks中存放的是上一帧中被跟踪的所有物体在当前帧中预测的非空bbox
    for t in reversed(to_del): #对to_del数组进行倒序遍历
      self.trackers.pop(t)   #从跟踪器中删除 to_del中的上一帧跟踪器ID
    matched, unmatched_dets, unmatched_trks = associate_detections_to_trackers(dets,trks)  #对传入的检测结果 与 上一帧跟踪物体在当前帧中预测的结果做关联，返回匹配的目标矩阵matched, 新增目标的矩阵unmatched_dets, 离开画面的目标矩阵unmatched_trks
 
    #update matched trackers with assigned detections
    for t,trk in enumerate(self.trackers):    # 对卡尔曼跟踪器做遍历
      if(t not in unmatched_trks):                   #如果上一帧中的t还在当前帧画面中（即不在当前预测的离开画面的矩阵unmatched_trks中）
        d = matched[np.where(matched[:,1]==t)[0],0]  #说明卡尔曼跟踪器t是关联成功的，在matched矩阵中找到与其关联的检测器d
        trk.update(dets[d,:][0])                     #用关联的检测结果d来更新卡尔曼跟踪器（即用后验来更新先验）
 
    #create and initialise new trackers for unmatched detections  #对于新增的未匹配的检测结果，创建并初始化跟踪器
    for i in unmatched_dets:                  #新增目标
        trk = KalmanBoxTracker(dets[i,:])     #将新增的未匹配的检测结果dets[i,:]传入KalmanBoxTracker
        self.trackers.append(trk)             #将新创建和初始化的跟踪器trk 传入trackers
    i = len(self.trackers)
    for trk in reversed(self.trackers):       #对新的卡尔曼跟踪器集进行倒序遍历
        d = trk.get_state()[0]                #获取trk跟踪器的状态 [x1,y1,x2,y2]       
        if((trk.time_since_update < 1) and (trk.hit_streak >= self.min_hits or self.frame_count <= self.min_hits)):
          ret.append(np.concatenate((d,[trk.id+1])).reshape(1,-1)) # +1 as MOT benchmark requires positive
        i -= 1
        #remove dead tracklet
        if(trk.time_since_update > self.max_age):
          self.trackers.pop(i)
    if(len(ret)>0):
      return np.concatenate(ret)
    return np.empty((0,5))
    
def parse_args():
    """Parse input arguments."""
    parser = argparse.ArgumentParser(description='SORT demo')
    parser.add_argument('--display', dest='display', help='Display online tracker output (slow) [False]',action='store_true')
    args = parser.parse_args()
    return args
 
if __name__ == '__main__':
  # all train
  sequences = ['PETS09-S2L1','TUD-Campus','TUD-Stadtmitte','ETH-Bahnhof','ETH-Sunnyday','ETH-Pedcross2','KITTI-13','KITTI-17','ADL-Rundle-6','ADL-Rundle-8','Venice-2']
  args = parse_args()
  display = args.display
  phase = 'train'
  total_time = 0.0
  total_frames = 0
  colours = np.random.rand(32,3) #used only for display
  if(display):
    if not os.path.exists('mot_benchmark'):
      print('\n\tERROR: mot_benchmark link not found!\n\n    Create a symbolic link to the MOT benchmark\n    (https://motchallenge.net/data/2D_MOT_2015/#download). E.g.:\n\n    $ ln -s /path/to/MOT2015_challenge/2DMOT2015 mot_benchmark\n\n')
      exit()
    plt.ion()  #用于动态绘制显示图像
    fig = plt.figure() 
  
  if not os.path.exists('output'):
    os.makedirs('output')
  
  for seq in sequences:
    mot_tracker = Sort() #create instance of the SORT tracker    创建Sort 跟踪实例
    seq_dets = np.loadtxt('data/%s/det.txt'%(seq),delimiter=',') #load detections    #加载检测结果
    with open('output/%s.txt'%(seq),'w') as out_file:
      print("Processing %s."%(seq))
      for frame in range(int(seq_dets[:,0].max())):   #确定视频序列总帧数，并进行for循环
        frame += 1 #detection and frame numbers begin at 1  #由于视频序列帧数是从1开始的，因此加1
        dets = seq_dets[seq_dets[:,0]==frame,2:7]     #提取检测结果中的[x1,y1,w,h,score]到dets
        dets[:,2:4] += dets[:,0:2] #convert to [x1,y1,w,h] to [x1,y1,x2,y2]   将dets中的第2,3列的数加上第0,1列的数后赋值给2,3列；
        total_frames += 1          #总帧数累计
 
        if(display):        #如果要求显示结果
          ax1 = fig.add_subplot(111, aspect='equal')
          fn = 'mot_benchmark/%s/%s/img1/%06d.jpg'%(phase,seq,frame)   #原图像路径名
          im =io.imread(fn)      #加载图像
          ax1.imshow(im)         #显示图像
          plt.title(seq+' Tracked Targets')
 
        start_time = time.time()
        trackers = mot_tracker.update(dets)  #sort跟踪器更新
        cycle_time = time.time() - start_time  #sort跟踪器耗时
        total_time += cycle_time               #sort跟踪器总共耗费时间
 
        for d in trackers:
          print('%d,%d,%.2f,%.2f,%.2f,%.2f,1,-1,-1,-1'%(frame,d[4],d[0],d[1],d[2]-d[0],d[3]-d[1]),file=out_file) #打印： frame,ID,x1,y1,x2,y2,1,-1,-1,-1
          if(display):             #如果显示，将目标检测框画上
            d = d.astype(np.int32)
            ax1.add_patch(patches.Rectangle((d[0],d[1]),d[2]-d[0],d[3]-d[1],fill=False,lw=3,ec=colours[d[4]%32,:]))
            ax1.set_adjustable('box-forced')
 
        if(display):
          fig.canvas.flush_events()
          plt.draw()
          ax1.cla()
 
  print("Total Tracking took: %.3f for %d frames or %.1f FPS"%(total_time,total_frames,total_frames/total_time))
  if(display):
    print("Note: to get real runtime results run without the option: --display")

DeepSORT 深入解读

一年之后，原团队发布了 SORT 的续作 DeepSORT，到现在都有很多人在用这个跟踪器。

整体框架没有大改，还是延续了卡尔曼滤波加匈牙利算法的思路，在这个基础上增加了 Deep Association Metric。Deep Association Metric 其实就是在大型行人重识别网络上学习的一个行人鉴别网络。目的是区分出不同的行人。个人感觉很类似于典型的行人重识别网络。输出行人图片，输出一组向量，通过比对两个向量之间的距离，来判断两副输入图片是否是同一个行人。

此外还加入了外观信息（Appearance Information）以实现较长时间遮挡的目标跟踪。

跟踪流程延续上作，在卡尔曼滤波的预测结果的基础上，继续使用了匈牙利算法进行目标分配，但在这个过程中加入了运动信息和外观信息。这个说起来简单，实现起来比较复杂，感兴趣的读者可以细看论文和代码。在这里就不赘述了。

其他方面没有太多变化，还是使用了标准的卡尔曼滤波和固定速度模型等来进行预测。

最终实现了较好的跟踪效果，并且能够实时运行（40FPS）。

IOU 匹配流程图

作者代码也以检测结果为输入：bounding box、confidence、feature 。conf 主要用于进行一部分的检测框的筛选；bounding box 与 feature（ReID）用于后面与跟踪器的 match 计算；首先是预测模块，会对跟踪器使用卡尔曼滤波器进行预测。作者在这里使用的是卡尔曼滤波器的匀速运动和线性观测模型（意味着只有四个量且在初始化时会使用检测器进行恒值初始化）。其次是更新模块，其中包括匹配，追踪器更新与特征集更新。在更新模块的部分，根本的方法还是使用 IOU 来进行匈牙利算法的匹配

1.使用级联匹配算法：
针对每一个检测器都会分配一个跟踪器，每个跟踪器会设定一个 time_since_update 参数。如果跟踪器完成匹配并进行更新，那么参数会重置为 0，否则就会+1。实际上，级联匹配换句话说就是不同优先级的匹配。在级联匹配中，会根据这个参数来对跟踪器分先后顺序，参数小的先来匹配，参数大的后匹配。也就是给上一帧最先匹配的跟踪器高的优先权，给好几帧都没匹配上的跟踪器降低优先权（慢慢放弃）。至于使用级联匹配的目的，我引用一下博客②里的解释：

当一个目标长时间被遮挡之后，kalman 滤波预测的不确定性就会大大增加，状态空间内的可观察性就会大大降低。假如此时两个追踪器竞争同一个检测结果的匹配权，往往遮挡时间较长的那条轨迹的马氏距离更小，使得检测结果更可能和遮挡时间较长的那条轨迹相关联，这种不理想的效果往往会破坏追踪的持续性。这么理解吧，假设本来协方差矩阵是一个正态分布，那么连续的预测不更新就会导致这个正态分布的方差越来越大，那么离均值欧氏距离远的点可能和之前分布中离得较近的点获得同样的马氏距离值。所以，作者使用了级联匹配来对更加频繁出现的目标赋予优先权。当然同样也有弊端：可能导致一些新产生的轨迹被连接到了一些旧的轨迹上。但这种情况较少。

2.添加马氏距离与余弦距离：
实际上是针对运动信息与外观信息的计算。两个名词听着较为陌生，而实际上换句话解释，马氏距离就是“加强版的欧氏距离”。它实际上是规避了欧氏距离中对于数据特征方差不同的风险，在计算中添加了协方差矩阵，其目的就是进行方差归一化，从而使所谓的“距离”更加符合数据特征以及实际意义。马氏距离是对于差异度的衡量中，的一种距离度量方式，而不同于马氏距离，余弦距离则是一种相似度度量方式。前者是针对于位置进行区分，而后者则是针对于方向。换句话说，我们使用余弦距离的时候，可以用来衡量不同个体在维度之间的差异，而一个个体中，维度与维度的差异我们却不好判断，此时我们可以使用马氏距离进行弥补，从而在整体上可以达到一个相对于全面的差异性衡量。而我们之所以要进行差异性衡量，根本目的也是想比较检测器与跟踪器的相似程度，优化度量方式，也可以更好地完成匹配。

3.添加深度学习特征：
这一部分也就是 ReID 的模块，也是 deepsort 的亮点之一。deepsort 在对于 sort 的改进中加入了一个深度学习的特征提取网络，网络结构部分各位看官可以移步论文。作者将所有 confirmed 的追踪器（其中一个状态）每次完成匹配对应的 detection 的 feature map 存储进一个 list。存储的数量作者使用 budget 超参数（100 帧）进行限制（我认为如果实时性效果不好的话，可以调低这个参数加快速度）。从而我们在每次匹配之后都会更新这个 feature map 的 list，比如去除掉一些已经出镜头的目标的特征集，保留最新的特征将老的特征 pop 掉等等。这个特征集在进行余弦距离计算的时候将会发挥作用。实际上，在当前帧，会计算第 i 个物体跟踪的所有 Feature 向量和第 j 个物体检测之间的最小余弦距离。

4.IOU 与匈牙利算法匹配：
这个方法是在 sort 中被提出的。又是比较陌生的名词，我接着“换句话说”。实际上匈牙利算法可以理解成“尽量多”的一种思路，比如说 A 检测器可以和 a，c 跟踪器完成匹配（与 a 匹配置信度更高），但是 B 检测器只能和 a 跟踪器完成匹配。那在算法中，就会让 A 与 c 完成匹配，B 与 a 完成匹配，而降低对于置信度的考虑。所以算法的根本目的并不是在于匹配的准不准，而是在于尽量多的匹配上，这也就是在 deepsort 中作者添加级联匹配与马氏距离与余弦距离的根本目的，因为仅仅使用匈牙利算法进行匹配特别容易造成 ID switch，就是一个检测框 id 不停地进行更换，缺乏准确性与鲁棒性。那什么是匹配的置信度高呢，其实在这里，作者使用的是 IOU 进行衡量，计算检测器与跟踪器的 IOU，将这个作为置信度的高低（比较粗糙）。

还有一些超参数，我也已经在代码流程的部分明确讲解了，这些超参数或进行阈值的作用，或进行循环次数的限定，不断帮助算法完成最优匹配与追踪器更新。之后，将未匹配的追踪器 delete，将未匹配的检测器初始化，将匹配的追踪器使用对应的检测器进行赋值，作为输出，进入下次循环。

Deepsort 代码解读
另一篇写的很棒的 Deepsort 原理解读：https://blog.csdn.net/sgfmby1994/article/details/98517210

yolo 的总体思想归纳：

首先，将输入图片压缩到 416×416，通过特征提取网络（Darknet53 without FC layer）对输入图像提取特征得到大小一定的特征图，比如 13×13，然后将输入图像分成 13×13 个网格（grid cells），接着如果 GT 中某个目标的中心坐标落在哪个 grid cell 中，那么就由该 grid cell 来预测该目标。每个 grid cell 都会预测 3 个边界框。预测得到的输出特征图共有三个维度，第三个维度是深度。

Yolov3 输出了三个不同尺度的特征图。采用多尺度对不同大小的目标进行检测，越精细的 grid cell 就可以检测出越精细的物体。三个尺度的深度都是 255（3×（5+80））。

根据图来说明过程：

流程：首先输入尺寸 416×416，然后进入 darknet 特征提取网络，右边图（不算分支，也是左边图虚线中内容），其中经过五次下采样，还是用了残差结构，目的是使网络结构在很深的情况下，仍能收敛，继续训练下去。然后到左边图，虚线中输出的尺寸是 13×13，然后在经过 DBL 特征提取，以及最后蓝色的卷积（我猜是用来代替全连接分类的），输出第一个尺度 13×13。

接着用虚线输出的特征图经过 DBL 后的 13×13 的特征图上采样后与倒数第二次下采样的结果相加，二者都为 26×26，然后在进行和尺度一同样的后续操作。

最后是 26×26 的特征图上采样后与倒数第三次下采样的特征图相加，即还为 26×26，在进行后续操作。

总的来说会输出 3 个不同尺度的特征图，每个尺度的特征图负责预测不同大小的目标。每个特征图对应 3 种 anchor 大小不同的负责预测目标。最初图像还被分成 13×13 个网格，目标落在哪个网格中，哪个网格就负责预测目标，一个网格对应 3 个 anchor（anchor 的尺寸根据特征图相对于原图的比例等比缩小）。

预测时，yolov3 采用多个独立的逻辑分类器来计算属于特定标签的可能性，在计算分类损失时，它对每个标签使用二元交叉熵损失，降低了计算的复杂度。

YOLOv3 和 YOLOv5 整体思想类似，不过 YOLOV5 增加了 PaNet 等 tricks，以及 Mossiac 等大量数据增强，

YOLO V5 使用 GIOU Loss 作为 bounding box 的损失。

YOLO V5 使用二进制交叉熵和 Logits 损失函数计算类概率和目标得分的损失。同时我们也可以使用 fl _ gamma 参数来激活 Focal loss 计算损失函数。

在 YOLO V5 中，中间/隐藏层使用了 Leaky ReLU 激活函数，最后的检测层使用了 Sigmoid 形激活函数。

YOLOv3/YOLOv5 训练教程：
以 github Ultralytics 作者的 Yolov3 和 Yolo v5 为例子，可以很迅速的训练数据：1：配置环境 pip install -U -r requirements.txt

2：数据标注与预处理

将我们的 XML 文件放至 Annotations

将我们的图片放到 images

然后就可以转换 Annotations 为 Yolo 的训练格式，百度有很多。这里要注意看一下代码，有的地方需要修改。

并切分训练验证集，代码也给了，Voc_Labels.py 请看看代码，没怎么写注释。

接下来编写 data/文件夹的 yaml 文件（可以新建）：

在上面我们做好数据预处理后，就可以开始训练了，上面的一些处理步骤，每个人都可能不同，不过大体上思路是一致的。

接下来我们可以进行预训练，下载官方的预训练模型：yolov5s yolov5m yolov5l yolov5x 来 我在我的 github 中方了 yolov5s，比较小，只有 25mb，专门为移动端考虑了，真好。

当然也可以不使用预训练模型，使用与否，在总时间上是差不多的，不过

为什么要使用预训练模型？

作者已尽其所能设计了基准模型。我们可以在自己的数据集上使用预训练模型，而不是从头构建模型来解决类似的自然语言处理问题。

尽管仍然需要进行一些微调，但它已经为我们节省了大量的时间：通常是每个损失下降更快和计算资源节省。

加快梯度下降的收敛速度

更有可能获得一个低模型误差，或者低泛化误差的模型

降低因未初始化或初始化不当导致的梯度消失或者梯度爆炸问题。此情况会导致模型训练速度变慢，崩溃，直至失败。

其中随机初始化，可以打破对称性，从而保证不同的隐藏单元可以学习到不同的东西

接下来开始训练：

python train.py --data data/smoke.yaml --cfg models/yolov5s.yaml --weights weights/yolov5s.pt --batch-size 10 --epochs 100

我们–data data/smoke.yaml 中就是在 smoke.yaml 中撰写的训练代码路径和类别等 data，通过这个获取训练的图片和 label 标签等。

然后-cfg models/yolov5s.yaml 和 --weights weights/yolov5s.pt 是获取配置和预训练模型权重

batch-size 10 大家都懂，default 是 16，大家可以改成 16，在 yolov5s 中模型参施不多，百万左右，所以显存消耗不多，我的配置很差，显存 4g，在使用 yolov5m 中以及不能调到 16。

会报 cuda out of memory 报错，就把 batch size 降低就行。

然后最后是 epoch，这个也不用解释，我在使用 yolov5m 训练 5k 张图片在 100epoch 中花费 了 24 小时，一个 epoch13 分钟。

训练过程中，会慢慢在 runs 中生成 tensorboard，可视化损失下降

当然也可以在本地稍微看看

这幅图中，我们的类别只有 1 个，第三幅图显示了我们数据中的宽高比，归一化后，普遍在 0.1 左右，说明数据确实很小，也会面临模糊问题，导致数据质量降低。

检测：

运行 detect.py 即可

全部代码介绍

来回顾一下代码：

验证脚本

特征提取类

以【batch size,3,128,64】输入，返回类别结果的网络处理层，被上图特征提取类使用。

上图目前网络较原网络稍稍优化了，下图为原始网络。

网络性能验证与测试

网络训练。

追踪部分：
追踪部分的数据转换

匹配 Iou，用来区别框是否为待追踪目标的途径之一。

卡尔曼滤波

追踪类，返回识别结果

同追踪类，返回匹配追踪目标，和不匹配目标

YOLOv3 部分，darknet 版本，的 pytorch 版。

原始类别的检测脚本

更改后用于追踪的检测脚本

YOLOv3 网络层

处理数据，bdbox，nms 等操作的配置类 utils

解析 config 类

Rtsp 推流等方式 web 端部署。

V5 区域

训练部分代码和参数

图片，视频，web，相机等多方式检测

配置多比例模型和配置 utils。

V5 导出模型 onnx

演示

总结

原创好文，从原理到技术到源码到实际应用，工程，统统放送，在视频流处理中，更是大放异彩~

在视频流的实时追踪中，我们虽然解决了一些问题，但是发现，还是有许多道阻且长的问题。

大家一起加油干吧~

欢迎关注 cv 君公众号，源码欢迎公众号回复 跟踪 获取哦

致谢。