目标跟踪算法——ByteTrack算法原理解析

2024-09-04 06:36

本文主要是介绍目标跟踪算法——ByteTrack算法原理解析,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

文章目录

  • ByteTrack
    • 1. ByteTrack算法步骤:
    • 2. 算法解释
      • 2.1 模型初始化
      • 2.2 模型更新算法流程
        • 2.2.1 检测结果划分,划分为高分和较低分段
        • 2.2.2 高分段处理手段
        • 2.2.3 最优匹配与未匹配划分
        • 2.2.4 低分框再匹配
        • 2.2.5 未确认轨迹处理
        • 2.2.6 更新状态
      • 2.3 匈牙利匹配算法(线性分配)

ByteTrack

1. ByteTrack算法步骤:

  1. 目标检测:ByteTrack算法首先会对视频数据进行目标检测。
  2. 检测结果划分:根据得分(score)对检测结果进行划分。通过设定一个阈值,将检测结果分为高分(high score)和低分(low score)两个部分。高分部分通常对应着较为准确的检测结果,而低分部分可能包含一些误检或检测不准的目标。
  3. 初次匹配:将高分中的检测结果与已有的跟踪轨迹进行匹配追踪。这一步通常使用如SORT等算法进行。在这个过程中,会有部分轨迹成功匹配到检测结果,但也有部分轨迹可能没有被匹配成功。
  4. 再次匹配:对于初次匹配中未能成功匹配的轨迹,ByteTrack算法会将其与低分中的检测结果进行再次匹配。这样做的目的是为了尽可能利用所有的检测结果,提高跟踪的准确性和鲁棒性。
  5. 新建和保留轨迹:对于未能匹配到任何检测结果的跟踪轨迹,ByteTrack算法会保留这些轨迹m帧(m是一个预设的帧数),等待这些轨迹再次出现时再进行匹配。对于没有匹配上跟踪轨迹但得分又足够高的检测框,ByteTrack算法会新建一个跟踪轨迹。

2. 算法解释

2.1 模型初始化

def __init__(self, args, frame_rate=30):# 初始化一个空列表,用于存储正在被跟踪的轨迹self.tracked_stracks = []  # type: list[STrack]# 初始化一个空列表,用于存储丢失的轨迹(即当前帧中未检测到的轨迹)self.lost_stracks = []  # type: list[STrack]# 初始化一个空列表,用于存储已经从跟踪列表中移除的轨迹self.removed_stracks = []  # type: list[STrack]# 当前处理的帧的ID,初始化为0self.frame_id = 0# 存储算法的参数self.args = args#self.det_thresh = args.track_thresh# 初始化检测阈值,这个值用于判断检测到的物体是否应该被追踪# 初始值设置为args中的track_thresh值加上0.1self.det_thresh = args.track_thresh + 0.1# 根据帧率和args中的track_buffer来计算buffer的大小self.buffer_size = int(frame_rate / 30.0 * args.track_buffer)# 最大时间丢失阈值,用于判断一个轨迹何时应该被视为丢失self.max_time_lost = self.buffer_size# 初始化Kalman滤波器,用于预测物体的位置self.kalman_filter = KalmanFilter()

2.2 模型更新算法流程

2.2.1 检测结果划分,划分为高分和较低分段
self.frame_id += 1
# 初始化几个列表,用于存储不同类型的轨迹
activated_starcks = []
refind_stracks = []
lost_stracks = []
removed_stracks = []# 根据output_results的形状决定如何处理检测结果
if output_results.shape[1] == 5:# 如果输出结果的列数是5,那么只包含边界框和分数scores = output_results[:, 4]  # 获取分数列bboxes = output_results[:, :4]  # 获取边界框列
else:# 否则,需要将output_results从tensor转换为numpy数组output_results = output_results.cpu().numpy()scores = output_results[:, 4]  # 获取分数列# 这一行被注释掉了,如果取消注释,则会将分数与另一列相乘# scores = output_results[:, 4] * output_results[:, 5]bboxes = output_results[:, :4]  # 获取边界框列,格式为x1y1x2y2(左上角和右下角坐标)# 以下是关于边界框缩放的代码
# scale = min(img_size[0] / float(img_h), img_size[1] / float(img_w))
# bboxes /= scale# 过滤掉分数低于跟踪阈值的检测结果
remain_inds = scores > self.args.track_thresh
# 分割出分数较高的和较低的检测结果
inds_low = scores > 0.1
inds_high = scores < self.args.track_thresh
# 找到同时满足上述两个条件的索引
inds_second = np.logical_and(inds_low, inds_high)# 获取对应的边界框和分数
dets = bboxes[remain_inds]
scores_keep = scores[remain_inds]dets_second = bboxes[inds_second]
scores_second = scores[inds_second]
2.2.2 高分段处理手段
if len(dets) > 0:'''Detections'''# 创建新的轨迹对象,并添加到detections列表中detections = [STrack(STrack.tlbr_to_tlwh(tlbr), s) for(tlbr, s) in zip(dets, scores_keep)]
else:# 如果没有符合条件的检测结果,则detections列表为空detections = []
''' Add newly detected tracklets to tracked_stracks'''# 将未激活的轨迹添加到unconfirmed列表中,已激活的轨迹添加到tracked_stracks列表中
unconfirmed = []
tracked_stracks = []  # type: list[STrack]
for track in self.tracked_stracks:if not track.is_activated:unconfirmed.append(track)else:tracked_stracks.append(track)
2.2.3 最优匹配与未匹配划分
1.通过计算IoU距离来评估轨迹与检测框之间的匹配程度,并使用匈牙利算法来找到最优匹配。
2.匹配成功后,轨迹会根据新的检测框信息进行更新,或者被重新激活。
3.未匹配的轨迹和检测框则分别存储在u_track和u_detection中,
轨迹和检测框可能需要在后续步骤中进行进一步处理,例如将长时间未匹配的轨迹标记为丢失或移除。
# 第二步:首先与分数较高的检测结果进行关联将当前正在跟踪的轨迹和已丢失的轨迹合并成一个列表,准备进行匹配
strack_pool = joint_stracks(tracked_stracks, self.lost_stracks)
# Predict the current location with KF
# 使用Kalman滤波器预测strack_pool中每个轨迹在当前帧的位置
STrack.multi_predict(strack_pool)
# 计算strack_pool中每个轨迹的预测位置与当前帧检测框之间的IoU距离
dists = matching.iou_distance(strack_pool, detections)
# 如果不是使用MOT20格式的数据集,则根据检测框的分数调整IoU距离
if not self.args.mot20:dists = matching.fuse_score(dists, detections)
# 使用线性分配算法(也称为匈牙利算法)进行轨迹与检测框的匹配
# 返回匹配成功的轨迹和检测框索引对,未匹配的轨迹索引和未匹配的检测框索引
matches, u_track, u_detection = matching.linear_assignment(dists, thresh=self.args.match_thresh)
# 遍历匹配结果
for itracked, idet in matches:# 获取匹配的轨迹和检测框track = strack_pool[itracked]det = detections[idet]if track.state == TrackState.Tracked:# 将激活的轨迹添加到activated_starcks列表中track.update(detections[idet], self.frame_id)activated_starcks.append(track)else:# 如果轨迹是处于丢失状态(Lost) 重新激活轨迹,使用新的检测框信息,将重新找到的轨迹添加到refind_stracks列表中track.re_activate(det, self.frame_id, new_id=False)refind_stracks.append(track)
2.2.4 低分框再匹配

1.如果存在分数较低的检测框,将它们转换成STrack对象列表。
1.1 从未匹配的轨迹中筛选出状态为Tracked的轨迹。
1.2 计算这些轨迹与分数较低的检测框之间的IoU距离。
1.3使用线性分配算法进行二次匹配,阈值设为0.
匹配成功的轨迹根据检测框信息更新或重新激活。
对于剩余未匹配的轨迹,如果它们不是已标记为Lost的状态,则将它们标记为Lost并添加到lost_stracks列表中。

 # 第三步:使用分数较低的检测框进行二次关联# 如果存在分数较低的检测框if len(dets_second) > 0:# 创建一个新的轨迹列表,用于存储分数较低的检测框'''Detections'''detections_second = [STrack(STrack.tlbr_to_tlwh(tlbr), s) for (tlbr, s) in zip(dets_second, scores_second)]else:# 如果没有分数较低的检测框,则创建一个空列表detections_second = []# 从未匹配的轨迹中筛选出状态为Tracked的轨迹r_tracked_stracks = [strack_pool[i] for i in u_track if strack_pool[i].state == TrackState.Tracked]# 计算筛选后的轨迹与分数较低的检测框之间的IoU距离dists = matching.iou_distance(r_tracked_stracks, detections_second)# 使用线性分配算法进行二次匹配,匹配阈值设为0.5matches, u_track, u_detection_second = matching.linear_assignment(dists, thresh=0.5)# 遍历匹配结果for itracked, idet in matches:# 获取匹配的轨迹和检测框track = r_tracked_stracks[itracked]det = detections_second[idet]# 如果轨迹是处于跟踪状态(Tracked)if track.state == TrackState.Tracked:# 使用检测框的信息更新轨迹track.update(det, self.frame_id)# 将激活的轨迹添加到activated_starcks列表中activated_starcks.append(track)# 如果轨迹不是处于跟踪状态(可能是Lost)else:# 重新激活轨迹,使用新的检测框信息track.re_activate(det, self.frame_id, new_id=False)# 将重新找到的轨迹添加到refind_stracks列表中refind_stracks.append(track)# 遍历剩余未匹配的轨迹for it in u_track:# 获取轨迹track = r_tracked_stracks[it]# 如果轨迹不是已标记为Lost的状态if not track.state == TrackState.Lost:# 标记轨迹为Losttrack.mark_lost()# 将Lost状态的轨迹添加到lost_stracks列表中lost_stracks.append(track)
2.2.5 未确认轨迹处理
  1. 从所有检测框中筛选出与未确认轨迹相关的检测框。
  2. 计算未确认轨迹与这些检测框之间的IoU距离。
  3. 如果不是使用MOT20标准,则将轨迹的分数与IoU距离融合,以得到一个综合的匹配距离。
  4. 使用线性分配算法进行匹配,阈值设为0.7。
  5. 对于匹配成功的未确认轨迹,使用检测框的信息进行更新,并将其标记为已激活,添加到activated_starcks列表中。
  6. 对于剩余的未确认轨迹,即未能与任何检测框匹配的轨迹,将其标记为已移除,并添加到removed_stracks列表中。
# 处理未确认的轨迹,这些轨迹通常只有起始帧
'''Deal with unconfirmed tracks, usually tracks with only one beginning frame'''
# 从所有检测框中筛选出与未确认轨迹相关的检测框
detections = [detections[i] for i in u_detection]# 计算未确认轨迹与筛选后的检测框之间的IoU距离
dists = matching.iou_distance(unconfirmed, detections)# 如果不是使用MOT20标准,则将轨迹的分数与IoU距离融合
if not self.args.mot20:dists = matching.fuse_score(dists, detections)# 使用线性分配算法进行匹配,匹配阈值设为0.7
matches, u_unconfirmed, u_detection = matching.linear_assignment(dists, thresh=0.7)# 遍历匹配结果
for itracked, idet in matches:# 获取匹配的未确认轨迹和检测框track = unconfirmed[itracked]det = detections[idet]# 使用检测框的信息更新未确认轨迹track.update(det, self.frame_id)# 将已激活的轨迹添加到activated_starcks列表中activated_starcks.append(track)# 遍历剩余的未确认轨迹
for it in u_unconfirmed:# 获取轨迹track = unconfirmed[it]# 标记轨迹为已移除track.mark_removed()# 将已移除的轨迹添加到removed_stracks列表中removed_stracks.append(track)
2.2.6 更新状态

检查并移除那些超过最大丢失时间阈值的丢失轨迹。
更新已跟踪的轨迹列表,只保留状态为“Tracked”的轨迹。
将新激活的轨迹和重新找到的轨迹添加到已跟踪的轨迹列表中。
更新丢失的轨迹列表,移除那些已经被跟踪的轨迹,并添加新标记为丢失的轨迹。
从丢失的轨迹列表中移除那些已经被移除的轨迹。
将已移除的轨迹添加到移除的轨迹列表中。
移除已跟踪和丢失轨迹列表中的重复轨迹。
返回所有已激活的跟踪轨迹列表。

# 遍历所有标记为丢失的轨迹
for track in self.lost_stracks:# 如果轨迹丢失的时间超过了最大允许丢失时间if self.frame_id - track.end_frame > self.max_time_lost:# 标记轨迹为已移除track.mark_removed()# 将移除的轨迹添加到removed_stracks列表中removed_stracks.append(track)# 更新已跟踪的轨迹列表,只保留状态为Tracked的轨迹
self.tracked_stracks = [t for t in self.tracked_stracks if t.state == TrackState.Tracked]
# 将新激活的轨迹(activated_starcks)添加到已跟踪的轨迹列表中
self.tracked_stracks = joint_stracks(self.tracked_stracks, activated_starcks)
# 将重新找到的轨迹(refind_stracks)也添加到已跟踪的轨迹列表中
self.tracked_stracks = joint_stracks(self.tracked_stracks, refind_stracks)
# 从丢失的轨迹列表中移除那些已经被跟踪的轨迹
self.lost_stracks = sub_stracks(self.lost_stracks, self.tracked_stracks)
# 将新标记为丢失的轨迹(lost_stracks)添加到丢失的轨迹列表中
self.lost_stracks.extend(lost_stracks)
# 从丢失的轨迹列表中移除那些已经被移除的轨迹
self.lost_stracks = sub_stracks(self.lost_stracks, self.removed_stracks)
# 将已移除的轨迹(removed_stracks)添加到移除的轨迹列表中
self.removed_stracks.extend(removed_stracks)
# 移除已跟踪和丢失轨迹列表中的重复轨迹
self.tracked_stracks, self.lost_stracks = remove_duplicate_stracks(self.tracked_stracks, self.lost_stracks)
# 获取所有已激活的跟踪轨迹
output_stracks = [track for track in self.tracked_stracks if track.is_activated]
# 返回已激活的跟踪轨迹列表
return output_stracks

2.3 匈牙利匹配算法(线性分配)

cost, x, y = lap.lapjv(cost_matrix, extend_cost=True, cost_limit=thresh) 这行代码中,lapjv 函数来自 SciPy 的 scipy.optimize 模块,用于解决线性分配问题(也称为匈牙利算法)。这个函数会找到一种最优的配对方式,使得两组元素之间的配对总成本最小。

函数的参数解释如下:

  • cost_matrix: 这是一个二维数组(或矩阵),表示不同元素配对之间的成本。cost_matrix[i][j] 表示将第一组中的第 i 个元素与第二组中的第 j 个元素配对的成本。
  • extend_cost: 这是一个布尔值,当设置为 True 时,lapjv 函数会扩展成本矩阵,使其成为一个方阵(即行数和列数相等),并在扩展的部分填充一个足够大的值,以确保原始成本矩阵中的配对是最优的。这对于非方阵的成本矩阵是必要的,因为匈牙利算法要求成本矩阵是方阵。
  • cost_limit: 这是一个阈值,用于限制考虑的配对成本。只有当配对的成本小于或等于此阈值时,该配对才会被考虑在内。这有助于排除那些成本过高的配对,从而加速计算过程或找到满足特定条件的解。

函数的返回值解释如下:

  • cost: 这是一个标量值,表示找到的最优配对方案的总成本。
  • x: 这是一个整数数组,表示第一组元素与第二组元素的配对关系。如果 x[i] 的值是 j(且 j 是非负的),那么表示第一组中的第 i 个元素与第二组中的第 j 个元素被配对。如果 x[i] 的值是负数,那么表示第一组中的第 i 个元素没有被配对。
  • y: 这是一个整数数组,与 x 类似,表示第二组元素与第一组元素的配对关系。如果 y[j] 的值是 i(且 i 是非负的),那么表示第二组中的第 j 个元素与第一组中的第 i 个元素被配对。如果 y[j] 的值是负数,那么表示第二组中的第 j 个元素没有被配对。
def linear_assignment(cost_matrix, thresh):'''线性分配,匈牙利算法Args:cost_matrix:thresh:Returns:'''if cost_matrix.size == 0:return np.empty((0, 2), dtype=int), tuple(range(cost_matrix.shape[0])), tuple(range(cost_matrix.shape[1]))matches, unmatched_a, unmatched_b = [], [], []cost, x, y = lap.lapjv(cost_matrix, extend_cost=True, cost_limit=thresh)for ix, mx in enumerate(x):if mx >= 0:matches.append([ix, mx])unmatched_a = np.where(x < 0)[0]unmatched_b = np.where(y < 0)[0]matches = np.asarray(matches)return matches, unmatched_a, unmatched_b
, [], []cost, x, y = lap.lapjv(cost_matrix, extend_cost=True, cost_limit=thresh)for ix, mx in enumerate(x):if mx >= 0:matches.append([ix, mx])unmatched_a = np.where(x < 0)[0]unmatched_b = np.where(y < 0)[0]matches = np.asarray(matches)return matches, unmatched_a, unmatched_b

这篇关于目标跟踪算法——ByteTrack算法原理解析的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1135270

相关文章

Python中随机休眠技术原理与应用详解

《Python中随机休眠技术原理与应用详解》在编程中,让程序暂停执行特定时间是常见需求,当需要引入不确定性时,随机休眠就成为关键技巧,下面我们就来看看Python中随机休眠技术的具体实现与应用吧... 目录引言一、实现原理与基础方法1.1 核心函数解析1.2 基础实现模板1.3 整数版实现二、典型应用场景2

Java的IO模型、Netty原理解析

《Java的IO模型、Netty原理解析》Java的I/O是以流的方式进行数据输入输出的,Java的类库涉及很多领域的IO内容:标准的输入输出,文件的操作、网络上的数据传输流、字符串流、对象流等,这篇... 目录1.什么是IO2.同步与异步、阻塞与非阻塞3.三种IO模型BIO(blocking I/O)NI

SpringBoot实现MD5加盐算法的示例代码

《SpringBoot实现MD5加盐算法的示例代码》加盐算法是一种用于增强密码安全性的技术,本文主要介绍了SpringBoot实现MD5加盐算法的示例代码,文中通过示例代码介绍的非常详细,对大家的学习... 目录一、什么是加盐算法二、如何实现加盐算法2.1 加盐算法代码实现2.2 注册页面中进行密码加盐2.

python+opencv处理颜色之将目标颜色转换实例代码

《python+opencv处理颜色之将目标颜色转换实例代码》OpenCV是一个的跨平台计算机视觉库,可以运行在Linux、Windows和MacOS操作系统上,:本文主要介绍python+ope... 目录下面是代码+ 效果 + 解释转HSV: 关于颜色总是要转HSV的掩膜再标注总结 目标:将红色的部分滤

Python 中的异步与同步深度解析(实践记录)

《Python中的异步与同步深度解析(实践记录)》在Python编程世界里,异步和同步的概念是理解程序执行流程和性能优化的关键,这篇文章将带你深入了解它们的差异,以及阻塞和非阻塞的特性,同时通过实际... 目录python中的异步与同步:深度解析与实践异步与同步的定义异步同步阻塞与非阻塞的概念阻塞非阻塞同步

Java时间轮调度算法的代码实现

《Java时间轮调度算法的代码实现》时间轮是一种高效的定时调度算法,主要用于管理延时任务或周期性任务,它通过一个环形数组(时间轮)和指针来实现,将大量定时任务分摊到固定的时间槽中,极大地降低了时间复杂... 目录1、简述2、时间轮的原理3. 时间轮的实现步骤3.1 定义时间槽3.2 定义时间轮3.3 使用时

Redis中高并发读写性能的深度解析与优化

《Redis中高并发读写性能的深度解析与优化》Redis作为一款高性能的内存数据库,广泛应用于缓存、消息队列、实时统计等场景,本文将深入探讨Redis的读写并发能力,感兴趣的小伙伴可以了解下... 目录引言一、Redis 并发能力概述1.1 Redis 的读写性能1.2 影响 Redis 并发能力的因素二、

Spring MVC使用视图解析的问题解读

《SpringMVC使用视图解析的问题解读》:本文主要介绍SpringMVC使用视图解析的问题解读,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录Spring MVC使用视图解析1. 会使用视图解析的情况2. 不会使用视图解析的情况总结Spring MVC使用视图

一文详解SQL Server如何跟踪自动统计信息更新

《一文详解SQLServer如何跟踪自动统计信息更新》SQLServer数据库中,我们都清楚统计信息对于优化器来说非常重要,所以本文就来和大家简单聊一聊SQLServer如何跟踪自动统计信息更新吧... SQL Server数据库中,我们都清楚统计信息对于优化器来说非常重要。一般情况下,我们会开启"自动更新

利用Python和C++解析gltf文件的示例详解

《利用Python和C++解析gltf文件的示例详解》gltf,全称是GLTransmissionFormat,是一种开放的3D文件格式,Python和C++是两个非常强大的工具,下面我们就来看看如何... 目录什么是gltf文件选择语言的原因安装必要的库解析gltf文件的步骤1. 读取gltf文件2. 提