基于YOLOv8与ByteTrack实现多目标跟踪——算法原理与代码实践

知来者逆

已于 2024-04-19 09:08:18 修改

阅读量6.6k

点赞数 28

分类专栏： YOLO 文章标签： YOLOv8 目标追踪目标检测人工智能机器学习 python

于 2024-03-29 13:05:43 首次发布

本文链接：https://blog.csdn.net/matt45m/article/details/137139824

版权

YOLO 专栏收录该内容

34 篇文章 94 订阅

订阅专栏

概述

在目标检测中，有许多经算法如Faster RCNN、SSD和YOLO的各种版本，这些算法利用深度学习技术，特别是卷积神经网络（CNN），能够高效地在图像中定位和识别不同类别的目标。Faster RCNN是一种基于区域提议的目标检测算法，通过引入区域建议网络（RPN）来生成候选框，然后使用分类器和回归器来识别和精确定位目标。SSD（Single Shot MultiBox Detector）是一种单阶段的目标检测算法，它在单个卷积网络中同时进行目标分类和定位，具有较快的速度和较高的准确性。而YOLO（You Only Look Once）则是一种端到端的目标检测算法，通过将图像分割为网格并预测每个网格中的目标类别和边界框来实现目标检测，具有实时性的优势。
但这里有一个问题是，在目标检测上，所检测到的目标是一帧帧的，同一个目标在帧与帧之间并没有关联起来，这个时候，如果要确定上一帧的A_1目标是不是下一帧的A_2目标，这里就要用到多目标跟踪。多目标追踪传输的是一个视频流，对于每一帧，需要检测目标并分配一个“对象 ID”，在下一帧中，如果检测到相同的对象，则需要分配相同的对象 ID。有许多算法用于 MOT，如 SORT（简单在线实时跟踪）、DeepSort、StrongSort 等。

SORT（Simple Online and Realtime Tracking）：这是一种简单而高效的在线多目标跟踪算法，它结合了卡尔曼滤波和匈牙利算法来实现目标跟踪。SORT适用于实时应用，并且在计算资源有限的情况下表现良好。
DeepSort：这是在SORT基础上发展而来的算法，它引入了深度学习技术，特别是卷积神经网络（CNN），用于提取目标的特征表示。DeepSort在目标跟踪的准确性和鲁棒性方面相对于传统方法有所提升。
StrongSort：这是另一种基于深度学习的多目标跟踪算法，它通过设计更强大的特征提取网络和更精细的跟踪策略来提高目标跟踪的性能。

目标跟踪可分为下面几种：

基于特征的跟踪：这涉及基于其特征（如颜色、形状、纹理等）进行跟踪。

模板匹配：顾名思义，这种方法使用预定义的模板在每个视频序列中进行匹配。

基于相关性的跟踪：这种方法用于计算目标对象与后续帧中候选区域之间的相似性。

基于深度学习的跟踪：这种方法使用在大型数据集上训练的神经网络实时检测和跟踪对象。

ByteSort

其他MOT算法中移除低置信度检测框的问题主要源于对检测框置信度的阈值设置以及对检测框的筛选策略。因为低置信度的检测框被认为可能是误检测或者不可靠的检测结果，因此会被丢弃以提高跟踪的准确性。然而，这种策略可能会带来一些问题：

遮挡目标： 低置信度的检测框有时确实可以指示目标的存在，尤其是在目标被部分遮挡或者遮挡物很大时。丢弃这些低置信度的检测框可能会导致漏检目标，因为算法无法正确地识别被遮挡的目标。
轨迹断裂： 移除低置信度的检测框可能导致轨迹的不连续性，因为目标在一帧中被识别出来，在另一帧中却被移除了。这可能会导致跟踪算法无法正确地维持目标的标识符，从而产生碎片化的轨迹，使跟踪结果不连贯。

ByteTrack考虑低置信度的检测框的原因在于：

避免漏检： ByteTrack意识到低置信度的检测框可能是有价值的目标信息，尤其是在目标被遮挡的情况下。因此，保留这些检测框有助于避免目标漏检的情况，提高跟踪的完整性。
减少轨迹断裂： 通过保留低置信度的检测框，ByteTrack可以减少轨迹的不连续性，从而提高了多目标跟踪的连贯性和准确性。这有助于跟踪算法更好地维持目标的标识符，减少碎片化轨迹的出现。

可以从下面的例子说明这个问题，如下图1：
在这里插入图片描述
在帧 t1 中，初始化了三个不同的轨迹，因为它们的置信度都高于 0.5。但在帧 t2 和 t3 中，置信度从 0.8 下降到 0.4，然后从 0.4 下降到 0.1。

图2：
在这里插入图片描述
这些检测框将被阈值机制消除，相应的红色轨迹也会相应消失，如上图所示。但如果考虑所有的检测框，更多的误报率将会被引入，例如图1中右most的框。这带来了第二个问题。

图3：
在这里插入图片描述
例如，如图3所示，两个低分检测框通过运动预测框（虚线）与轨迹匹配，因此对象被正确恢复。背景框被移除，因为它没有匹配的轨迹。

因此，使用高分到低分检测框在匹配过程中。这种简单而有效的关联方法称为 BYTE，因为每个检测框都是轨迹的基本单位。首先，它根据运动或外观相似性将高分检测框匹配到轨迹。然后，它采用卡尔曼滤波器来预测下一帧中轨迹的位置。然后可以使用 IoU 或 Re-ID 特征距离计算预测框和检测框之间的相似性。在第二次匹配步骤中，低分检测和未匹配的轨迹，即红色框中的轨迹，使用相同的运动相似性进行匹配。

数据关联

数据关联是多目标跟踪的核心之一，它涉及计算轨迹和检测框之间的相似性，并根据相似性应用不同的策略进行匹配。

在相似性度量方面，位置、运动和外观是三个重要的线索。SORT算法通常简单地利用位置和运动线索。它使用卡尔曼滤波器来预测下一帧中的轨迹，并计算检测框和预测框之间的IoU作为相似性度量。然而，位置和运动线索更适用于短距离匹配。对于长距离匹配，外观相似性则变得更加重要。例如，长时间被遮挡的对象可能会通过外观相似性进行识别。外观相似性通常通过计算Re-ID特征的余弦相似性来衡量。与此类似，DeepSort采用了独立的深度学习模型来处理外观相似性。

在匹配策略方面，不同的算法使用不同的方法为对象分配ID。SORT通常通过一次匹配将检测框与轨迹匹配，而DeepSort则采用级联匹配策略。这种策略首先将检测框与最近的跟踪器匹配，然后与丢失的跟踪器进行匹配。

BYTE 算法

BYTE算法的输入是视频序列和检测器，以及一个检测阈值值。该算法的输出是视频的每一帧中的轨迹T，其中包含对象的边界框和ID。

对于视频中的每一帧，首先使用检测器（Det）预测检测框和相应的预测分数。然后，根据设定的检测分数阈值，将检测框分为高分（Det(high)）和低分（Det(low)）两部分。

分离检测框后，BYTE算法将卡尔曼滤波器应用于预测当前帧中每个轨迹T的新位置。首先对高分检测框进行关联，然后再处理剩余的低分检测框。

BYTE算法的主要亮点在于其非常灵活，能够与不同的关联方法兼容。这意味着它可以根据特定的应用场景选择最合适的关联方法，从而提高多目标跟踪的性能和效果。

性能测试

在同一个数据集上的表现，ByteTrack算法的性能优于SORT和DeepSORT算法，这表明它在多目标跟踪任务上具有较好的表现。，ByteTrack的MOTA达到了76.6，而SORT和DeepSORT的性能分别为74.6和75.4。

ByteTrack在算法架构上相对简单，但其性能却十分可观。这种性能提升可能源于它在关联过程中的灵活性以及对外观相似性的更好处理。

ByteTrack 与 YOLOv8 示例

多目标追踪场景中，大部分遮挡物体的检测结果都是低分框，ByteTrack 非常简洁地从低分检测框中寻找遮挡的物体，对遮挡非常鲁棒。ByteTrack 同时也为如何最大程度利用检测结果来帮助 MOT 提供了启发，下面提供了 ByteTrack 的部署代码和模型：

import supervision as sv
from ultralytics import YOLO 
from tqdm import tqdm
import argparse
import numpy as np

tracker = sv.ByteTrack() 
def process_video(
        source_weights_path: str, 
        source_video_path: str,
        target_video_path: str, 
        confidence_threshold: float = 0.3,
        iou_threshold: float = 0.7
) -> None:
    model = YOLO(source_weights_path)       # Load YOLO model 
    classes = list(model.names.values())    # Class names 
    LINE_STARTS = sv.Point(0,500)           # Line start point for count in/out vehicle
    LINE_END = sv.Point(1280, 500)          # Line end point for count in/out vehicle
    tracker = sv.ByteTrack()                # Bytetracker instance 
    box_annotator = sv.BoundingBoxAnnotator()     # BondingBox annotator instance 
    label_annotator = sv.LabelAnnotator()         # Label annotator instance 
    frame_generator = sv.get_video_frames_generator(source_path=source_video_path) # for generating frames from video
    video_info = sv.VideoInfo.from_video_path(video_path=source_video_path)
    line_counter = sv.LineZone(start=LINE_STARTS, end = LINE_END)
    line_annotator = sv.LineZoneAnnotator(thickness=2, text_thickness=2, text_scale= 0.5)

    with sv.VideoSink(target_path=target_video_path, video_info=video_info) as sink:
        for frame in tqdm(frame_generator, total= video_info.total_frames):
            # Getting result from model
            results = model(frame, verbose=False, conf= confidence_threshold, iou = iou_threshold)[0] 
            detections = sv.Detections.from_ultralytics(results)    # Getting detections
            #Filtering classes for car and truck only instead of all COCO classes.
            detections = detections[np.where((detections.class_id==2)|(detections.class_id==7))]
            detections = tracker.update_with_detections(detections)  # Updating detection to Bytetracker
            # Annotating detection boxes
            annotated_frame = box_annotator.annotate(scene = frame.copy(), detections= detections) 

            #Prepare labels
            labels = []
            for index in range(len(detections.class_id)):
                # creating labels as per required.
                labels.append("#" + str(detections.tracker_id[index]) + " " + classes[detections.class_id[index]] + " "+ str(round(detections.confidence[index],2)) )
            
            # Line counter in/out trigger
            line_counter.trigger(detections=detections)
            # Annotating labels
            annotated_label_frame = label_annotator.annotate(scene=annotated_frame, detections=detections, labels=labels)
            # Annotating line labels
            line_annotate_frame = line_annotator.annotate(frame=annotated_label_frame, line_counter=line_counter)
            sink.write_frame(frame = line_annotate_frame)

if __name__ == "__main__":
    parser = argparse.ArgumentParser("video processing with YOLO and ByteTrack") 
    parser.add_argument(
        "--source_weights_path",
        required=True,
        help="Path to the source weights file",
        type=str
    )
    parser.add_argument(
        "--source_video_path",
        required=True, 
        help="Path to the source video file",
        type = str
    )
    parser.add_argument(
        "--target_video_path",
        required=True,
        help="Path to the target video file",
        type= str
    )
    parser.add_argument(
        "--confidence_threshold",
        default = 0.3,
        help= "Confidence threshold for the model",
        type=float
    )
    parser.add_argument(
        "--iou_threshold",
        default=0.7,
        help="Iou threshold for the model",
        type= float
    )
    args = parser.parse_args() 
    process_video(
        source_weights_path=args.source_weights_path, 
        source_video_path= args.source_video_path,
        target_video_path=args.target_video_path, 
        confidence_threshold=args.confidence_threshold,
        iou_threshold=args.iou_threshold
    )