当前位置：首页 > article >正文

深入解析SORT多目标跟踪算法：从原理到实现

article 2025/2/21 19:49:34

深入解析SORT多目标跟踪算法：从原理到实现

一、多目标跟踪概述

1.1 问题定义

多目标跟踪（Multiple Object Tracking, MOT）是计算机视觉领域的核心任务之一，旨在从视频序列中持续检测多个目标并维护其身份标识。其核心挑战在于处理目标间的遮挡、外观变化、运动模式突变等问题。

1.2 SORT算法特点

Simple Online and Realtime Tracking (SORT) 由Alex Bewley等人于2016年提出，其创新之处在于：

实时处理能力（260Hz处理速度）
简单的架构设计
检测与跟踪分离的框架
卡尔曼滤波与匈牙利算法的结合

二、SORT核心组件

2.1 目标检测器

使用现成的检测器（原文使用Faster R-CNN）
检测输出格式：[x1, y1, x2, y2, score]
检测质量直接影响跟踪性能

2.2 卡尔曼滤波器

2.2.1 状态空间定义

8维状态向量：
$\dot{u}, \dot{v}, \dot{s}, \dot{r}]^T$
其中：

(u,v)：边界框中心坐标
s：尺度（面积）
r：长宽比
带点变量为对应参数的速率

2.2.2 观测模型

4维观测向量：
$z = [u, v, s, r]^T$

2.2.3 状态转移矩阵

$\begin{bmatrix} 1 & 0 & 0 & 0 & dt & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & dt & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 & dt & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & dt \\ 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \end{bmatrix}$

2.3 匈牙利算法

用于解决检测框与跟踪轨迹的二分图匹配问题
代价矩阵使用交并比（IoU）计算
实现线性分配的高效求解

三、SORT算法流程

3.1 整体流程图

3.2 详细步骤分解

步骤1：目标检测

使用预训练检测器处理当前帧
过滤低置信度检测（建议阈值0.3）
输出检测框列表D={d1, d2,…,dn}

步骤2：轨迹预测

对现有轨迹集合T={t1, t2,…,tm}执行卡尔曼预测
预测方程：
$\mathbf{F}\mathbf{x}$
$\mathbf{F}\mathbf{P}\mathbf{F}^T + \mathbf{Q}$
其中Q为过程噪声协方差

步骤3：数据关联

计算IoU矩阵：
$\text{IoU}(t_i, d_j) = \frac{\text{Area}(t_i \cap d_j)}{\text{Area}(t_i \cup d_j)}$
构建二分图匹配：

行：预测的跟踪框
列：当前帧检测框
权重：IoU值

使用匈牙利算法求解最大匹配
设置IoU阈值（默认0.3）过滤不可靠匹配

步骤4：状态更新

对匹配成功的检测更新卡尔曼滤波：
$\mathbf{y} = \mathbf{z} - \mathbf{H}\mathbf{x}'$
$\mathbf{S} = \mathbf{H}\mathbf{P}'\mathbf{H}^T + \mathbf{R}$
$\mathbf{K} = \mathbf{P}'\mathbf{H}^T\mathbf{S}^{-1}$
$\mathbf{x} = \mathbf{x}' + \mathbf{K}\mathbf{y}$
$\mathbf{P} = (\mathbf{I} - \mathbf{K}\mathbf{H})\mathbf{P}'$

步骤5：轨迹管理

新生轨迹：未匹配的检测创建新轨迹
轨迹保留：设置最大丢失帧数（默认3帧）
轨迹删除：连续丢失超过阈值的轨迹

四、关键算法细节

4.1 卡尔曼滤波实现要点

4.1.1 噪声协方差设置

# 过程噪声协方差
Q = np.diag([10, 10, 10, 10, 1e4, 1e4, 1e4, 1e4]) 

# 观测噪声协方差
R = np.diag([1, 1, 10, 10])

4.1.2 观测矩阵设计

$\mathbf{H} = \begin{bmatrix} 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \end{bmatrix}$

4.2 数据关联优化

马氏距离过滤：在IoU匹配前进行初步筛选
$d^2 = (\mathbf{z} - \mathbf{H}\mathbf{x}')^T \mathbf{S}^{-1} (\mathbf{z} - \mathbf{H}\mathbf{x}')$
门限阈值设置（建议χ²分布95%置信区间）

4.3 轨迹管理策略

class Track:
    def __init__(self, detection):
        self.kf = KalmanFilter()
        self.hits = 1  # 连续匹配次数
        self.age = 1   # 存活帧数
        self.time_since_update = 0
        self.id = uuid4()
        
    def predict(self):
        self.kf.predict()
        self.age += 1
        self.time_since_update += 1

五、代码实现示例

5.1 卡尔曼滤波封装

class KalmanFilter:
    def __init__(self):
        self.ndim = 4
        self.dt = 1.0
        
        # 状态转移矩阵
        self.F = np.eye(8, 8)
        for i in range(4):
            self.F[i, i+4] = self.dt
            
        # 观测矩阵
        self.H = np.eye(4, 8)
        
        # 过程噪声
        self.Q = np.diag([10, 10, 10, 10, 1e4, 1e4, 1e4, 1e4])
        
        # 观测噪声
        self.R = np.diag([1, 1, 10, 10])
        
    def init(self, measurement):
        x = np.zeros((8, 1))
        x[:4] = measurement.reshape(4,1)
        P = np.eye(8) * 10
        return x, P
    
    def predict(self, x, P):
        x = self.F @ x
        P = self.F @ P @ self.F.T + self.Q
        return x, P
    
    def update(self, x, P, z):
        y = z - self.H @ x
        S = self.H @ P @ self.H.T + self.R
        K = P @ self.H.T @ np.linalg.inv(S)
        x = x + K @ y
        P = (np.eye(8) - K @ self.H) @ P
        return x, P

5.2 匈牙利算法实现

from scipy.optimize import linear_sum_assignment

def associate_detections_to_trackers(detections, trackers, iou_threshold=0.3):
    """
    使用匈牙利算法进行IoU匹配
    """
    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)
    
    for d, det in enumerate(detections):
        for t, trk in enumerate(trackers):
            iou_matrix[d, t] = iou(det, trk)
    
    # 使用匈牙利算法找到最优匹配
    row_ind, col_ind = linear_sum_assignment(-iou_matrix)
    
    matched_indices = []
    unmatched_detections = []
    for d in range(len(detections)):
        if d not in row_ind:
            unmatched_detections.append(d)
    
    for d, t in zip(row_ind, col_ind):
        if iou_matrix[d, t] < iou_threshold:
            unmatched_detections.append(d)
        else:
            matched_indices.append(np.array([d, t]))
    
    if len(matched_indices) == 0:
        matched_indices = np.empty((0,2), dtype=int)
    else:
        matched_indices = np.stack(matched_indices, axis=0)
    
    return matched_indices, np.array(unmatched_detections)