انتقل إلى المحتوى

مرجع ل ultralytics/trackers/utils/kalman_filter.py

ملاحظه

هذا الملف متاح في https://github.com/ultralytics/ultralytics/ نقطة / الرئيسية /ultralytics/ بتتبع / المرافق / kalman_filter.py. إذا اكتشفت مشكلة ، فيرجى المساعدة في إصلاحها من خلال المساهمة في طلب 🛠️ سحب. شكرا لك 🙏!



ultralytics.trackers.utils.kalman_filter.KalmanFilterXYAH

ل bytetrack. مرشح Kalman بسيط لتتبع المربعات المحيطة في مساحة الصورة.

يحتوي فضاء الحالة 8 الأبعاد (x ، y ، a ، h ، vx ، vy ، va ، vh) على موضع مركز المربع المحيط (x ، y) ، الجانب النسبة A والارتفاع h وسرعات كل منهما.

تتبع حركة الجسم نموذج سرعة ثابتة. يتم أخذ موقع المربع المحيط (x ، y ، a ، h) على أنه مباشر مراقبة فضاء الحالة (نموذج المراقبة الخطية).

شفرة المصدر في ultralytics/trackers/utils/kalman_filter.py
class KalmanFilterXYAH:
    """
    For bytetrack. A simple Kalman filter for tracking bounding boxes in image space.

    The 8-dimensional state space (x, y, a, h, vx, vy, va, vh) contains the bounding box center position (x, y), aspect
    ratio a, height h, and their respective velocities.

    Object motion follows a constant velocity model. The bounding box location (x, y, a, h) is taken as direct
    observation of the state space (linear observation model).
    """

    def __init__(self):
        """Initialize Kalman filter model matrices with motion and observation uncertainty weights."""
        ndim, dt = 4, 1.0

        # Create Kalman filter model matrices
        self._motion_mat = np.eye(2 * ndim, 2 * ndim)
        for i in range(ndim):
            self._motion_mat[i, ndim + i] = dt
        self._update_mat = np.eye(ndim, 2 * ndim)

        # Motion and observation uncertainty are chosen relative to the current state estimate. These weights control
        # the amount of uncertainty in the model.
        self._std_weight_position = 1.0 / 20
        self._std_weight_velocity = 1.0 / 160

    def initiate(self, measurement: np.ndarray) -> tuple:
        """
        Create track from unassociated measurement.

        Args:
            measurement (ndarray): Bounding box coordinates (x, y, a, h) with center position (x, y), aspect ratio a,
                and height h.

        Returns:
            (tuple[ndarray, ndarray]): Returns the mean vector (8 dimensional) and covariance matrix (8x8 dimensional) of
                the new track. Unobserved velocities are initialized to 0 mean.
        """
        mean_pos = measurement
        mean_vel = np.zeros_like(mean_pos)
        mean = np.r_[mean_pos, mean_vel]

        std = [
            2 * self._std_weight_position * measurement[3],
            2 * self._std_weight_position * measurement[3],
            1e-2,
            2 * self._std_weight_position * measurement[3],
            10 * self._std_weight_velocity * measurement[3],
            10 * self._std_weight_velocity * measurement[3],
            1e-5,
            10 * self._std_weight_velocity * measurement[3],
        ]
        covariance = np.diag(np.square(std))
        return mean, covariance

    def predict(self, mean: np.ndarray, covariance: np.ndarray) -> tuple:
        """
        Run Kalman filter prediction step.

        Args:
            mean (ndarray): The 8 dimensional mean vector of the object state at the previous time step.
            covariance (ndarray): The 8x8 dimensional covariance matrix of the object state at the previous time step.

        Returns:
            (tuple[ndarray, ndarray]): Returns the mean vector and covariance matrix of the predicted state. Unobserved
                velocities are initialized to 0 mean.
        """
        std_pos = [
            self._std_weight_position * mean[3],
            self._std_weight_position * mean[3],
            1e-2,
            self._std_weight_position * mean[3],
        ]
        std_vel = [
            self._std_weight_velocity * mean[3],
            self._std_weight_velocity * mean[3],
            1e-5,
            self._std_weight_velocity * mean[3],
        ]
        motion_cov = np.diag(np.square(np.r_[std_pos, std_vel]))

        mean = np.dot(mean, self._motion_mat.T)
        covariance = np.linalg.multi_dot((self._motion_mat, covariance, self._motion_mat.T)) + motion_cov

        return mean, covariance

    def project(self, mean: np.ndarray, covariance: np.ndarray) -> tuple:
        """
        Project state distribution to measurement space.

        Args:
            mean (ndarray): The state's mean vector (8 dimensional array).
            covariance (ndarray): The state's covariance matrix (8x8 dimensional).

        Returns:
            (tuple[ndarray, ndarray]): Returns the projected mean and covariance matrix of the given state estimate.
        """
        std = [
            self._std_weight_position * mean[3],
            self._std_weight_position * mean[3],
            1e-1,
            self._std_weight_position * mean[3],
        ]
        innovation_cov = np.diag(np.square(std))

        mean = np.dot(self._update_mat, mean)
        covariance = np.linalg.multi_dot((self._update_mat, covariance, self._update_mat.T))
        return mean, covariance + innovation_cov

    def multi_predict(self, mean: np.ndarray, covariance: np.ndarray) -> tuple:
        """
        Run Kalman filter prediction step (Vectorized version).

        Args:
            mean (ndarray): The Nx8 dimensional mean matrix of the object states at the previous time step.
            covariance (ndarray): The Nx8x8 covariance matrix of the object states at the previous time step.

        Returns:
            (tuple[ndarray, ndarray]): Returns the mean vector and covariance matrix of the predicted state. Unobserved
                velocities are initialized to 0 mean.
        """
        std_pos = [
            self._std_weight_position * mean[:, 3],
            self._std_weight_position * mean[:, 3],
            1e-2 * np.ones_like(mean[:, 3]),
            self._std_weight_position * mean[:, 3],
        ]
        std_vel = [
            self._std_weight_velocity * mean[:, 3],
            self._std_weight_velocity * mean[:, 3],
            1e-5 * np.ones_like(mean[:, 3]),
            self._std_weight_velocity * mean[:, 3],
        ]
        sqr = np.square(np.r_[std_pos, std_vel]).T

        motion_cov = [np.diag(sqr[i]) for i in range(len(mean))]
        motion_cov = np.asarray(motion_cov)

        mean = np.dot(mean, self._motion_mat.T)
        left = np.dot(self._motion_mat, covariance).transpose((1, 0, 2))
        covariance = np.dot(left, self._motion_mat.T) + motion_cov

        return mean, covariance

    def update(self, mean: np.ndarray, covariance: np.ndarray, measurement: np.ndarray) -> tuple:
        """
        Run Kalman filter correction step.

        Args:
            mean (ndarray): The predicted state's mean vector (8 dimensional).
            covariance (ndarray): The state's covariance matrix (8x8 dimensional).
            measurement (ndarray): The 4 dimensional measurement vector (x, y, a, h), where (x, y) is the center
                position, a the aspect ratio, and h the height of the bounding box.

        Returns:
            (tuple[ndarray, ndarray]): Returns the measurement-corrected state distribution.
        """
        projected_mean, projected_cov = self.project(mean, covariance)

        chol_factor, lower = scipy.linalg.cho_factor(projected_cov, lower=True, check_finite=False)
        kalman_gain = scipy.linalg.cho_solve(
            (chol_factor, lower), np.dot(covariance, self._update_mat.T).T, check_finite=False
        ).T
        innovation = measurement - projected_mean

        new_mean = mean + np.dot(innovation, kalman_gain.T)
        new_covariance = covariance - np.linalg.multi_dot((kalman_gain, projected_cov, kalman_gain.T))
        return new_mean, new_covariance

    def gating_distance(
        self,
        mean: np.ndarray,
        covariance: np.ndarray,
        measurements: np.ndarray,
        only_position: bool = False,
        metric: str = "maha",
    ) -> np.ndarray:
        """
        Compute gating distance between state distribution and measurements. A suitable distance threshold can be
        obtained from `chi2inv95`. If `only_position` is False, the chi-square distribution has 4 degrees of freedom,
        otherwise 2.

        Args:
            mean (ndarray): Mean vector over the state distribution (8 dimensional).
            covariance (ndarray): Covariance of the state distribution (8x8 dimensional).
            measurements (ndarray): An Nx4 matrix of N measurements, each in format (x, y, a, h) where (x, y)
                is the bounding box center position, a the aspect ratio, and h the height.
            only_position (bool, optional): If True, distance computation is done with respect to the bounding box
                center position only. Defaults to False.
            metric (str, optional): The metric to use for calculating the distance. Options are 'gaussian' for the
                squared Euclidean distance and 'maha' for the squared Mahalanobis distance. Defaults to 'maha'.

        Returns:
            (np.ndarray): Returns an array of length N, where the i-th element contains the squared distance between
                (mean, covariance) and `measurements[i]`.
        """
        mean, covariance = self.project(mean, covariance)
        if only_position:
            mean, covariance = mean[:2], covariance[:2, :2]
            measurements = measurements[:, :2]

        d = measurements - mean
        if metric == "gaussian":
            return np.sum(d * d, axis=1)
        elif metric == "maha":
            cholesky_factor = np.linalg.cholesky(covariance)
            z = scipy.linalg.solve_triangular(cholesky_factor, d.T, lower=True, check_finite=False, overwrite_b=True)
            return np.sum(z * z, axis=0)  # square maha
        else:
            raise ValueError("Invalid distance metric")

__init__()

تهيئة مصفوفات نموذج مرشح كالمان بأوزان عدم اليقين في الحركة والملاحظة.

شفرة المصدر في ultralytics/trackers/utils/kalman_filter.py
18 19 20 21 22 2324252627 28293031
def __init__(self):
    """Initialize Kalman filter model matrices with motion and observation uncertainty weights."""
    ndim, dt = 4, 1.0

    # Create Kalman filter model matrices
    self._motion_mat = np.eye(2 * ndim, 2 * ndim)
    for i in range(ndim):
        self._motion_mat[i, ndim + i] = dt
    self._update_mat = np.eye(ndim, 2 * ndim)

    # Motion and observation uncertainty are chosen relative to the current state estimate. These weights control
    # the amount of uncertainty in the model.
    self._std_weight_position = 1.0 / 20
    self._std_weight_velocity = 1.0 / 160

gating_distance(mean, covariance, measurements, only_position=False, metric='maha')

حساب مسافة البوابة بين توزيع الحالة والقياسات. يمكن أن تكون عتبة المسافة المناسبة تم الحصول عليها من chi2inv95. لو only_position خطأ، توزيع مربع كاي له ٤ درجات من الحرية خلاف ذلك 2.

البارامترات:

اسم نوع وصف افتراضي
mean ndarray

متوسط المتجه على توزيع الحالة (8 أبعاد).

مطلوب
covariance ndarray

التباين المشترك لتوزيع الحالة (8 × 8 أبعاد).

مطلوب
measurements ndarray

مصفوفة Nx4 من قياسات N ، كل منها بتنسيق (x ، y ، a ، h) حيث (x ، y) هو موضع مركز المربع المحيط ، ونسبة العرض إلى الارتفاع ، و h الارتفاع.

مطلوب
only_position bool

إذا كان هذا صحيحا ، حساب المسافة فيما يتعلق بالمربع المحيط موقف المركز فقط. الإعدادات الافتراضية إلى خطأ.

False
metric str

المقياس الذي يجب استخدامه لحساب المسافة. الخيارات "غاوسية" ل تربيع المسافة الإقليدية و "مها" لمسافة ماهالانوبيس التربيعية. الإعدادات الافتراضية ل "maha".

'maha'

ارجاع:

نوع وصف
ndarray

إرجاع صفيف بطول N، حيث يحتوي العنصر i-th على المسافة التربيعية بين (المتوسط ، التباين) و measurements[i].

شفرة المصدر في ultralytics/trackers/utils/kalman_filter.py
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199200201 202 203 204 205 206207208209 210 211 212 213 214 215 216
def gating_distance(
    self,
    mean: np.ndarray,
    covariance: np.ndarray,
    measurements: np.ndarray,
    only_position: bool = False,
    metric: str = "maha",
) -> np.ndarray:
    """
    Compute gating distance between state distribution and measurements. A suitable distance threshold can be
    obtained from `chi2inv95`. If `only_position` is False, the chi-square distribution has 4 degrees of freedom,
    otherwise 2.

    Args:
        mean (ndarray): Mean vector over the state distribution (8 dimensional).
        covariance (ndarray): Covariance of the state distribution (8x8 dimensional).
        measurements (ndarray): An Nx4 matrix of N measurements, each in format (x, y, a, h) where (x, y)
            is the bounding box center position, a the aspect ratio, and h the height.
        only_position (bool, optional): If True, distance computation is done with respect to the bounding box
            center position only. Defaults to False.
        metric (str, optional): The metric to use for calculating the distance. Options are 'gaussian' for the
            squared Euclidean distance and 'maha' for the squared Mahalanobis distance. Defaults to 'maha'.

    Returns:
        (np.ndarray): Returns an array of length N, where the i-th element contains the squared distance between
            (mean, covariance) and `measurements[i]`.
    """
    mean, covariance = self.project(mean, covariance)
    if only_position:
        mean, covariance = mean[:2], covariance[:2, :2]
        measurements = measurements[:, :2]

    d = measurements - mean
    if metric == "gaussian":
        return np.sum(d * d, axis=1)
    elif metric == "maha":
        cholesky_factor = np.linalg.cholesky(covariance)
        z = scipy.linalg.solve_triangular(cholesky_factor, d.T, lower=True, check_finite=False, overwrite_b=True)
        return np.sum(z * z, axis=0)  # square maha
    else:
        raise ValueError("Invalid distance metric")

initiate(measurement)

إنشاء مسار من قياس غير مرتبط.

البارامترات:

اسم نوع وصف افتراضي
measurement ndarray

إحداثيات المربع المحيط (x ، y ، a ، h) مع موضع المركز (x ، y) ، نسبة العرض إلى الارتفاع a ، والارتفاع ح.

مطلوب

ارجاع:

نوع وصف
tuple[ndarray, ndarray]

إرجاع المتجه المتوسط (8 أبعاد) ومصفوفة التغاير (8x8 أبعاد) ل المسار الجديد. يتم تهيئة السرعات غير المرصودة إلى 0 يعني.

شفرة المصدر في ultralytics/trackers/utils/kalman_filter.py
33 34 35 36 37 38 39 40 41 42 43 44 45 464748 49 50 515253 5455 5657585960
def initiate(self, measurement: np.ndarray) -> tuple:
    """
    Create track from unassociated measurement.

    Args:
        measurement (ndarray): Bounding box coordinates (x, y, a, h) with center position (x, y), aspect ratio a,
            and height h.

    Returns:
        (tuple[ndarray, ndarray]): Returns the mean vector (8 dimensional) and covariance matrix (8x8 dimensional) of
            the new track. Unobserved velocities are initialized to 0 mean.
    """
    mean_pos = measurement
    mean_vel = np.zeros_like(mean_pos)
    mean = np.r_[mean_pos, mean_vel]

    std = [
        2 * self._std_weight_position * measurement[3],
        2 * self._std_weight_position * measurement[3],
        1e-2,
        2 * self._std_weight_position * measurement[3],
        10 * self._std_weight_velocity * measurement[3],
        10 * self._std_weight_velocity * measurement[3],
        1e-5,
        10 * self._std_weight_velocity * measurement[3],
    ]
    covariance = np.diag(np.square(std))
    return mean, covariance

multi_predict(mean, covariance)

قم بتشغيل خطوة التنبؤ بمرشح Kalman (الإصدار المتجه).

البارامترات:

اسم نوع وصف افتراضي
mean ndarray

مصفوفة متوسط الأبعاد Nx8 لحالات الكائن في الخطوة الزمنية السابقة.

مطلوب
covariance ndarray

مصفوفة التغاير Nx8x8 لحالات الكائن في الخطوة الزمنية السابقة.

مطلوب

ارجاع:

نوع وصف
tuple[ndarray, ndarray]

ترجع هذه الدالة المتجه المتوسط ومصفوفة التغاير للحالة المتوقعة. مخفي تتم تهيئة السرعات إلى 0 يعني.

شفرة المصدر في ultralytics/trackers/utils/kalman_filter.py
116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138139 140 141 142143 144 145 146147148149
def multi_predict(self, mean: np.ndarray, covariance: np.ndarray) -> tuple:
    """
    Run Kalman filter prediction step (Vectorized version).

    Args:
        mean (ndarray): The Nx8 dimensional mean matrix of the object states at the previous time step.
        covariance (ndarray): The Nx8x8 covariance matrix of the object states at the previous time step.

    Returns:
        (tuple[ndarray, ndarray]): Returns the mean vector and covariance matrix of the predicted state. Unobserved
            velocities are initialized to 0 mean.
    """
    std_pos = [
        self._std_weight_position * mean[:, 3],
        self._std_weight_position * mean[:, 3],
        1e-2 * np.ones_like(mean[:, 3]),
        self._std_weight_position * mean[:, 3],
    ]
    std_vel = [
        self._std_weight_velocity * mean[:, 3],
        self._std_weight_velocity * mean[:, 3],
        1e-5 * np.ones_like(mean[:, 3]),
        self._std_weight_velocity * mean[:, 3],
    ]
    sqr = np.square(np.r_[std_pos, std_vel]).T

    motion_cov = [np.diag(sqr[i]) for i in range(len(mean))]
    motion_cov = np.asarray(motion_cov)

    mean = np.dot(mean, self._motion_mat.T)
    left = np.dot(self._motion_mat, covariance).transpose((1, 0, 2))
    covariance = np.dot(left, self._motion_mat.T) + motion_cov

    return mean, covariance

predict(mean, covariance)

قم بتشغيل خطوة التنبؤ بمرشح Kalman.

البارامترات:

اسم نوع وصف افتراضي
mean ndarray

متجه متوسط 8 أبعاد لحالة الكائن في الخطوة الزمنية السابقة.

مطلوب
covariance ndarray

مصفوفة التغاير المشترك الأبعاد 8x8 لحالة الكائن في الخطوة الزمنية السابقة.

مطلوب

ارجاع:

نوع وصف
tuple[ndarray, ndarray]

ترجع هذه الدالة المتجه المتوسط ومصفوفة التغاير للحالة المتوقعة. مخفي تتم تهيئة السرعات إلى 0 يعني.

شفرة المصدر في ultralytics/trackers/utils/kalman_filter.py
62 63 64 65 66 67 68 69 70 71 7273 74 75 76 77 78 79 80 81 82 838485868788899091
def predict(self, mean: np.ndarray, covariance: np.ndarray) -> tuple:
    """
    Run Kalman filter prediction step.

    Args:
        mean (ndarray): The 8 dimensional mean vector of the object state at the previous time step.
        covariance (ndarray): The 8x8 dimensional covariance matrix of the object state at the previous time step.

    Returns:
        (tuple[ndarray, ndarray]): Returns the mean vector and covariance matrix of the predicted state. Unobserved
            velocities are initialized to 0 mean.
    """
    std_pos = [
        self._std_weight_position * mean[3],
        self._std_weight_position * mean[3],
        1e-2,
        self._std_weight_position * mean[3],
    ]
    std_vel = [
        self._std_weight_velocity * mean[3],
        self._std_weight_velocity * mean[3],
        1e-5,
        self._std_weight_velocity * mean[3],
    ]
    motion_cov = np.diag(np.square(np.r_[std_pos, std_vel]))

    mean = np.dot(mean, self._motion_mat.T)
    covariance = np.linalg.multi_dot((self._motion_mat, covariance, self._motion_mat.T)) + motion_cov

    return mean, covariance

project(mean, covariance)

توزيع حالة المشروع على مساحة القياس.

البارامترات:

اسم نوع وصف افتراضي
mean ndarray

متجه متوسط الحالة (صفيف 8 أبعاد).

مطلوب
covariance ndarray

مصفوفة التغاير في الولاية (8 × 8 أبعاد).

مطلوب

ارجاع:

نوع وصف
tuple[ndarray, ndarray]

إرجاع المتوسط المتوقع ومصفوفة التغاير لتقدير الحالة المحدد.

شفرة المصدر في ultralytics/trackers/utils/kalman_filter.py
93 94 95 96 97 98  99 100 101 102 103 104 105  106 107 108 109 110 111 112  113 114
def project(self, mean: np.ndarray, covariance: np.ndarray) -> tuple:
    """
    Project state distribution to measurement space.

    Args:
        mean (ndarray): The state's mean vector (8 dimensional array).
        covariance (ndarray): The state's covariance matrix (8x8 dimensional).

    Returns:
        (tuple[ndarray, ndarray]): Returns the projected mean and covariance matrix of the given state estimate.
    """
    std = [
        self._std_weight_position * mean[3],
        self._std_weight_position * mean[3],
        1e-1,
        self._std_weight_position * mean[3],
    ]
    innovation_cov = np.diag(np.square(std))

    mean = np.dot(self._update_mat, mean)
    covariance = np.linalg.multi_dot((self._update_mat, covariance, self._update_mat.T))
    return mean, covariance + innovation_cov

update(mean, covariance, measurement)

قم بتشغيل خطوة تصحيح مرشح كالمان.

البارامترات:

اسم نوع وصف افتراضي
mean ndarray

المتجه المتوسط للحالة المتوقعة (8 أبعاد).

مطلوب
covariance ndarray

مصفوفة التغاير في الولاية (8 × 8 أبعاد).

مطلوب
measurement ndarray

متجه القياس 4 الأبعاد (x ، y ، a ، h) ، حيث (x ، y) هو المركز الموضع ، ونسبة العرض إلى الارتفاع ، و h ارتفاع المربع المحيط.

مطلوب

ارجاع:

نوع وصف
tuple[ndarray, ndarray]

ترجع توزيع الحالة المصححة للقياس.

شفرة المصدر في ultralytics/trackers/utils/kalman_filter.py
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166167 168 169 170 171 172173 174
def update(self, mean: np.ndarray, covariance: np.ndarray, measurement: np.ndarray) -> tuple:
    """
    Run Kalman filter correction step.

    Args:
        mean (ndarray): The predicted state's mean vector (8 dimensional).
        covariance (ndarray): The state's covariance matrix (8x8 dimensional).
        measurement (ndarray): The 4 dimensional measurement vector (x, y, a, h), where (x, y) is the center
            position, a the aspect ratio, and h the height of the bounding box.

    Returns:
        (tuple[ndarray, ndarray]): Returns the measurement-corrected state distribution.
    """
    projected_mean, projected_cov = self.project(mean, covariance)

    chol_factor, lower = scipy.linalg.cho_factor(projected_cov, lower=True, check_finite=False)
    kalman_gain = scipy.linalg.cho_solve(
        (chol_factor, lower), np.dot(covariance, self._update_mat.T).T, check_finite=False
    ).T
    innovation = measurement - projected_mean

    new_mean = mean + np.dot(innovation, kalman_gain.T)
    new_covariance = covariance - np.linalg.multi_dot((kalman_gain, projected_cov, kalman_gain.T))
    return new_mean, new_covariance



ultralytics.trackers.utils.kalman_filter.KalmanFilterXYWH

قواعد: KalmanFilterXYAH

لبوت سورت. مرشح Kalman بسيط لتتبع المربعات المحيطة في مساحة الصورة.

تحتوي مساحة الحالة ذات 8 أبعاد (x ، y ، w ، h ، vx ، vy ، vw ، vh) على موضع مركز المربع المحيط (x ، y) ، العرض W ، الارتفاع h ، وسرعات كل منهما.

تتبع حركة الجسم نموذج سرعة ثابتة. يتم أخذ موقع المربع المحيط (x ، y ، w ، h) على أنه مباشر مراقبة فضاء الحالة (نموذج المراقبة الخطية).

شفرة المصدر في ultralytics/trackers/utils/kalman_filter.py
class KalmanFilterXYWH(KalmanFilterXYAH):
    """
    For BoT-SORT. A simple Kalman filter for tracking bounding boxes in image space.

    The 8-dimensional state space (x, y, w, h, vx, vy, vw, vh) contains the bounding box center position (x, y), width
    w, height h, and their respective velocities.

    Object motion follows a constant velocity model. The bounding box location (x, y, w, h) is taken as direct
    observation of the state space (linear observation model).
    """

    def initiate(self, measurement: np.ndarray) -> tuple:
        """
        Create track from unassociated measurement.

        Args:
            measurement (ndarray): Bounding box coordinates (x, y, w, h) with center position (x, y), width, and height.

        Returns:
            (tuple[ndarray, ndarray]): Returns the mean vector (8 dimensional) and covariance matrix (8x8 dimensional) of
                the new track. Unobserved velocities are initialized to 0 mean.
        """
        mean_pos = measurement
        mean_vel = np.zeros_like(mean_pos)
        mean = np.r_[mean_pos, mean_vel]

        std = [
            2 * self._std_weight_position * measurement[2],
            2 * self._std_weight_position * measurement[3],
            2 * self._std_weight_position * measurement[2],
            2 * self._std_weight_position * measurement[3],
            10 * self._std_weight_velocity * measurement[2],
            10 * self._std_weight_velocity * measurement[3],
            10 * self._std_weight_velocity * measurement[2],
            10 * self._std_weight_velocity * measurement[3],
        ]
        covariance = np.diag(np.square(std))
        return mean, covariance

    def predict(self, mean, covariance) -> tuple:
        """
        Run Kalman filter prediction step.

        Args:
            mean (ndarray): The 8 dimensional mean vector of the object state at the previous time step.
            covariance (ndarray): The 8x8 dimensional covariance matrix of the object state at the previous time step.

        Returns:
            (tuple[ndarray, ndarray]): Returns the mean vector and covariance matrix of the predicted state. Unobserved
                velocities are initialized to 0 mean.
        """
        std_pos = [
            self._std_weight_position * mean[2],
            self._std_weight_position * mean[3],
            self._std_weight_position * mean[2],
            self._std_weight_position * mean[3],
        ]
        std_vel = [
            self._std_weight_velocity * mean[2],
            self._std_weight_velocity * mean[3],
            self._std_weight_velocity * mean[2],
            self._std_weight_velocity * mean[3],
        ]
        motion_cov = np.diag(np.square(np.r_[std_pos, std_vel]))

        mean = np.dot(mean, self._motion_mat.T)
        covariance = np.linalg.multi_dot((self._motion_mat, covariance, self._motion_mat.T)) + motion_cov

        return mean, covariance

    def project(self, mean, covariance) -> tuple:
        """
        Project state distribution to measurement space.

        Args:
            mean (ndarray): The state's mean vector (8 dimensional array).
            covariance (ndarray): The state's covariance matrix (8x8 dimensional).

        Returns:
            (tuple[ndarray, ndarray]): Returns the projected mean and covariance matrix of the given state estimate.
        """
        std = [
            self._std_weight_position * mean[2],
            self._std_weight_position * mean[3],
            self._std_weight_position * mean[2],
            self._std_weight_position * mean[3],
        ]
        innovation_cov = np.diag(np.square(std))

        mean = np.dot(self._update_mat, mean)
        covariance = np.linalg.multi_dot((self._update_mat, covariance, self._update_mat.T))
        return mean, covariance + innovation_cov

    def multi_predict(self, mean, covariance) -> tuple:
        """
        Run Kalman filter prediction step (Vectorized version).

        Args:
            mean (ndarray): The Nx8 dimensional mean matrix of the object states at the previous time step.
            covariance (ndarray): The Nx8x8 covariance matrix of the object states at the previous time step.

        Returns:
            (tuple[ndarray, ndarray]): Returns the mean vector and covariance matrix of the predicted state. Unobserved
                velocities are initialized to 0 mean.
        """
        std_pos = [
            self._std_weight_position * mean[:, 2],
            self._std_weight_position * mean[:, 3],
            self._std_weight_position * mean[:, 2],
            self._std_weight_position * mean[:, 3],
        ]
        std_vel = [
            self._std_weight_velocity * mean[:, 2],
            self._std_weight_velocity * mean[:, 3],
            self._std_weight_velocity * mean[:, 2],
            self._std_weight_velocity * mean[:, 3],
        ]
        sqr = np.square(np.r_[std_pos, std_vel]).T

        motion_cov = [np.diag(sqr[i]) for i in range(len(mean))]
        motion_cov = np.asarray(motion_cov)

        mean = np.dot(mean, self._motion_mat.T)
        left = np.dot(self._motion_mat, covariance).transpose((1, 0, 2))
        covariance = np.dot(left, self._motion_mat.T) + motion_cov

        return mean, covariance

    def update(self, mean, covariance, measurement) -> tuple:
        """
        Run Kalman filter correction step.

        Args:
            mean (ndarray): The predicted state's mean vector (8 dimensional).
            covariance (ndarray): The state's covariance matrix (8x8 dimensional).
            measurement (ndarray): The 4 dimensional measurement vector (x, y, w, h), where (x, y) is the center
                position, w the width, and h the height of the bounding box.

        Returns:
            (tuple[ndarray, ndarray]): Returns the measurement-corrected state distribution.
        """
        return super().update(mean, covariance, measurement)

initiate(measurement)

إنشاء مسار من قياس غير مرتبط.

البارامترات:

اسم نوع وصف افتراضي
measurement ndarray

إحداثيات المربع المحيط (x، y، w، h) مع موضع المركز (x، y)، العرض، والارتفاع.

مطلوب

ارجاع:

نوع وصف
tuple[ndarray, ndarray]

إرجاع المتجه المتوسط (8 أبعاد) ومصفوفة التغاير (8x8 أبعاد) ل المسار الجديد. يتم تهيئة السرعات غير المرصودة إلى 0 يعني.

شفرة المصدر في ultralytics/trackers/utils/kalman_filter.py
230 231 232 233 234 235 236 237 238239 240 241 242 243 244 245 246247 248 249 250 251 252 253 254255256
def initiate(self, measurement: np.ndarray) -> tuple:
    """
    Create track from unassociated measurement.

    Args:
        measurement (ndarray): Bounding box coordinates (x, y, w, h) with center position (x, y), width, and height.

    Returns:
        (tuple[ndarray, ndarray]): Returns the mean vector (8 dimensional) and covariance matrix (8x8 dimensional) of
            the new track. Unobserved velocities are initialized to 0 mean.
    """
    mean_pos = measurement
    mean_vel = np.zeros_like(mean_pos)
    mean = np.r_[mean_pos, mean_vel]

    std = [
        2 * self._std_weight_position * measurement[2],
        2 * self._std_weight_position * measurement[3],
        2 * self._std_weight_position * measurement[2],
        2 * self._std_weight_position * measurement[3],
        10 * self._std_weight_velocity * measurement[2],
        10 * self._std_weight_velocity * measurement[3],
        10 * self._std_weight_velocity * measurement[2],
        10 * self._std_weight_velocity * measurement[3],
    ]
    covariance = np.diag(np.square(std))
    return mean, covariance

multi_predict(mean, covariance)

قم بتشغيل خطوة التنبؤ بمرشح Kalman (الإصدار المتجه).

البارامترات:

اسم نوع وصف افتراضي
mean ndarray

مصفوفة متوسط الأبعاد Nx8 لحالات الكائن في الخطوة الزمنية السابقة.

مطلوب
covariance ndarray

مصفوفة التغاير Nx8x8 لحالات الكائن في الخطوة الزمنية السابقة.

مطلوب

ارجاع:

نوع وصف
tuple[ndarray, ndarray]

ترجع هذه الدالة المتجه المتوسط ومصفوفة التغاير للحالة المتوقعة. مخفي تتم تهيئة السرعات إلى 0 يعني.

شفرة المصدر في ultralytics/trackers/utils/kalman_filter.py
312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328329 330 331 332 333 334 335 336 337 338339 340341 342 343 344345
def multi_predict(self, mean, covariance) -> tuple:
    """
    Run Kalman filter prediction step (Vectorized version).

    Args:
        mean (ndarray): The Nx8 dimensional mean matrix of the object states at the previous time step.
        covariance (ndarray): The Nx8x8 covariance matrix of the object states at the previous time step.

    Returns:
        (tuple[ndarray, ndarray]): Returns the mean vector and covariance matrix of the predicted state. Unobserved
            velocities are initialized to 0 mean.
    """
    std_pos = [
        self._std_weight_position * mean[:, 2],
        self._std_weight_position * mean[:, 3],
        self._std_weight_position * mean[:, 2],
        self._std_weight_position * mean[:, 3],
    ]
    std_vel = [
        self._std_weight_velocity * mean[:, 2],
        self._std_weight_velocity * mean[:, 3],
        self._std_weight_velocity * mean[:, 2],
        self._std_weight_velocity * mean[:, 3],
    ]
    sqr = np.square(np.r_[std_pos, std_vel]).T

    motion_cov = [np.diag(sqr[i]) for i in range(len(mean))]
    motion_cov = np.asarray(motion_cov)

    mean = np.dot(mean, self._motion_mat.T)
    left = np.dot(self._motion_mat, covariance).transpose((1, 0, 2))
    covariance = np.dot(left, self._motion_mat.T) + motion_cov

    return mean, covariance

predict(mean, covariance)

قم بتشغيل خطوة التنبؤ بمرشح Kalman.

البارامترات:

اسم نوع وصف افتراضي
mean ndarray

متجه متوسط 8 أبعاد لحالة الكائن في الخطوة الزمنية السابقة.

مطلوب
covariance ndarray

مصفوفة التغاير المشترك الأبعاد 8x8 لحالة الكائن في الخطوة الزمنية السابقة.

مطلوب

ارجاع:

نوع وصف
tuple[ndarray, ndarray]

ترجع هذه الدالة المتجه المتوسط ومصفوفة التغاير للحالة المتوقعة. مخفي تتم تهيئة السرعات إلى 0 يعني.

شفرة المصدر في ultralytics/trackers/utils/kalman_filter.py
258 259 260 261 262 263 264 265 266 267268269 270 271 272 273 274 275 276277 278279 280 281 282 283284285286 287
def predict(self, mean, covariance) -> tuple:
    """
    Run Kalman filter prediction step.

    Args:
        mean (ndarray): The 8 dimensional mean vector of the object state at the previous time step.
        covariance (ndarray): The 8x8 dimensional covariance matrix of the object state at the previous time step.

    Returns:
        (tuple[ndarray, ndarray]): Returns the mean vector and covariance matrix of the predicted state. Unobserved
            velocities are initialized to 0 mean.
    """
    std_pos = [
        self._std_weight_position * mean[2],
        self._std_weight_position * mean[3],
        self._std_weight_position * mean[2],
        self._std_weight_position * mean[3],
    ]
    std_vel = [
        self._std_weight_velocity * mean[2],
        self._std_weight_velocity * mean[3],
        self._std_weight_velocity * mean[2],
        self._std_weight_velocity * mean[3],
    ]
    motion_cov = np.diag(np.square(np.r_[std_pos, std_vel]))

    mean = np.dot(mean, self._motion_mat.T)
    covariance = np.linalg.multi_dot((self._motion_mat, covariance, self._motion_mat.T)) + motion_cov

    return mean, covariance

project(mean, covariance)

توزيع حالة المشروع على مساحة القياس.

البارامترات:

اسم نوع وصف افتراضي
mean ndarray

متجه متوسط الحالة (صفيف 8 أبعاد).

مطلوب
covariance ndarray

مصفوفة التغاير في الولاية (8 × 8 أبعاد).

مطلوب

ارجاع:

نوع وصف
tuple[ndarray, ndarray]

إرجاع المتوسط المتوقع ومصفوفة التغاير لتقدير الحالة المحدد.

شفرة المصدر في ultralytics/trackers/utils/kalman_filter.py
289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308309310
def project(self, mean, covariance) -> tuple:
    """
    Project state distribution to measurement space.

    Args:
        mean (ndarray): The state's mean vector (8 dimensional array).
        covariance (ndarray): The state's covariance matrix (8x8 dimensional).

    Returns:
        (tuple[ndarray, ndarray]): Returns the projected mean and covariance matrix of the given state estimate.
    """
    std = [
        self._std_weight_position * mean[2],
        self._std_weight_position * mean[3],
        self._std_weight_position * mean[2],
        self._std_weight_position * mean[3],
    ]
    innovation_cov = np.diag(np.square(std))

    mean = np.dot(self._update_mat, mean)
    covariance = np.linalg.multi_dot((self._update_mat, covariance, self._update_mat.T))
    return mean, covariance + innovation_cov

update(mean, covariance, measurement)

قم بتشغيل خطوة تصحيح مرشح كالمان.

البارامترات:

اسم نوع وصف افتراضي
mean ndarray

المتجه المتوسط للحالة المتوقعة (8 أبعاد).

مطلوب
covariance ndarray

مصفوفة التغاير في الولاية (8 × 8 أبعاد).

مطلوب
measurement ndarray

متجه القياس 4 الأبعاد (x ، y ، w ، h) ، حيث (x ، y) هو المركز الموضع ، w العرض ، و h ارتفاع المربع المحيط.

مطلوب

ارجاع:

نوع وصف
tuple[ndarray, ndarray]

ترجع توزيع الحالة المصححة للقياس.

شفرة المصدر في ultralytics/trackers/utils/kalman_filter.py
347 348 349 350 351 352 353 354 355 356 357358359360
def update(self, mean, covariance, measurement) -> tuple:
    """
    Run Kalman filter correction step.

    Args:
        mean (ndarray): The predicted state's mean vector (8 dimensional).
        covariance (ndarray): The state's covariance matrix (8x8 dimensional).
        measurement (ndarray): The 4 dimensional measurement vector (x, y, w, h), where (x, y) is the center
            position, w the width, and h the height of the bounding box.

    Returns:
        (tuple[ndarray, ndarray]): Returns the measurement-corrected state distribution.
    """
    return super().update(mean, covariance, measurement)





تم إنشاء 2023-11-12, اخر تحديث 2023-11-25
المؤلفون: جلين جوشر (3)