DeepSORT（目标跟踪算法）中的计算观测值与状态估计的马氏距离

flyfish

在目标跟踪中，使用马氏距离可以帮助判断某个观测值是否与当前的状态估计一致。

gating_distance 是一个方法，用于计算状态分布和观测值之间的门限距离（gating distance）。门限距离通常用于数据关联和验证测量值是否合理。提示用户可以从 chi2inv95 中获取适当的距离阈值。如果only_position 为 False，则使用4自由度的卡方分布，否则使用2自由度的卡方分布。

使用 gating_distance 方法计算观测值与状态估计的马氏距离，并判断哪些观测值在合理范围内.

在源码中有这样一句

py 复制代码

  cholesky_factor = np.linalg.cholesky(covariance)

将正定矩阵分解为一个下三角矩阵及其转置的过程

Cholesky 分解是一种将正定矩阵分解为一个下三角矩阵及其转置的过程。具体来说，如果 A A A 是一个对称正定矩阵，那么它可以被分解为：

A = L L T A = LL^T A=LLT

其中 L L L 是一个下三角矩阵。

具体例子

假设我们有一个 3x3 的对称正定矩阵：
[ 4 12 − 16 12 37 − 43 − 16 − 43 98 ] \begin{bmatrix}4 & 12 & -16 \\ 12 & 37 & -43 \\ -16 & -43 & 98 \end{bmatrix} 412−161237−43−16−4398

我们要找到下三角矩阵 ( L ) 使得：
A = L L T A = LL^T A=LLT

计算过程

初始化 ( L ) 矩阵 ：
( L ) 初始化为一个与 ( A ) 维度相同的零矩阵：
L = [ l 11 0 0 l 21 l 22 0 l 31 l 32 l 33 ] L = \begin{bmatrix} l_{11} & 0 & 0 \\ l_{21} & l_{22} & 0 \\ l_{31} & l_{32} & l_{33} \end{bmatrix} L= l11l21l310l22l3200l33
计算 L L L 的元素：

计算(l_{11} ) ：
l 11 = a 11 = 4 = 2 l_{11} = \sqrt{a_{11}} = \sqrt{4} = 2 l11=a11 =4 =2
计算 ( l_{21} ) ：
l 21 = a 21 l 11 = 12 2 = 6 l_{21} = \frac{a_{21}}{l_{11}} = \frac{12}{2} = 6 l21=l11a21=212=6
计算 ( l_{31} ) ：
l 31 = a 31 l 11 = − 16 2 = − 8 l_{31} = \frac{a_{31}}{l_{11}} = \frac{-16}{2} = -8 l31=l11a31=2−16=−8
计算 ( l_{22} ) ：
l 22 = a 22 − l 21 2 = 37 − 6 2 = 37 − 36 = 1 l_{22} = \sqrt{a_{22} - l_{21}^2} = \sqrt{37 - 6^2} = \sqrt{37 - 36} = 1 l22=a22−l212 =37−62 =37−36 =1
计算 ( l_{32} ) ：
l 32 = a 32 − l 31 l 21 l 22 = − 43 − ( − 8 ) ⋅ 6 1 = − 43 + 48 1 = 5 l_{32} = \frac{a_{32} - l_{31} l_{21}}{l_{22}} = \frac{-43 - (-8) \cdot 6}{1} = \frac{-43 + 48}{1} = 5 l32=l22a32−l31l21=1−43−(−8)⋅6=1−43+48=5
计算 ( l_{33} ) ：
l 33 = a 33 − l 31 2 − l 32 2 = 98 − ( − 8 ) 2 − 5 2 = 98 − 64 − 25 = 9 = 3 l_{33} = \sqrt{a_{33} - l_{31}^2 - l_{32}^2} = \sqrt{98 - (-8)^2 - 5^2} = \sqrt{98 - 64 - 25} = \sqrt{9} = 3 l33=a33−l312−l322 =98−(−8)2−52 =98−64−25 =9 =3

构造 ( L ) 矩阵 ：
L = [ 2 0 0 6 1 0 − 8 5 3 ] L = \begin{bmatrix} 2 & 0 & 0 \\ 6 & 1 & 0 \\ -8 & 5 & 3 \end{bmatrix} L= 26−8015003
验证分解结果 ：
我们可以验证 L L T = A LL^T = A LLT=A：

L L T = [ 2 0 0 6 1 0 − 8 5 3 ] [ 2 6 − 8 0 1 5 0 0 3 ] = [ 4 12 − 16 12 37 − 43 − 16 − 43 98 ] = A LL^T = \begin{bmatrix} 2 & 0 & 0 \\ 6 & 1 & 0 \\ -8 & 5 & 3 \end{bmatrix} \begin{bmatrix} 2 & 6 & -8 \\ 0 & 1 & 5 \\ 0 & 0 & 3 \end{bmatrix} = \begin{bmatrix} 4 & 12 & -16 \\ 12 & 37 & -43 \\ -16 & -43 & 98 \end{bmatrix} = A LLT= 26−8015003 200610−853 = 412−161237−43−16−4398 =A

因此，分解是正确的。

Python 示例

我们可以使用 NumPy 来计算 Cholesky 分解：

python 复制代码

import numpy as np

# 定义矩阵 A
A = np.array([
    [4, 12, -16],
    [12, 37, -43],
    [-16, -43, 98]
])

# 计算 Cholesky 分解
L = np.linalg.cholesky(A)

# 输出结果
print("L:\n", L)
print("L * L.T:\n", np.dot(L, L.T))

运行上述代码，您将得到下三角矩阵 L L L 和验证结果 L L T LL^T LLT。

结果

python 复制代码

L:
 [[ 2.  0.  0.]
 [ 6.  1.  0.]
 [-8.  5.  3.]]
L * L.T:
 [[  4.  12. -16.]
 [ 12.  37. -43.]
 [-16. -43.  98.]]

矩阵 A A A 成功地分解为 L L T LL^T LLT。

计算观测值与状态估计的马氏距离的函数说明

py 复制代码

def gating_distance(self, mean, covariance, measurements,
                    only_position=False):

    mean, covariance = self.project(mean, covariance)
    if only_position:
        mean, covariance = mean[:2], covariance[:2, :2]
        measurements = measurements[:, :2]

    cholesky_factor = np.linalg.cholesky(covariance)
    d = measurements - mean
    z = scipy.linalg.solve_triangular(
        cholesky_factor, d.T, lower=True, check_finite=False,
        overwrite_b=True)
    squared_maha = np.sum(z * z, axis=0)
    return squared_maha

参数说明：

mean：状态分布的均值向量（8维）。
covariance：状态分布的协方差矩阵（8x8维）。
measurements：Nx4维矩阵，包含N个观测值，每个观测值的格式为 (x, y, a, h)，其中 (x, y) 是边界框的中心位置，a 是长宽比，h 是高度。
only_position（可选）：如果为 True，则只计算中心位置 (x, y) 的距离

返回值说明：

返回一个长度为 N 的数组，其中第 i 个元素包含 (mean, covariance) 和 measurements[i] 之间的平方马氏距离。

具体步骤

1 投影到测量空间 ：

mean, covariance = self.project(mean, covariance) 将状态均值和协方差矩阵投影到测量空间。
2 简化计算（如果只考虑位置） ：

if only_position: 部分只考虑位置部分，简化均值和协方差矩阵。
3 计算马氏距离 ：

cholesky_factor = np.linalg.cholesky(covariance) 计算协方差矩阵的 Cholesky 分解。

d = measurements - mean 计算观测值与均值的差值。

z = scipy.linalg.solve_triangular(cholesky_factor, d.T, lower=True, check_finite=False, overwrite_b=True) 通过解三角方程计算标准化残差。

squared_maha = np.sum(z * z, axis=0) 计算平方马氏距离。