YOLOV8+ByteTrack实现多目标检测与追踪

YOLOV8+ByteTrack实现多目标检测与追踪

先看效果：

mytrack

1. 任务内容及目标：

复现2022年在ECCV上发表的ByteTrack多目标追踪技术，并将其与YOLOV8结合，实现多目标检测与追踪。

2. 关于目标追踪的相关技术：

在多目标跟踪技术中，ByteTrack 凭借高效利用低置信度检测结果，在遮挡和密集场景中表现优异，是当前性能最为平衡的算法之一。而 FairMOT 通过单一网络结合检测和重识别特征，适合高精度要求的场景，但对计算资源需求较高。TrackFormer 基于 Transformer 的架构，擅长复杂长时间关联任务，但实时性不足，适合计算能力充足的环境。经典的 DeepSORT 则以简单高效著称，适合中小规模的跟踪任务。综合来看，ByteTrack 是性能与实时性兼具的最佳选择，FairMOT 在精度上略胜一筹，而 TrackFormer 和 DeepSORT 则分别适用于复杂和基础的应用场景。

3. 过程

MOT 17测试集上不同跟踪器的MOTA-IDF 1-FPS比较。横轴为FPS（行驶速度），纵轴为MOTA，圆的半径为IDF 1。我们的ByteTrack在MOT 17测试集上以30 FPS的运行速度实现了80.3 MOTA和77.3 IDF 1，超过了之前所有的跟踪器。

3.1 名词解释

1. IoU（Intersection over Union）

含义：IoU（交并比）是计算两个边界框重叠度的常用指标。它的计算方法是：

​ IoU = 交集面积 / 并集面积

应用：在多目标跟踪中，IoU 用于衡量一个检测框与预测轨迹框之间的重叠程度。高的 IoU 表示检测框和预测轨迹框较为吻合，是判断检测是否成功的重要标准。

2. Re-ID（Re-identification）

含义：Re-ID（重识别）是指通过外观特征（如图像中的颜色、形状、纹理等）来识别同一个物体，即使该物体在视频中的位置或姿态发生变化。

应用：在多目标跟踪中，Re-ID 特征用于在多个框之间确认目标的身份，尤其在遮挡、相似外观的目标出现或目标消失一段时间后，Re-ID 帮助恢复和匹配正确的目标身份。

3. MOTA（Multi-Object Tracking Accuracy）

含义：MOTA 是衡量多目标跟踪系统性能的一个重要指标，它综合考虑了跟踪过程中的多种错误，包括：

假阳性（False Positives，FP）：错误地将背景或非目标检测为目标。

假阴性（False Negatives，FN）：漏检的目标。

身份切换（ID Switches，ID）：目标的身份错误匹配。

计算公式：

MOTA = 1- （（FP+FN+ID）/ GT） 其中，GT 是真实的目标数。

应用：MOTA 越高，表示跟踪系统在多个目标的识别、定位和身份保留方面表现越好。80.3 的 MOTA 表示该系统在 MOT17 数据集上的多目标跟踪精度非常高。

4. IDF1（ID F1 Score）

含义：IDF1 是用来衡量多目标跟踪中目标身份保留能力的指标。它综合考虑了跟踪的准确性和稳定性，尤其关注目标身份在整个视频序列中的一致性。

计算公式：

IDF1 = （2 * 检测到且正确跟踪比例 * 真实且正确跟踪比例）/ （检测到且正确跟踪比例 + 真实且正确跟踪比例）

• Precision：检测到的目标中，正确跟踪的目标占比。
• Recall：所有真实目标中被成功跟踪的目标占比。

应用：IDF1 越高，表示系统在跟踪目标时保持身份一致性的能力越强。77.3 的 IDF1 表示该系统对目标身份的追踪效果较好，能够有效避免身份切换。

总结：

• 80.3 的 MOTA：表示该系统在多目标跟踪任务中，在检测精度、漏检和身份切换方面的表现非常好。
• 77.3 的 IDF1：表示该系统在多目标跟踪任务中，能够较好地保持目标的身份一致性，避免了大量的身份切换。

3.2 ByteTrack 伪代码流程

伪代码的流程分为以下几个步骤：

1. 初始化：在每个视频序列的开始，初始化一个空的跟踪列表 T（包含每个目标的边界框和身份），用于存储当前帧的所有目标轨迹。
2. 处理每一帧：
   • 检测框的预测：对当前帧进行目标检测，得到所有检测框 Dk，其中每个检测框包含一个得分（置信度）。
   • 分离高低分检测框：根据检测框的得分，将检测框分为两个类别：Dhigh（高得分框）和 Dlow（低得分框）。
3. 卡尔曼滤波器预测位置：
   • 对于每个跟踪中的目标轨迹，使用卡尔曼滤波器来预测目标在当前帧的位置。（轨迹框）
4. 第一阶段匹配（高得分框与轨迹匹配）：
   • 将高得分的检测框 Dhigh 与所有当前的轨迹进行匹配，计算轨迹框与检测框之间的相似度，通常使用 IoU 或 Re-ID 特征距离来衡量相似度。
   • 使用 匈牙利算法（Hungarian Algorithm）来完成最优匹配，将匹配的检测框关联到轨迹。
   • 匹配后的检测框会被从高得分检测框 Dhigh 中移除，剩余未匹配的检测框放入 Dremain，未匹配的轨迹放入 Tremain。
5. 第二阶段匹配（低得分框与未匹配轨迹匹配）：
   • 对于第一阶段未匹配的轨迹 Tremain 和低得分的检测框 Dlow 进行第二阶段匹配。
   • 采用 IoU 作为相似度度量，因为低得分框通常在遮挡或运动模糊的情况下很难提取出有效的外观特征，因此不使用 Re-ID 特征。
   • 匹配后的低得分检测框会被关联到轨迹，未匹配的低得分检测框会被丢弃。
6. 删除未匹配的轨迹：
   • 对于第二阶段匹配后仍然未匹配的轨迹 Tremain，如果它们在当前帧依然没有匹配到检测框，并且持续时间超过一定阈值（如 30 帧），这些轨迹将被删除。
7. 初始化新的轨迹：
   • 对于第一阶段中未匹配到轨迹的高得分检测框 Dremain，将它们作为新的轨迹添加到跟踪列表 T。
8. 返回跟踪结果：在所有帧处理完后，返回所有轨迹的边界框和身份。

3.3 卡尔曼滤波器在ByteTrack的作用

卡尔曼滤波器预测的目标位置（轨迹框的当前位置）被用作匹配的基准，在第一阶段匹配中，通过计算预测位置与高置信度检测框之间的相似度（通常是 IoU 或 Re-ID 特征距离）来决定轨迹是否可以与检测框关联。

1.具体流程

1. 输入的轨迹信息：
   • 每条轨迹的最新状态包括目标的上一帧位置、速度，以及预测的下一帧位置（由卡尔曼滤波器提供）。
2. 使用预测位置计算 IoU：
   • 利用卡尔曼滤波器预测的位置（轨迹框）与当前帧中的检测框 Dhigh 计算 IoU（交并比）
   • IoU 衡量的是两者的空间重合程度，值越大说明检测框和轨迹框越可能属于同一个目标。
3. 匹配高置信度检测框：
   • 根据 IoU 相似度矩阵，将轨迹框与高置信度检测框进行分配（通常通过匈牙利算法找到最优分配）。
   • 如果某个轨迹框与某个检测框的 IoU 足够高（高于设定阈值），则将该检测框分配给该轨迹。
4. 未匹配处理：
   • 如果轨迹框没有匹配到任何检测框，则它会进入第二阶段，尝试与低置信度检测框匹配。
   • 如果检测框没有匹配到轨迹，则该检测框会被视为新目标，初始化一个新的轨迹。

---

2. 为什么需要卡尔曼滤波器的预测？

1. 解决检测框的抖动问题：
   • 在实际应用中，检测框可能会因为检测器的抖动而偏离目标的真实位置。卡尔曼滤波器通过结合上一帧的速度信息预测下一帧的位置，可以提供更平滑、连续的轨迹框，有效减小抖动带来的影响。
2. 提供更准确的轨迹预测：
   • 检测器无法总是完美地检测到目标（例如被遮挡时）。卡尔曼滤波器可以基于轨迹历史，预测目标在下一帧中的可能位置，从而提高未检测到目标情况下的轨迹保留能力。
3. 增强轨迹的连续性：
   • 如果某个目标的检测框在当前帧中消失（例如被遮挡），预测位置可以用作目标暂时丢失时的参考，保证轨迹的连续性，避免轨迹中断或 ID 切换。
4. 作为匹配的基准：
   • IoU 相似度的计算需要轨迹框的位置，而这个位置就是卡尔曼滤波器预测的结果。如果没有预测位置，轨迹框可能会偏离目标，导致 IoU 计算不准确。

3.4 举例说明

假设场景：

• 当前帧有两个高置信度检测框和三条轨迹：

  • 检测框：D1 (x1=10, y1=10, w1=50, h1=50) 和 D2 (x2=100, y2=100, w2=40, h2=40)。
  • 轨迹框（上一帧的）：T1 (x=8, y=12, vx=5, vy=5)、T2 (x=98, y=102, vx=3, vy=3) 和 T3 (x=200, y=200, vx=-2, vy=-1)。

步骤：

1. 卡尔曼滤波器预测轨迹框位置：

   • 使用上一帧的位置和速度预测轨迹框：

     T1_pred = (x = 13,y = 17)

     T2_pred = (x = 101,y = 105)

     T3_pred = (x = 198,y = 199)

   • 预测轨迹框的大小保持不变。

2. 计算 IoU 相似度矩阵：

   • 对每个检测框和每个轨迹框，计算 IoU：

     

   • IoU 值越大，说明轨迹框和检测框越可能属于同一个目标。

3. 匈牙利算法匹配：

   • 根据 IoU 矩阵，将检测框分配给最可能的轨迹框：
     • D1 分配给 T1（IoU=0.8）。
     • D2 分配给 T2（IoU=0.9）。
   • T3 未匹配，进入第二阶段尝试匹配低置信度框。

在 ByteTrack 中，卡尔曼滤波器预测的轨迹框位置主要用于：

1. 提供轨迹与检测框匹配的基准位置。
2. 帮助计算 IoU，判断轨迹与检测框的相似度。
3. 保持轨迹的连续性，尤其是在目标被部分遮挡或检测器无法识别目标时。

卡尔曼滤波器的预测结果为第一阶段匹配提供了更准确的初始轨迹位置，从而提高了检测框与轨迹的匹配质量，减少了目标身份切换和轨迹中断的风险。

3.5 ByteTrack算法总结：

ByteTrack 是一款高效且高精度的多目标跟踪算法，其核心优势在于结合高置信度和低置信度检测结果，显著提升了遮挡和密集场景下的跟踪性能，同时保持了较高的实时性。算法具有结构简洁、适应性强的特点，能够灵活应用于多种检测模型。然而，其性能仍有改进空间：

• ByteTrack 对检测器质量有较强依赖，当检测器产生高误报或漏报时，算法可能引入错误轨迹。

• 当前对低置信度框的处理机制假设其主要为漏报目标，但在复杂动态场景中，低置信度框往往混杂较多噪声，容易影响跟踪精度。

• 遮挡严重或目标外观变化较大的情况下，ByteTrack 的鲁棒性仍存在不足，且由于缺乏动态在线学习能力，难以应对长时间跟踪中的漂移问题。

可以从以下几个方面改进：

• 是引入更强大的外观特征提取模块，例如基于 Transformer 的特征建模或动态更新外观特征，以增强遮挡场景中的跟踪表现；
• 是优化低置信度框的处理机制，通过时序信息或噪声过滤模块更精准地识别低置信度检测中的真实目标；
• 是集成在线学习模块，使算法能够动态适应目标外观变化，减少长时间跟踪中的漂移；
• 是通过图神经网络或自注意力机制建模多目标间的关系，以应对密集目标的遮挡和交互问题。通过这些改进，ByteTrack 有望进一步提升遮挡场景中的鲁棒性和复杂动态环境下的多目标跟踪性能。

4. 项目主要源码：

import numpy as np
import cv2
from ultralytics import YOLO
import sys

sys.path.append("D:/pyprogramfile/ByteTrack")
from yolox.tracker.byte_tracker import BYTETracker


class BYTETrackerArgs:
    track_thresh: float = 0.25
    track_buffer: int = 30
    match_thresh: float = 0.8
    aspect_ratio_thresh: float = 3.0
    min_box_area: float = 1.0
    mot20: bool = False
    
'''track_thresh
含义：目标被跟踪的置信度阈值。
用途：在检测到目标后，只有目标的检测置信度高于该阈值时，才会被认为是一个可追踪的目标。
默认值：0.25 表示检测器置信度高于 0.25 的目标会被加入跟踪。
2. track_buffer
含义：跟踪丢失后，保留目标的帧数。
用途：当一个目标未被检测到时，会进入丢失状态，跟踪器会继续保留该目标一段时间，直到达到 track_buffer 指定的帧数为止。如果在此期间目标重新出现，则会继续跟踪；否则该目标会被丢弃。
默认值：30 表示在丢失目标后的 30 帧内尝试重新关联。
3. match_thresh
含义：目标匹配的 IOU（交并比）阈值。
用途：当跟踪器尝试将当前帧的检测结果与已有的跟踪目标关联时，使用 IOU 或其他度量方法计算目标之间的匹配度。只有匹配度大于该阈值时，才会认为检测结果与现有目标匹配。
默认值：0.8 表示检测结果与跟踪目标的 IOU 大于 0.8 时认为可以匹配。
4. aspect_ratio_thresh
含义：目标宽高比阈值。
用途：用于过滤不合理的目标检测结果（如目标检测框过于扁平或不符合正常比例）。当目标的宽高比超过该值时，可能会被视为异常目标，通常用于提高跟踪的稳定性。
默认值：3.0 表示目标的宽高比大于 3 时可能被忽略。
5. min_box_area
含义：目标检测框的最小面积。
用途：过滤过小的目标检测框，防止噪声或误检测的影响。只有检测框的面积大于该值时，才会被加入跟踪。
默认值：1.0 表示目标检测框的面积需要大于 1（像素面积）。
6. mot20
含义：是否启用 MOT20（多目标跟踪挑战2020）模式。
用途：MOT20 数据集的场景更复杂，密集度更高。在启用该选项时，会调整算法的参数或逻辑以适应这些复杂场景。
默认值：False 表示不开启 MOT20 模式。 track_thresh
含义：目标被跟踪的置信度阈值。
用途：在检测到目标后，只有目标的检测置信度高于该阈值时，才会被认为是一个可追踪的目标。
默认值：0.25 表示检测器置信度高于 0.25 的目标会被加入跟踪。
'''


# 初始化 YOLO 模型
model = YOLO('yolov8l.pt')

# 打开视频文件
cap = cv2.VideoCapture("mp4/person.mp4")
fps = cap.get(cv2.CAP_PROP_FPS)
size = (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
videoWriter = cv2.VideoWriter("D:/pyprogramfile/yolov8_bytetrack/result/myperson.mp4", fourcc, fps, size)

# 初始化 ByteTrack 和轨迹字典
byte_tracker = BYTETracker(BYTETrackerArgs(), frame_rate=fps)
trajectories = {}  # 存储每个目标的轨迹

# 最大轨迹长度
MAX_TRAJECTORY_LENGTH = 10


def box_label(image, box, label='', color=(128, 128, 128), txt_color=(255, 255, 255)):
    """在图像上绘制目标框和标签"""
    p1, p2 = (int(box[0]), int(box[1])), (int(box[2]), int(box[3]))
    cv2.rectangle(image, p1, p2, color, thickness=1, lineType=cv2.LINE_AA)
    if label:
        w, h = cv2.getTextSize(label, 0, fontScale=2 / 3, thickness=1)[0]
        outside = p1[1] - h >= 3
        p2 = p1[0] + w, p1[1] - h - 3 if outside else p1[1] + h + 3
        cv2.rectangle(image, p1, p2, color, -1, cv2.LINE_AA)
        cv2.putText(image, label, (p1[0], p1[1] - 2 if outside else p1[1] + h + 2), 0, 2 / 3, txt_color, thickness=1, lineType=cv2.LINE_AA)


def draw_trajectory(image, points, color=(0, 255, 0)):
    """绘制目标轨迹"""
    for i in range(1, len(points)):
        if points[i - 1] is None or points[i] is None:
            continue
        cv2.line(image, points[i - 1], points[i], color, thickness=2)


def iou(box: np.ndarray, boxes: np.ndarray):
    xy_max = np.minimum(boxes[:, 2:], box[2:])
    xy_min = np.maximum(boxes[:, :2], box[:2])
    inter = np.clip(xy_max - xy_min, a_min=0, a_max=np.inf)
    inter = inter[:, 0] * inter[:, 1]

    area_boxes = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
    area_box = (box[2] - box[0]) * (box[3] - box[1])

    return inter / (area_box + area_boxes - inter)


while cap.isOpened():
    success, frame = cap.read()

    if success:
        results = model(frame, conf=0.5)
        outputs = results[0].boxes.data.cpu().numpy()

        if outputs is not None:
            for output in outputs:
                output[4] = 0.95  # 手动设置分数，用于 ByteTrack

            # 更新 ByteTrack 的轨迹
            tracks = byte_tracker.update(outputs[:, :5], img_info=frame.shape, img_size=frame.shape)

            for track in tracks:
                box_iou = iou(track.tlbr, outputs[:, :4])
                maxindex = np.argmax(box_iou)
                # 获取目标的边界框和 ID
                box = track.tlbr  # Top-Left, Bottom-Right
                track_id = track.track_id
                center = (int((box[0] + box[2]) / 2), int((box[1] + box[3]) / 2))

                # 更新轨迹字典
                if track_id not in trajectories:
                    trajectories[track_id] = []
                trajectories[track_id].append(center)

                # 保持轨迹长度不超过 MAX_TRAJECTORY_LENGTH
                if len(trajectories[track_id]) > MAX_TRAJECTORY_LENGTH:
                    trajectories[track_id] = trajectories[track_id][-MAX_TRAJECTORY_LENGTH:]

                # 绘制目标的边界框和 ID
                if outputs[maxindex, 5] == 0:
                    box_label(frame, outputs[maxindex], '#' + str(track.track_id) + ' person', (143, 131, 226))
                    # 绘制轨迹
                    draw_trajectory(frame, trajectories[track_id], (143, 131, 226))

                elif outputs[maxindex, 5] == 2:
                    box_label(frame, outputs[maxindex], '#' + str(track.track_id) + ' car', (167, 146, 11))
                    # 绘制轨迹
                    draw_trajectory(frame, trajectories[track_id], (167, 146, 11))
                elif outputs[maxindex, 5] == 5:
                    box_label(frame, outputs[maxindex], '#' + str(track.track_id) + ' bus', (186, 55, 2))
                    # 绘制轨迹
                    draw_trajectory(frame, trajectories[track_id], (186, 55, 2))
                elif outputs[maxindex, 5] == 7:
                    box_label(frame, outputs[maxindex], '#' + str(track.track_id) + ' truck', (19, 222, 24))
                    # 绘制轨迹
                    draw_trajectory(frame, trajectories[track_id], (19, 222, 24))

                #box_label(frame, box, f'#{track_id}', color=(255, 0, 0))
                # 绘制轨迹
                #draw_trajectory(frame, trajectories[track_id])

        # 显示帧
        cv2.putText(frame, "yy88", (25, 50),
                    cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 255), 2)
        cv2.imshow("ByteTrack with Trajectories", frame)

        # 写入视频
        videoWriter.write(frame)

        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        break

# 释放资源
cap.release()
videoWriter.release()
cv2.destroyAllWindows()

实现了对 人、轿车、公交、卡车的检测与跟踪。

数据集采用的是coco数据集，下面是coco数据集对应的分类id：

names:
                0: person
                1: bicycle
                2: car
                3: motorcycle
                4: airplane
                5: bus
                6: train
                7: truck
                8: boat
                9: traffic
                light
                10: fire
                hydrant
                11: stop
                sign
                12: parking
                meter
                13: bench
                14: bird
                15: cat
                16: dog
                17: horse
                18: sheep
                19: cow
                20: elephant
                21: bear
                22: zebra
                23: giraffe
                24: backpack
                25: umbrella
                26: handbag
                27: tie
                28: suitcase
                29: frisbee
                30: skis
                31: snowboard
                32: sports
                ball
                33: kite
                34: baseball
                bat
                35: baseball
                glove
                36: skateboard
                37: surfboard
                38: tennis
                racket
                39: bottle
                40: wine
                glass
                41: cup
                42: fork
                43: knife
                44: spoon
                45: bowl
                46: banana
                47: apple
                48: sandwich
                49: orange
                50: broccoli
                51: carrot
                52: hot
                dog
                53: pizza
                54: donut
                55: cake
                56: chair
                57: couch
                58: potted
                plant
                59: bed
                60: dining
                table
                61: toilet
                62: tv
                63: laptop
                64: mouse
                65: remote
                66: keyboard
                67: cell
                phone
                68: microwave
                69: oven
                70: toaster
                71: sink
                72: refrigerator
                73: book
                74: clock
                75: vase
                76: scissors
                77: teddy
                bear
                78: hair
                drier
                79: toothbrush

				if outputs[maxindex, 5] == 0:
                    box_label(frame, outputs[maxindex], '#' + str(track.track_id) + ' person', (143, 131, 						226))
                    # 绘制轨迹
                    draw_trajectory(frame, trajectories[track_id], (143, 131, 226))

                elif outputs[maxindex, 5] == 2:
                    box_label(frame, outputs[maxindex], '#' + str(track.track_id) + ' car', (167, 146, 11))
                    # 绘制轨迹
                    draw_trajectory(frame, trajectories[track_id], (167, 146, 11))
                elif outputs[maxindex, 5] == 5:
                    box_label(frame, outputs[maxindex], '#' + str(track.track_id) + ' bus', (186, 55, 2))
                    # 绘制轨迹
                    draw_trajectory(frame, trajectories[track_id], (186, 55, 2))
                elif outputs[maxindex, 5] == 7:
                    box_label(frame, outputs[maxindex], '#' + str(track.track_id) + ' truck', (19, 222, 24))
                    # 绘制轨迹
                    draw_trajectory(frame, trajectories[track_id], (19, 222, 24))

修改分类ID即可识别跟踪不同物体，同样也可以自己训练模型。模型检测的越准确，ByteTrack的跟踪效果越优秀。

5. 环境依赖说明：

下面是所有用到的包版本

(yolo8_bt) C:\Users\gaoyi>conda list
# packages in environment at D:\anaconda3\envs\yolo8_bt:
#
# Name                    Version                   Build  Channel
absl-py                   2.1.0                    pypi_0    pypi
awscli                    1.36.22                  pypi_0    pypi
backports-tarfile         1.2.0                    pypi_0    pypi
boto3                     1.35.81                  pypi_0    pypi
botocore                  1.35.81                  pypi_0    pypi
ca-certificates           2024.11.26           haa95532_0
cachetools                5.5.0                    pypi_0    pypi
certifi                   2024.8.30                pypi_0    pypi
charset-normalizer        3.4.0                    pypi_0    pypi
click                     8.1.7                    pypi_0    pypi
colorama                  0.4.6                    pypi_0    pypi
coloredlogs               15.0.1                   pypi_0    pypi
contourpy                 1.1.1                    pypi_0    pypi
cycler                    0.12.1                   pypi_0    pypi
cython                    3.0.11                   pypi_0    pypi
cython-bbox               0.1.3                    pypi_0    pypi
docker                    7.1.0                    pypi_0    pypi
docutils                  0.16                     pypi_0    pypi
filterpy                  1.4.5                    pypi_0    pypi
flatbuffers               24.3.25                  pypi_0    pypi
fonttools                 4.55.3                   pypi_0    pypi
google-auth               2.37.0                   pypi_0    pypi
google-auth-oauthlib      1.0.0                    pypi_0    pypi
grpcio                    1.68.1                   pypi_0    pypi
h5py                      3.11.0                   pypi_0    pypi
humanfriendly             10.0                     pypi_0    pypi
idna                      3.10                     pypi_0    pypi
imageio                   2.35.1                   pypi_0    pypi
importlib-metadata        8.5.0                    pypi_0    pypi
importlib-resources       6.4.5                    pypi_0    pypi
jaraco-classes            3.4.0                    pypi_0    pypi
jaraco-context            6.0.1                    pypi_0    pypi
jinja2                    3.1.4                    pypi_0    pypi
jmespath                  1.0.1                    pypi_0    pypi
keyring                   8.7                      pypi_0    pypi
keyrings-alt              5.0.2                    pypi_0    pypi
kiwisolver                1.4.7                    pypi_0    pypi
lap                       0.5.12                   pypi_0    pypi
lazy-loader               0.4                      pypi_0    pypi
libffi                    3.4.4                hd77b12b_1
loguru                    0.7.3                    pypi_0    pypi
markdown                  3.7                      pypi_0    pypi
markupsafe                2.1.5                    pypi_0    pypi
matplotlib                3.7.5                    pypi_0    pypi
more-itertools            10.5.0                   pypi_0    pypi
motmetrics                1.4.0                    pypi_0    pypi
mpmath                    1.3.0                    pypi_0    pypi
networkx                  3.1                      pypi_0    pypi
ninja                     1.11.1.2                 pypi_0    pypi
numpy                     1.24.4                   pypi_0    pypi
oauthlib                  3.2.2                    pypi_0    pypi
onnx                      1.8.1                    pypi_0    pypi
onnx-simplifier           0.3.5                    pypi_0    pypi
onnxoptimizer             0.3.13                   pypi_0    pypi
onnxruntime               1.8.0                    pypi_0    pypi
onnxruntime-gpu           1.19.2                   pypi_0    pypi
opencv-python             4.10.0.84                pypi_0    pypi
openssl                   3.0.15               h827c3e9_0
packaging                 24.2                     pypi_0    pypi
pandas                    2.0.3                    pypi_0    pypi
pillow                    10.4.0                   pypi_0    pypi
pip                       24.2             py38haa95532_0
protobuf                  5.29.1                   pypi_0    pypi
psutil                    6.1.0                    pypi_0    pypi
py-cpuinfo                9.0.0                    pypi_0    pypi
pyasn1                    0.6.1                    pypi_0    pypi
pyasn1-modules            0.4.1                    pypi_0    pypi
pycocotools               2.0.7                    pypi_0    pypi
pyparsing                 3.1.4                    pypi_0    pypi
pyreadline3               3.5.4                    pypi_0    pypi
python                    3.8.20               h8205438_0
python-dateutil           2.9.0.post0              pypi_0    pypi
pytz                      2024.2                   pypi_0    pypi
pywavelets                1.4.1                    pypi_0    pypi
pywin32                   308                      pypi_0    pypi
pywin32-ctypes            0.2.3                    pypi_0    pypi
pyyaml                    6.0.2                    pypi_0    pypi
requests                  2.32.3                   pypi_0    pypi
requests-oauthlib         2.0.0                    pypi_0    pypi
rsa                       4.7.2                    pypi_0    pypi
ruamel-yaml               0.18.6                   pypi_0    pypi
ruamel-yaml-clib          0.2.8                    pypi_0    pypi
s3transfer                0.10.4                   pypi_0    pypi
scikit-image              0.21.0                   pypi_0    pypi
scipy                     1.10.1                   pypi_0    pypi
seaborn                   0.13.2                   pypi_0    pypi
setuptools                75.1.0           py38haa95532_0
six                       1.17.0                   pypi_0    pypi
sqlite                    3.45.3               h2bbff1b_0
sympy                     1.13.3                   pypi_0    pypi
tabulate                  0.9.0                    pypi_0    pypi
tensorboard               2.14.0                   pypi_0    pypi
tensorboard-data-server   0.7.2                    pypi_0    pypi
thop                      0.1.1-2209072238          pypi_0    pypi
tifffile                  2023.7.10                pypi_0    pypi
torch                     1.12.0+cu113             pypi_0    pypi
torchaudio                0.12.0+cu113             pypi_0    pypi
torchvision               0.13.0+cu113             pypi_0    pypi
tqdm                      4.67.1                   pypi_0    pypi
typing-extensions         4.12.2                   pypi_0    pypi
tzdata                    2024.2                   pypi_0    pypi
ultralytics               8.3.49                   pypi_0    pypi
ultralytics-thop          2.0.13                   pypi_0    pypi
urllib3                   1.26.20                  pypi_0    pypi
vc                        14.40                haa95532_2
voluptuous                0.14.2                   pypi_0    pypi
vs2015_runtime            14.42.34433          h9531ae6_2
werkzeug                  3.0.6                    pypi_0    pypi
wheel                     0.44.0           py38haa95532_0
win32-setctime            1.2.0                    pypi_0    pypi
xmltodict                 0.14.2                   pypi_0    pypi
yolo                      0.3.1                    pypi_0    pypi
yolox                     0.1.0                     dev_0    <develop>
zipp                      3.20.2                   pypi_0    pypi

6. 代码运行方法说明：

首先git克隆ByteTrack源码到本地，并将其所需依赖（requirements.txt 、cython、cython-bbox、pycocotools）安装完成后，在安装yolo包与yolo所需的ultralytics包，就可以开始运行代码了

7. 主要实验结果的日志文件活动截图：

1、人类检测跟踪：

##### 2、车辆检测追踪：

3、日志截图：

8. 视频效果：

mytrack

myperson