目标跟踪 SORT：简单在线实时跟踪器

FreeGuideOnline 最新 2026-06-19

目标跟踪 SORT：简单在线实时跟踪器完全指南

在机器视觉领域，多目标跟踪（Multiple Object Tracking, MOT）是连接检测与行为分析的关键桥梁。当检测器在每一帧中找到目标后，我们需要将跨帧的同名目标关联起来，形成稳定的轨迹。SORT（Simple Online and Realtime Tracking）正是这样一款经典的轻量级解决方案——它用极简的工程实现，平衡了速度与精度，至今仍是很多实时跟踪系统的基线选择。本教程将从零带您彻底理解 SORT 的原理与实现。

SORT 是什么？设计哲学与核心思想

SORT 的全称非常直白：Simple Online and Realtime Tracking。它的设计遵循三个原则：

  • 简单性：尽量避免复杂的模型，仅依赖检测结果与基本运动假设。
  • 在线性：只使用过去和当前帧的信息，不依赖未来帧。这对实时系统至关重要。
  • 实时性：算法必须足够高效，能够在常见硬件上以远超视频帧率的速度运行。

SORT 的核心思想可以概括为：将跟踪问题分解为两个独立子任务——状态预测与数据关联。首先用卡尔曼滤波器对每个目标的运动状态进行建模与预测，然后通过匈牙利算法将当前帧的检测框与已有轨迹进行匹配。整个流程围绕“检测框”展开，完全不使用图像外观特征，仅用框的位置和大小进行跟踪。

算法流程：一帧数据的完整处理逻辑

从接收到一帧检测结果开始，SORT 的执行流程高度结构化，非常便于理解与复现。

步骤 1：卡尔曼滤波预测

对于当前时刻存在的所有跟踪轨迹（Tracklets），使用卡尔曼滤波器的预测步骤，推断它们在当前帧的位置。每个目标的状态向量定义为：

x = [u, v, s, r, u_dot, v_dot, s_dot]

其中：

  • u 和 v：目标中心点的水平和垂直位置（图像坐标）。
  • s：目标边界框的面积（scale）。
  • r：边界框的宽高比（aspect ratio），通常设为常数。
  • u_dot, v_dot, s_dot：对应分量的变化速率。

通过匀速运动模型，状态转移矩阵简单地保持位置与速度的线性关系，预测框的坐标和面积将据此更新。这一步的意义在于：即使检测器偶尔漏检，卡尔曼预测也能让轨迹短暂“存活”，保持连续性。

步骤 2：数据关联（匈牙利算法）

将当前帧的检测结果（Detection）与已经存在的轨迹预测框进行匹配。匹配的成本矩阵由 IOU 距离构成：即计算每一对预测框与检测框的交并比，并取 1 - IOU 作为代价。IOU 越小，代价越大，表明两个框越不可能是同一目标。

得到代价矩阵后，使用匈牙利算法寻找全局最优的二分匹配。为了过滤低质量匹配，还会设置一个最小 IOU 阈值（通常为 0.3）。如果预测框与检测框的 IOU 低于该阈值，则被视为不匹配。

匹配结果分为三类：

  • 匹配成功：检测框与某个跟踪轨迹关联，用检测框更新该轨迹的卡尔曼状态。
  • 检测未匹配：当前帧新出现的目标，初始化一个新的卡尔曼轨迹。
  • 轨迹未匹配：可能目标离开视野或被短暂遮挡，先保留该轨迹，但增加其“丢失计数”。

步骤 3：轨迹生命周期管理

每个轨迹都有一个计数器记录其连续未被匹配的次数。当计数器超过预设的最大阈值（一般为 1 帧或少许几帧），就认为该目标已经离开，轨迹被删除。新创建的轨迹通常需要连续若干帧被成功匹配（称为“命中次数”达到最小阈值），才被认定为有效目标并输出结果，这样可以避免杂散检测导致的虚假轨迹。

核心组件深度解析

理解了整体流程后，我们深入剖析支撑 SORT 的三个关键模块。

卡尔曼滤波器：运动模型与观测更新

SORT 使用标准卡尔曼滤波器，其状态向量和观测向量定义如下。观测向量直接来自检测框：

z = [u, v, s, r]

状态转移通过匀速运动模型实现，协方差矩阵初始假设速度分量具有较高不确定性。当检测框与轨迹匹配成功后，执行卡尔曼更新步骤，利用检测位置校正状态估计；如果轨迹未匹配，则只进行预测而不更新，状态的不确定性会逐渐增大。这种机制使得短期遮挡可以由线性运动假设填补，而长期丢失的轨迹会因不确定性过高而自然终结。

匈牙利算法与 IOU 匹配

为什么选择 IOU 作为关联度量？因为 SORT 侧重速度，IOU 计算极其高效，且在帧率较高的情况下，相邻帧间同一目标的移动通常很小，IOU 是非常可靠的关联依据。匈牙利算法能够在 O(n³) 时间内解决二分图的最大匹配，即使目标数量达到数百个，耗时仍可忽略不计。

值得注意的是，SORT 完全忽略了目标的外观特征，这在目标稠密交互或快速移动时容易出错，但也是其能够保持极高速度的重要原因。

状态初始化与消失管理

当检测未匹配时，SORT 直接用检测框的测量值初始化一个全新的卡尔曼轨迹。此时，面积变化率初始化为零，速度分量根据位置无法直接观测，协方差矩阵会给予速度较大的初始不确定性，让滤波器后续自适应调整。

轨迹删除的控制参数非常敏感：最大丢失帧数太大会产生过多幽灵轨迹，太小则几乎不允许任何遮挡。典型设置 TTL（time-to-live）为 1 帧，这意味着只要相邻两帧关联中断，轨迹立即终止。这的确会导致身份切换频繁，但保证了系统的实时输出干净利落。

SORT 的优缺点与适用场景

任何一个算法都有其边界和取舍，了解这些有助于我们在实际项目中合理选型。

优点

  • 极快的速度：核心运算只有卡尔曼滤波和匈牙利匹配，在 CPU 上轻松达到数百 FPS，甚至上千 FPS。
  • 实现简单：代码量小，依赖少，易于部署和调试。
  • 可作为强大基线：许多更复杂的跟踪器（如 DeepSORT）都是在 SORT 的基础上扩展而来。
  • 在线实时：非常适合需要即时反馈的交互系统或边缘设备。

缺点

  • 身份切换频繁：当目标互相遮挡或交叉时，因为没有外观模型，IOU 匹配容易错误地将身份互换，ID switch 计数较高。
  • 对检测器依赖严重：SORT 本质上是一个检测驱动的跟踪器，跟踪质量完全取决于检测器的准确性和召回率。漏检或误检会直接导致轨迹断裂或虚假轨迹。
  • 无法处理长期遮挡：线性运动模型在遮挡超过几帧后就会失效，目标重新出现时会生成新的身份。

适用场景

  • 行人多目标跟踪（如监控视频分析）中，帧率较高、人群密度适中的情形。
  • 需要快速搭建原型系统，或对跟踪延迟有严格要求的产品。
  • 作为二次开发的基础，在 SORT 的框架上添加外观特征、更复杂的运动模型等。

实战：用 Python 实现最简 SORT

为了让读者真正理解原理，这里提供一个面向理解的最简实现骨架（基于 Python 和 NumPy），省略了部分边界条件的鲁棒处理，但完整表达了核心逻辑。

import numpy as np
from filterpy.kalman import KalmanFilter
from scipy.optimize import linear_sum_assignment

def iou(bb_test, bb_gt):
    """
    计算两个边界框的 IOU, bb格式为[x1,y1,x2,y2]
    """
    xx1 = max(bb_test[0], bb_gt[0])
    yy1 = max(bb_test[1], bb_gt[1])
    xx2 = min(bb_test[2], bb_gt[2])
    yy2 = min(bb_test[3], bb_gt[3])
    if xx2 < xx1 or yy2 < yy1:
        return 0.0
    inter = (xx2 - xx1) * (yy2 - yy1)
    area1 = (bb_test[2] - bb_test[0]) * (bb_test[3] - bb_test[1])
    area2 = (bb_gt[2] - bb_gt[0]) * (bb_gt[3] - bb_gt[1])
    return inter / (area1 + area2 - inter)

class KalmanBoxTracker:
    count = 0
    def __init__(self, bbox):
        self.kf = KalmanFilter(dim_x=7, dim_z=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]])
        # 初始状态：由bbox初始化，速度=0，面积变化率=0
        self.kf.x[:4] = self._bbox_to_z(bbox)
        self.time_since_update = 0
        self.id = KalmanBoxTracker.count
        KalmanBoxTracker.count += 1
        self.hits = 0

    def _bbox_to_z(self, bbox):
        x1,y1,x2,y2 = bbox
        w = x2 - x1; h = y2 - y1
        return np.array([x1+w/2., y1+h/2., w*h, float(w)/h])

    def predict(self):
        self.kf.predict()
        self.time_since_update += 1
        return self.get_state()

    def update(self, bbox):
        self.time_since_update = 0
        self.hits += 1
        self.kf.update(self._bbox_to_z(bbox))

    def get_state(self):
        x = self.kf.x[:4]
        u,v,s,r = x
        w = np.sqrt(s * r) if r>0 else np.sqrt(s)
        h = s / w if w>0 else s
        x1 = u - w/2.
        y1 = v - h/2.
        x2 = u + w/2.
        y2 = v + h/2.
        return [x1,y1,x2,y2]

def associate_detections(trackers, detections, iou_threshold=0.3):
    if len(trackers) == 0:
        return np.zeros((0,2), dtype=int), list(range(len(detections))), []
    iou_matrix = np.zeros((len(trackers), len(detections)))
    for t,trk in enumerate(trackers):
        for d,det in enumerate(detections):
            iou_matrix[t,d] = iou(trk, det)
    row_ind, col_ind = linear_sum_assignment(-iou_matrix)
    unmatched_tracks = []
    unmatched_detections = []
    matches = []
    for t in range(len(trackers)):
        if t not in row_ind:
            unmatched_tracks.append(t)
    for d in range(len(detections)):
        if d not in col_ind:
            unmatched_detections.append(d)
    for row, col in zip(row_ind,col_ind):
        if iou_matrix[row,col] < iou_threshold:
            unmatched_tracks.append(row)
            unmatched_detections.append(col)
        else:
            matches.append([row, col])
    return matches, unmatched_detections, unmatched_tracks

# 主循环示意（每一帧调用）：
# trackers: 当前活跃的 KalmanBoxTracker 列表
# detections: 当前帧检测框列表 [x1,y1,x2,y2,...]
def step(trackers, detections):
    predicted_states = [t.predict() for t in trackers]
    matches, unmatched_dets, unmatched_trks = associate_detections(
        predicted_states, detections)
    # 更新匹配的轨迹
    for t_idx, d_idx in matches:
        trackers[t_idx].update(detections[d_idx])
    # 创建新轨迹
    for d_idx in unmatched_dets:
        trackers.append(KalmanBoxTracker(detections[d_idx]))
    # 删除丢失太久的轨迹
    trackers = [t for t in trackers if t.time_since_update <= 1]
    # 可返回命中数足够的轨迹作为有效输出
    return [t for t in trackers if t.hits >= 3]

上述代码完整展示了 SORT 的预测、匹配、更新与生命周期管理。你可以将其嵌入任意检测器后处理中，实现一个可工作的跟踪管道。

从 SORT 到 DeepSORT：一条简单的进化之路

SORT 为实时多目标跟踪奠定了坚实基础，但其身份切换问题催生了下一个里程碑——DeepSORT。DeepSORT 在 SORT 框架上主要增加了两个组件：

  1. 外观特征提取：用一个预训练的 ReID 网络为每个检测框提取深度特征向量，匹配时结合运动信息和外观余弦距离。
  2. 级联匹配机制：优先匹配更新频率高的活跃轨迹，有效减少因轨迹丢失过久导致的 ID 混淆。

有了本教程对 SORT 的扎实理解，再去学习 DeepSORT 或其他现代跟踪器，你会发现核心骨架一脉相承，仅是关联度量和生命周期的优化。

总结

SORT 用卡尔曼滤波和匈牙利算法搭配 IOU 匹配，证明了在实时多目标跟踪中，简单与高效可以兼得。它虽然面对密集遮挡和长期丢失时力不从心，但作为理解跟踪问题的基础框架，以及许多实际项目的起点，价值永恒。希望本教程帮助您彻底掌握了 SORT 的精髓，并能够将其灵活运用到自己的工作中。