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

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

@@ -1,156 +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/track.py
-"""
-
-import datetime
-from paddlex.ppdet.core.workspace import register, serializable
-
-__all__ = ['TrackState', 'Track']
-
-
-class TrackState(object):
-    """
-    Enumeration type for the single target track state. Newly created tracks are
-    classified as `tentative` until enough evidence has been collected. Then,
-    the track state is changed to `confirmed`. Tracks that are no longer alive
-    are classified as `deleted` to mark them for removal from the set of active
-    tracks.
-    """
-    Tentative = 1
-    Confirmed = 2
-    Deleted = 3
-
-
-@register
-@serializable
-class Track(object):
-    """
-    A single target track with state space `(x, y, a, h)` and associated
-    velocities, where `(x, y)` is the center of the bounding box, `a` is the
-    aspect ratio and `h` is the height.
-
-    Args:
-        mean (ndarray): Mean vector of the initial state distribution.
-        covariance (ndarray): Covariance matrix of the initial state distribution.
-        track_id (int): A unique track identifier.
-        n_init (int): Number of consecutive detections before the track is confirmed.
-            The track state is set to `Deleted` if a miss occurs within the first
-            `n_init` frames.
-        max_age (int): The maximum number of consecutive misses before the track
-            state is set to `Deleted`.
-        cls_id (int): The category id of the tracked box.
-        score (float): The confidence score of the tracked box.
-        feature (Optional[ndarray]): Feature vector of the detection this track
-            originates from. If not None, this feature is added to the `features` cache.
-
-    Attributes:
-        hits (int): Total number of measurement updates.
-        age (int): Total number of frames since first occurance.
-        time_since_update (int): Total number of frames since last measurement
-            update.
-        state (TrackState): The current track state.
-        features (List[ndarray]): A cache of features. On each measurement update,
-            the associated feature vector is added to this list.
-    """
-
-    def __init__(self,
-                 mean,
-                 covariance,
-                 track_id,
-                 n_init,
-                 max_age,
-                 cls_id,
-                 score,
-                 feature=None):
-        self.mean = mean
-        self.covariance = covariance
-        self.track_id = track_id
-        self.hits = 1
-        self.age = 1
-        self.time_since_update = 0
-        self.cls_id = cls_id
-        self.score = score
-        self.start_time = datetime.datetime.now()
-
-        self.state = TrackState.Tentative
-        self.features = []
-        self.feat = feature
-        if feature is not None:
-            self.features.append(feature)
-
-        self._n_init = n_init
-        self._max_age = max_age
-
-    def to_tlwh(self):
-        """Get position in format `(top left x, top left y, width, height)`."""
-        ret = self.mean[:4].copy()
-        ret[2] *= ret[3]
-        ret[:2] -= ret[2:] / 2
-        return ret
-
-    def to_tlbr(self):
-        """Get position in bounding box format `(min x, miny, max x, max y)`."""
-        ret = self.to_tlwh()
-        ret[2:] = ret[:2] + ret[2:]
-        return ret
-
-    def predict(self, kalman_filter):
-        """
-        Propagate the state distribution to the current time step using a Kalman
-        filter prediction step.
-        """
-        self.mean, self.covariance = kalman_filter.predict(self.mean,
-                                                           self.covariance)
-        self.age += 1
-        self.time_since_update += 1
-
-    def update(self, kalman_filter, detection):
-        """
-        Perform Kalman filter measurement update step and update the associated
-        detection feature cache.
-        """
-        self.mean, self.covariance = kalman_filter.update(self.mean,
-                                                          self.covariance,
-                                                          detection.to_xyah())
-        self.features.append(detection.feature)
-        self.feat = detection.feature
-        self.cls_id = detection.cls_id
-        self.score = detection.score
-
-        self.hits += 1
-        self.time_since_update = 0
-        if self.state == TrackState.Tentative and self.hits >= self._n_init:
-            self.state = TrackState.Confirmed
-
-    def mark_missed(self):
-        """Mark this track as missed (no association at the current time step).
-        """
-        if self.state == TrackState.Tentative:
-            self.state = TrackState.Deleted
-        elif self.time_since_update > self._max_age:
-            self.state = TrackState.Deleted
-
-    def is_tentative(self):
-        """Returns True if this track is tentative (unconfirmed)."""
-        return self.state == TrackState.Tentative
-
-    def is_confirmed(self):
-        """Returns True if this track is confirmed."""
-        return self.state == TrackState.Confirmed
-
-    def is_deleted(self):
-        """Returns True if this track is dead and should be deleted."""
-        return self.state == TrackState.Deleted

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

@@ -1,188 +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/tracker.py
-"""
-
-import numpy as np
-
-from ..motion import KalmanFilter
-from ..matching.deepsort_matching import NearestNeighborDistanceMetric
-from ..matching.deepsort_matching import iou_cost, min_cost_matching, matching_cascade, gate_cost_matrix
-from .base_sde_tracker import Track
-from ..utils import Detection
-
-from paddlex.ppdet.core.workspace import register, serializable
-from paddlex.ppdet.utils.logger import setup_logger
-logger = setup_logger(__name__)
-
-__all__ = ['DeepSORTTracker']
-
-
-@register
-@serializable
-class DeepSORTTracker(object):
-    """
-    DeepSORT tracker
-
-    Args:
-        input_size (list): input feature map size to reid model, [h, w] format,
-            [64, 192] as default.
-        min_box_area (int): min box area to filter out low quality boxes
-        vertical_ratio (float): w/h, the vertical ratio of the bbox to filter
-            bad results, set 1.6 default for pedestrian tracking. If set <=0
-            means no need to filter bboxes.
-        budget (int): If not None, fix samples per class to at most this number.
-            Removes the oldest samples when the budget is reached.
-        max_age (int): maximum number of missed misses before a track is deleted
-        n_init (float): Number of frames that a track remains in initialization
-            phase. Number of consecutive detections before the track is confirmed.
-            The track state is set to `Deleted` if a miss occurs within the first
-            `n_init` frames.
-        metric_type (str): either "euclidean" or "cosine", the distance metric
-            used for measurement to track association.
-        matching_threshold (float): samples with larger distance are
-            considered an invalid match.
-        max_iou_distance (float): max iou distance threshold
-        motion (object): KalmanFilter instance
-    """
-
-    def __init__(self,
-                 input_size=[64, 192],
-                 min_box_area=0,
-                 vertical_ratio=-1,
-                 budget=100,
-                 max_age=70,
-                 n_init=3,
-                 metric_type='cosine',
-                 matching_threshold=0.2,
-                 max_iou_distance=0.9,
-                 motion='KalmanFilter'):
-        self.input_size = input_size
-        self.min_box_area = min_box_area
-        self.vertical_ratio = vertical_ratio
-        self.max_age = max_age
-        self.n_init = n_init
-        self.metric = NearestNeighborDistanceMetric(metric_type,
-                                                    matching_threshold, budget)
-        self.max_iou_distance = max_iou_distance
-        if motion == 'KalmanFilter':
-            self.motion = KalmanFilter()
-
-        self.tracks = []
-        self._next_id = 1
-
-    def predict(self):
-        """
-        Propagate track state distributions one time step forward.
-        This function should be called once every time step, before `update`.
-        """
-        for track in self.tracks:
-            track.predict(self.motion)
-
-    def update(self, pred_dets, pred_embs):
-        """
-        Perform measurement update and track management.
-        Args:
-            pred_dets (np.array): Detection results of the image, the shape is
-                [N, 6], means 'x0, y0, x1, y1, score, cls_id'.
-            pred_embs (np.array): Embedding results of the image, the shape is
-                [N, 128], usually pred_embs.shape[1] is a multiple of 128.
-        """
-        pred_tlwhs = pred_dets[:, :4]
-        pred_scores = pred_dets[:, 4:5]
-        pred_cls_ids = pred_dets[:, 5:]
-
-        detections = [
-            Detection(tlwh, score, feat, cls_id)
-            for tlwh, score, feat, cls_id in zip(pred_tlwhs, pred_scores,
-                                                 pred_embs, pred_cls_ids)
-        ]
-
-        # Run matching cascade.
-        matches, unmatched_tracks, unmatched_detections = \
-            self._match(detections)
-
-        # Update track set.
-        for track_idx, detection_idx in matches:
-            self.tracks[track_idx].update(self.motion,
-                                          detections[detection_idx])
-        for track_idx in unmatched_tracks:
-            self.tracks[track_idx].mark_missed()
-        for detection_idx in unmatched_detections:
-            self._initiate_track(detections[detection_idx])
-        self.tracks = [t for t in self.tracks if not t.is_deleted()]
-
-        # Update distance metric.
-        active_targets = [t.track_id for t in self.tracks if t.is_confirmed()]
-        features, targets = [], []
-        for track in self.tracks:
-            if not track.is_confirmed():
-                continue
-            features += track.features
-            targets += [track.track_id for _ in track.features]
-            track.features = []
-        self.metric.partial_fit(
-            np.asarray(features), np.asarray(targets), active_targets)
-        output_stracks = self.tracks
-        return output_stracks
-
-    def _match(self, detections):
-        def gated_metric(tracks, dets, track_indices, detection_indices):
-            features = np.array([dets[i].feature for i in detection_indices])
-            targets = np.array([tracks[i].track_id for i in track_indices])
-            cost_matrix = self.metric.distance(features, targets)
-            cost_matrix = gate_cost_matrix(self.motion, cost_matrix, tracks,
-                                           dets, track_indices,
-                                           detection_indices)
-            return cost_matrix
-
-        # Split track set into confirmed and unconfirmed tracks.
-        confirmed_tracks = [
-            i for i, t in enumerate(self.tracks) if t.is_confirmed()
-        ]
-        unconfirmed_tracks = [
-            i for i, t in enumerate(self.tracks) if not t.is_confirmed()
-        ]
-
-        # Associate confirmed tracks using appearance features.
-        matches_a, unmatched_tracks_a, unmatched_detections = \
-            matching_cascade(
-                gated_metric, self.metric.matching_threshold, self.max_age,
-                self.tracks, detections, confirmed_tracks)
-
-        # Associate remaining tracks together with unconfirmed tracks using IOU.
-        iou_track_candidates = unconfirmed_tracks + [
-            k for k in unmatched_tracks_a
-            if self.tracks[k].time_since_update == 1
-        ]
-        unmatched_tracks_a = [
-            k for k in unmatched_tracks_a
-            if self.tracks[k].time_since_update != 1
-        ]
-        matches_b, unmatched_tracks_b, unmatched_detections = \
-            min_cost_matching(
-                iou_cost, self.max_iou_distance, self.tracks,
-                detections, iou_track_candidates, unmatched_detections)
-
-        matches = matches_a + matches_b
-        unmatched_tracks = list(set(unmatched_tracks_a + unmatched_tracks_b))
-        return matches, unmatched_tracks, unmatched_detections
-
-    def _initiate_track(self, detection):
-        mean, covariance = self.motion.initiate(detection.to_xyah())
-        self.tracks.append(
-            Track(mean, covariance, self._next_id, self.n_init, self.max_age,
-                  detection.cls_id, detection.score, detection.feature))
-        self._next_id += 1

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

@@ -1,277 +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 ..matching import jde_matching as matching
-from ..motion import KalmanFilter
-from .base_jde_tracker import TrackState, STrack
-from .base_jde_tracker import joint_stracks, sub_stracks, remove_duplicate_stracks
-
-from paddlex.ppdet.core.workspace import register, serializable
-from paddlex.ppdet.utils.logger import setup_logger
-logger = setup_logger(__name__)
-
-__all__ = ['JDETracker']
-
-
-@register
-@serializable
-class JDETracker(object):
-    __shared__ = ['num_classes']
-    """
-    JDE tracker, support single class and multi classes
-
-    Args:
-        num_classes (int): the number of classes
-        det_thresh (float): threshold of detection score
-        track_buffer (int): buffer for tracker
-        min_box_area (int): min box area to filter out low quality boxes
-        vertical_ratio (float): w/h, the vertical ratio of the bbox to filter
-            bad results. If set <0 means no need to filter bboxes，usually set
-            1.6 for pedestrian tracking.
-        tracked_thresh (float): linear assignment threshold of tracked
-            stracks and detections
-        r_tracked_thresh (float): linear assignment threshold of
-            tracked stracks and unmatched detections
-        unconfirmed_thresh (float): linear assignment threshold of
-            unconfirmed stracks and unmatched detections
-        motion (str): motion model, KalmanFilter as default
-        conf_thres (float): confidence threshold for tracking
-        metric_type (str): either "euclidean" or "cosine", the distance metric
-            used for measurement to track association.
-    """
-
-    def __init__(self,
-                 num_classes=1,
-                 det_thresh=0.3,
-                 track_buffer=30,
-                 min_box_area=200,
-                 vertical_ratio=1.6,
-                 tracked_thresh=0.7,
-                 r_tracked_thresh=0.5,
-                 unconfirmed_thresh=0.7,
-                 motion='KalmanFilter',
-                 conf_thres=0,
-                 metric_type='euclidean'):
-        self.num_classes = num_classes
-        self.det_thresh = det_thresh
-        self.track_buffer = track_buffer
-        self.min_box_area = min_box_area
-        self.vertical_ratio = vertical_ratio
-
-        self.tracked_thresh = tracked_thresh
-        self.r_tracked_thresh = r_tracked_thresh
-        self.unconfirmed_thresh = unconfirmed_thresh
-        if motion == 'KalmanFilter':
-            self.motion = KalmanFilter()
-        self.conf_thres = conf_thres
-        self.metric_type = metric_type
-
-        self.frame_id = 0
-        self.tracked_tracks_dict = defaultdict(list)  # dict(list[STrack])
-        self.lost_tracks_dict = defaultdict(list)  # dict(list[STrack])
-        self.removed_tracks_dict = defaultdict(list)  # dict(list[STrack])
-
-        self.max_time_lost = 0
-        # max_time_lost will be calculated: int(frame_rate / 30.0 * track_buffer)
-
-    def update(self, pred_dets, pred_embs):
-        """
-        Processes the image frame and finds bounding box(detections).
-        Associates the detection with corresponding tracklets and also handles
-            lost, removed, refound and active tracklets.
-
-        Args:
-            pred_dets (np.array): Detection results of the image, the shape is
-                [N, 6], means 'x0, y0, x1, y1, score, cls_id'.
-            pred_embs (np.array): Embedding results of the image, the shape is
-                [N, 128] or [N, 512].
-
-        Return:
-            output_stracks_dict (dict(list)): The list contains information
-                regarding the online_tracklets for the recieved image tensor.
-        """
-        self.frame_id += 1
-        if self.frame_id == 1:
-            STrack.init_count(self.num_classes)
-        activated_tracks_dict = defaultdict(list)
-        refined_tracks_dict = defaultdict(list)
-        lost_tracks_dict = defaultdict(list)
-        removed_tracks_dict = defaultdict(list)
-        output_tracks_dict = defaultdict(list)
-
-        pred_dets_dict = defaultdict(list)
-        pred_embs_dict = defaultdict(list)
-
-        # unify single and multi classes detection and embedding results
-        for cls_id in range(self.num_classes):
-            cls_idx = (pred_dets[:, 5:] == cls_id).squeeze(-1)
-            pred_dets_dict[cls_id] = pred_dets[cls_idx]
-            pred_embs_dict[cls_id] = pred_embs[cls_idx]
-
-        for cls_id in range(self.num_classes):
-            """ Step 1: Get detections by class"""
-            pred_dets_cls = pred_dets_dict[cls_id]
-            pred_embs_cls = pred_embs_dict[cls_id]
-            remain_inds = (pred_dets_cls[:, 4:5] > self.conf_thres).squeeze(-1)
-            if remain_inds.sum() > 0:
-                pred_dets_cls = pred_dets_cls[remain_inds]
-                pred_embs_cls = pred_embs_cls[remain_inds]
-                detections = [
-                    STrack(
-                        STrack.tlbr_to_tlwh(tlbrs[:4]), tlbrs[4], f,
-                        self.num_classes, cls_id, 30)
-                    for (tlbrs, f) in zip(pred_dets_cls, pred_embs_cls)
-                ]
-            else:
-                detections = []
-            ''' Add newly detected tracklets to tracked_stracks'''
-            unconfirmed_dict = defaultdict(list)
-            tracked_tracks_dict = defaultdict(list)
-            for track in self.tracked_tracks_dict[cls_id]:
-                if not track.is_activated:
-                    # previous tracks which are not active in the current frame are added in unconfirmed list
-                    unconfirmed_dict[cls_id].append(track)
-                else:
-                    # Active tracks are added to the local list 'tracked_stracks'
-                    tracked_tracks_dict[cls_id].append(track)
-            """ Step 2: First association, with embedding"""
-            # building tracking pool for the current frame
-            track_pool_dict = defaultdict(list)
-            track_pool_dict[cls_id] = joint_stracks(
-                tracked_tracks_dict[cls_id], self.lost_tracks_dict[cls_id])
-
-            # Predict the current location with KalmanFilter
-            STrack.multi_predict(track_pool_dict[cls_id], self.motion)
-
-            dists = matching.embedding_distance(
-                track_pool_dict[cls_id], detections, metric=self.metric_type)
-            dists = matching.fuse_motion(self.motion, dists,
-                                         track_pool_dict[cls_id], detections)
-            matches, u_track, u_detection = matching.linear_assignment(
-                dists, thresh=self.tracked_thresh)
-
-            for i_tracked, idet in matches:
-                # i_tracked is the id of the track and idet is the detection
-                track = track_pool_dict[cls_id][i_tracked]
-                det = detections[idet]
-                if track.state == TrackState.Tracked:
-                    # If the track is active, add the detection to the track
-                    track.update(detections[idet], self.frame_id)
-                    activated_tracks_dict[cls_id].append(track)
-                else:
-                    # We have obtained a detection from a track which is not active,
-                    # hence put the track in refind_stracks list
-                    track.re_activate(det, self.frame_id, new_id=False)
-                    refined_tracks_dict[cls_id].append(track)
-
-            # None of the steps below happen if there are no undetected tracks.
-            """ Step 3: Second association, with IOU"""
-            detections = [detections[i] for i in u_detection]
-            r_tracked_stracks = []
-            for i in u_track:
-                if track_pool_dict[cls_id][i].state == TrackState.Tracked:
-                    r_tracked_stracks.append(track_pool_dict[cls_id][i])
-
-            dists = matching.iou_distance(r_tracked_stracks, detections)
-            matches, u_track, u_detection = matching.linear_assignment(
-                dists, thresh=self.r_tracked_thresh)
-
-            for i_tracked, idet in matches:
-                track = r_tracked_stracks[i_tracked]
-                det = detections[idet]
-                if track.state == TrackState.Tracked:
-                    track.update(det, self.frame_id)
-                    activated_tracks_dict[cls_id].append(track)
-                else:
-                    track.re_activate(det, self.frame_id, new_id=False)
-                    refined_tracks_dict[cls_id].append(track)
-
-            for it in u_track:
-                track = r_tracked_stracks[it]
-                if not track.state == TrackState.Lost:
-                    track.mark_lost()
-                    lost_tracks_dict[cls_id].append(track)
-            '''Deal with unconfirmed tracks, usually tracks with only one beginning frame'''
-            detections = [detections[i] for i in u_detection]
-            dists = matching.iou_distance(unconfirmed_dict[cls_id], detections)
-            matches, u_unconfirmed, u_detection = matching.linear_assignment(
-                dists, thresh=self.unconfirmed_thresh)
-            for i_tracked, idet in matches:
-                unconfirmed_dict[cls_id][i_tracked].update(detections[idet],
-                                                           self.frame_id)
-                activated_tracks_dict[cls_id].append(unconfirmed_dict[cls_id][
-                    i_tracked])
-            for it in u_unconfirmed:
-                track = unconfirmed_dict[cls_id][it]
-                track.mark_removed()
-                removed_tracks_dict[cls_id].append(track)
-            """ Step 4: Init new stracks"""
-            for inew in u_detection:
-                track = detections[inew]
-                if track.score < self.det_thresh:
-                    continue
-                track.activate(self.motion, self.frame_id)
-                activated_tracks_dict[cls_id].append(track)
-            """ Step 5: Update state"""
-            for track in self.lost_tracks_dict[cls_id]:
-                if self.frame_id - track.end_frame > self.max_time_lost:
-                    track.mark_removed()
-                    removed_tracks_dict[cls_id].append(track)
-
-            self.tracked_tracks_dict[cls_id] = [
-                t for t in self.tracked_tracks_dict[cls_id]
-                if t.state == TrackState.Tracked
-            ]
-            self.tracked_tracks_dict[cls_id] = joint_stracks(
-                self.tracked_tracks_dict[cls_id],
-                activated_tracks_dict[cls_id])
-            self.tracked_tracks_dict[cls_id] = joint_stracks(
-                self.tracked_tracks_dict[cls_id], refined_tracks_dict[cls_id])
-            self.lost_tracks_dict[cls_id] = sub_stracks(
-                self.lost_tracks_dict[cls_id],
-                self.tracked_tracks_dict[cls_id])
-            self.lost_tracks_dict[cls_id].extend(lost_tracks_dict[cls_id])
-            self.lost_tracks_dict[cls_id] = sub_stracks(
-                self.lost_tracks_dict[cls_id],
-                self.removed_tracks_dict[cls_id])
-            self.removed_tracks_dict[cls_id].extend(removed_tracks_dict[
-                cls_id])
-            self.tracked_tracks_dict[cls_id], self.lost_tracks_dict[
-                cls_id] = remove_duplicate_stracks(
-                    self.tracked_tracks_dict[cls_id],
-                    self.lost_tracks_dict[cls_id])
-
-            # get scores of lost tracks
-            output_tracks_dict[cls_id] = [
-                track for track in self.tracked_tracks_dict[cls_id]
-                if track.is_activated
-            ]
-
-            logger.debug('===========Frame {}=========='.format(self.frame_id))
-            logger.debug('Activated: {}'.format(
-                [track.track_id for track in activated_tracks_dict[cls_id]]))
-            logger.debug('Refind: {}'.format(
-                [track.track_id for track in refined_tracks_dict[cls_id]]))
-            logger.debug('Lost: {}'.format(
-                [track.track_id for track in lost_tracks_dict[cls_id]]))
-            logger.debug('Removed: {}'.format(
-                [track.track_id for track in removed_tracks_dict[cls_id]]))
-
-        return output_tracks_dict