paddlex 2.1.0__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

paddlex/ppdet/modeling/mot/motion/kalman_filter.py

@@ -1,270 +0,0 @@
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-This code is based on https://github.com/nwojke/deep_sort/blob/master/deep_sort/kalman_filter.py
-"""
-
-import numpy as np
-import scipy.linalg
-from paddlex.ppdet.core.workspace import register, serializable
-
-__all__ = ['KalmanFilter']
-"""
-Table for the 0.95 quantile of the chi-square distribution with N degrees of
-freedom (contains values for N=1, ..., 9). Taken from MATLAB/Octave's chi2inv
-function and used as Mahalanobis gating threshold.
-"""
-
-chi2inv95 = {
-    1: 3.8415,
-    2: 5.9915,
-    3: 7.8147,
-    4: 9.4877,
-    5: 11.070,
-    6: 12.592,
-    7: 14.067,
-    8: 15.507,
-    9: 16.919
-}
-
-
-@register
-@serializable
-class KalmanFilter(object):
-    """
-    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):
-        ndim, dt = 4, 1.
-
-        # 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. This is a bit hacky.
-        self._std_weight_position = 1. / 20
-        self._std_weight_velocity = 1. / 160
-
-    def initiate(self, measurement):
-        """
-        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:
-            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, covariance):
-        """
-        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:
-            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(self._motion_mat, mean)
-        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):
-        """
-        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:
-            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, covariance):
-        """
-        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 dimensional covariance matrics of the
-                object states at the previous time step.
-
-        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 = []
-        for i in range(len(mean)):
-            motion_cov.append(np.diag(sqr[i]))
-        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):
-        """
-        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:
-            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,
-                        covariance,
-                        measurements,
-                        only_position=False,
-                        metric='maha'):
-        """
-        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 dimensional 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 (Optional[bool]): If True, distance computation is
-                done with respect to the bounding box center position only.
-            metric (str): Metric type, 'gaussian' or 'maha'.
-
-        Returns
-            An array of length N, where the i-th element contains the squared
-            Mahalanobis 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)
-            squared_maha = np.sum(z * z, axis=0)
-            return squared_maha
-        else:
-            raise ValueError('invalid distance metric')

paddlex/ppdet/modeling/mot/tracker/__init__.py

@@ -1,23 +0,0 @@
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from . import base_jde_tracker
-from . import base_sde_tracker
-from . import jde_tracker
-from . import deepsort_tracker
-
-from .base_jde_tracker import *
-from .base_sde_tracker import *
-from .jde_tracker import *
-from .deepsort_tracker import *

paddlex/ppdet/modeling/mot/tracker/base_jde_tracker.py

@@ -1,297 +0,0 @@
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-This code is based on https://github.com/Zhongdao/Towards-Realtime-MOT/blob/master/tracker/multitracker.py
-"""
-
-import numpy as np
-from collections import defaultdict
-from collections import deque, OrderedDict
-from ..matching import jde_matching as matching
-from paddlex.ppdet.core.workspace import register, serializable
-import warnings
-warnings.filterwarnings("ignore")
-
-__all__ = [
-    'TrackState',
-    'BaseTrack',
-    'STrack',
-    'joint_stracks',
-    'sub_stracks',
-    'remove_duplicate_stracks',
-]
-
-
-class TrackState(object):
-    New = 0
-    Tracked = 1
-    Lost = 2
-    Removed = 3
-
-
-@register
-@serializable
-class BaseTrack(object):
-    _count_dict = defaultdict(int)  # support single class and multi classes
-
-    track_id = 0
-    is_activated = False
-    state = TrackState.New
-
-    history = OrderedDict()
-    features = []
-    curr_feature = None
-    score = 0
-    start_frame = 0
-    frame_id = 0
-    time_since_update = 0
-
-    # multi-camera
-    location = (np.inf, np.inf)
-
-    @property
-    def end_frame(self):
-        return self.frame_id
-
-    @staticmethod
-    def next_id(cls_id):
-        BaseTrack._count_dict[cls_id] += 1
-        return BaseTrack._count_dict[cls_id]
-
-    # @even: reset track id
-    @staticmethod
-    def init_count(num_classes):
-        """
-        Initiate _count for all object classes
-        :param num_classes:
-        """
-        for cls_id in range(num_classes):
-            BaseTrack._count_dict[cls_id] = 0
-
-    @staticmethod
-    def reset_track_count(cls_id):
-        BaseTrack._count_dict[cls_id] = 0
-
-    def activate(self, *args):
-        raise NotImplementedError
-
-    def predict(self):
-        raise NotImplementedError
-
-    def update(self, *args, **kwargs):
-        raise NotImplementedError
-
-    def mark_lost(self):
-        self.state = TrackState.Lost
-
-    def mark_removed(self):
-        self.state = TrackState.Removed
-
-
-@register
-@serializable
-class STrack(BaseTrack):
-    def __init__(self,
-                 tlwh,
-                 score,
-                 temp_feat,
-                 num_classes,
-                 cls_id,
-                 buff_size=30):
-        # object class id
-        self.cls_id = cls_id
-        # wait activate
-        self._tlwh = np.asarray(tlwh, dtype=np.float)
-        self.kalman_filter = None
-        self.mean, self.covariance = None, None
-        self.is_activated = False
-
-        self.score = score
-        self.track_len = 0
-
-        self.smooth_feat = None
-        self.update_features(temp_feat)
-        self.features = deque([], maxlen=buff_size)
-        self.alpha = 0.9
-
-    def update_features(self, feat):
-        # L2 normalizing
-        feat /= np.linalg.norm(feat)
-        self.curr_feat = feat
-        if self.smooth_feat is None:
-            self.smooth_feat = feat
-        else:
-            self.smooth_feat = self.alpha * self.smooth_feat + (
-                1.0 - self.alpha) * feat
-        self.features.append(feat)
-        self.smooth_feat /= np.linalg.norm(self.smooth_feat)
-
-    def predict(self):
-        mean_state = self.mean.copy()
-        if self.state != TrackState.Tracked:
-            mean_state[7] = 0
-        self.mean, self.covariance = self.kalman_filter.predict(
-            mean_state, self.covariance)
-
-    @staticmethod
-    def multi_predict(tracks, kalman_filter):
-        if len(tracks) > 0:
-            multi_mean = np.asarray([track.mean.copy() for track in tracks])
-            multi_covariance = np.asarray(
-                [track.covariance for track in tracks])
-            for i, st in enumerate(tracks):
-                if st.state != TrackState.Tracked:
-                    multi_mean[i][7] = 0
-            multi_mean, multi_covariance = kalman_filter.multi_predict(
-                multi_mean, multi_covariance)
-            for i, (mean, cov) in enumerate(zip(multi_mean, multi_covariance)):
-                tracks[i].mean = mean
-                tracks[i].covariance = cov
-
-    def reset_track_id(self):
-        self.reset_track_count(self.cls_id)
-
-    def activate(self, kalman_filter, frame_id):
-        """Start a new track"""
-        self.kalman_filter = kalman_filter
-        # update track id for the object class
-        self.track_id = self.next_id(self.cls_id)
-        self.mean, self.covariance = self.kalman_filter.initiate(
-            self.tlwh_to_xyah(self._tlwh))
-
-        self.track_len = 0
-        self.state = TrackState.Tracked  # set flag 'tracked'
-
-        if frame_id == 1:  # to record the first frame's detection result
-            self.is_activated = True
-
-        self.frame_id = frame_id
-        self.start_frame = frame_id
-
-    def re_activate(self, new_track, frame_id, new_id=False):
-        self.mean, self.covariance = self.kalman_filter.update(
-            self.mean, self.covariance, self.tlwh_to_xyah(new_track.tlwh))
-        self.update_features(new_track.curr_feat)
-        self.track_len = 0
-        self.state = TrackState.Tracked
-        self.is_activated = True
-        self.frame_id = frame_id
-        if new_id:  # update track id for the object class
-            self.track_id = self.next_id(self.cls_id)
-
-    def update(self, new_track, frame_id, update_feature=True):
-        self.frame_id = frame_id
-        self.track_len += 1
-
-        new_tlwh = new_track.tlwh
-        self.mean, self.covariance = self.kalman_filter.update(
-            self.mean, self.covariance, self.tlwh_to_xyah(new_tlwh))
-        self.state = TrackState.Tracked  # set flag 'tracked'
-        self.is_activated = True  # set flag 'activated'
-
-        self.score = new_track.score
-        if update_feature:
-            self.update_features(new_track.curr_feat)
-
-    @property
-    def tlwh(self):
-        """Get current position in bounding box format `(top left x, top left y,
-                width, height)`.
-        """
-        if self.mean is None:
-            return self._tlwh.copy()
-
-        ret = self.mean[:4].copy()
-        ret[2] *= ret[3]
-        ret[:2] -= ret[2:] / 2
-        return ret
-
-    @property
-    def tlbr(self):
-        """Convert bounding box to format `(min x, min y, max x, max y)`, i.e.,
-        `(top left, bottom right)`.
-        """
-        ret = self.tlwh.copy()
-        ret[2:] += ret[:2]
-        return ret
-
-    @staticmethod
-    def tlwh_to_xyah(tlwh):
-        """Convert bounding box to format `(center x, center y, aspect ratio,
-        height)`, where the aspect ratio is `width / height`.
-        """
-        ret = np.asarray(tlwh).copy()
-        ret[:2] += ret[2:] / 2
-        ret[2] /= ret[3]
-        return ret
-
-    def to_xyah(self):
-        return self.tlwh_to_xyah(self.tlwh)
-
-    @staticmethod
-    def tlbr_to_tlwh(tlbr):
-        ret = np.asarray(tlbr).copy()
-        ret[2:] -= ret[:2]
-        return ret
-
-    @staticmethod
-    def tlwh_to_tlbr(tlwh):
-        ret = np.asarray(tlwh).copy()
-        ret[2:] += ret[:2]
-        return ret
-
-    def __repr__(self):
-        return 'OT_({}-{})_({}-{})'.format(self.cls_id, self.track_id,
-                                           self.start_frame, self.end_frame)
-
-
-def joint_stracks(tlista, tlistb):
-    exists = {}
-    res = []
-    for t in tlista:
-        exists[t.track_id] = 1
-        res.append(t)
-    for t in tlistb:
-        tid = t.track_id
-        if not exists.get(tid, 0):
-            exists[tid] = 1
-            res.append(t)
-    return res
-
-
-def sub_stracks(tlista, tlistb):
-    stracks = {}
-    for t in tlista:
-        stracks[t.track_id] = t
-    for t in tlistb:
-        tid = t.track_id
-        if stracks.get(tid, 0):
-            del stracks[tid]
-    return list(stracks.values())
-
-
-def remove_duplicate_stracks(stracksa, stracksb):
-    pdist = matching.iou_distance(stracksa, stracksb)
-    pairs = np.where(pdist < 0.15)
-    dupa, dupb = list(), list()
-    for p, q in zip(*pairs):
-        timep = stracksa[p].frame_id - stracksa[p].start_frame
-        timeq = stracksb[q].frame_id - stracksb[q].start_frame
-        if timep > timeq:
-            dupb.append(q)
-        else:
-            dupa.append(p)
-    resa = [t for i, t in enumerate(stracksa) if not i in dupa]
-    resb = [t for i, t in enumerate(stracksb) if not i in dupb]
-    return resa, resb