paddlex 2.0.0rc4__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

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

@@ -1,262 +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 borrow from https://github.com/Zhongdao/Towards-Realtime-MOT/blob/master/tracker/multitracker.py
-"""
-
-import paddle
-
-from ..matching import jde_matching as matching
-from .base_jde_tracker import TrackState, BaseTrack, 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):
-    __inject__ = ['motion']
-    """
-    JDE tracker
-
-    Args:
-        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
-        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 (object): KalmanFilter instance
-        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,
-                 det_thresh=0.3,
-                 track_buffer=30,
-                 min_box_area=200,
-                 tracked_thresh=0.7,
-                 r_tracked_thresh=0.5,
-                 unconfirmed_thresh=0.7,
-                 motion='KalmanFilter',
-                 conf_thres=0,
-                 metric_type='euclidean'):
-        self.det_thresh = det_thresh
-        self.track_buffer = track_buffer
-        self.min_box_area = min_box_area
-        self.tracked_thresh = tracked_thresh
-        self.r_tracked_thresh = r_tracked_thresh
-        self.unconfirmed_thresh = unconfirmed_thresh
-        self.motion = motion
-        self.conf_thres = conf_thres
-        self.metric_type = metric_type
-
-        self.frame_id = 0
-        self.tracked_stracks = []
-        self.lost_stracks = []
-        self.removed_stracks = []
-
-        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 (Tensor): Detection results of the image, shape is [N, 5].
-            pred_embs (Tensor): Embedding results of the image, shape is [N, 512].
-
-        Return:
-            output_stracks (list): The list contains information regarding the
-                online_tracklets for the recieved image tensor.
-        """
-        self.frame_id += 1
-        activated_starcks = []
-        # for storing active tracks, for the current frame
-        refind_stracks = []
-        # Lost Tracks whose detections are obtained in the current frame
-        lost_stracks = []
-        # The tracks which are not obtained in the current frame but are not
-        # removed. (Lost for some time lesser than the threshold for removing)
-        removed_stracks = []
-
-        remain_inds = paddle.nonzero(pred_dets[:, 4] > self.conf_thres)
-        if remain_inds.shape[0] == 0:
-            pred_dets = paddle.zeros([0, 1])
-            pred_embs = paddle.zeros([0, 1])
-        else:
-            pred_dets = paddle.gather(pred_dets, remain_inds)
-            pred_embs = paddle.gather(pred_embs, remain_inds)
-
-        # Filter out the image with box_num = 0. pred_dets = [[0.0, 0.0, 0.0 ,0.0]]
-        empty_pred = True if len(pred_dets) == 1 and paddle.sum(
-            pred_dets) == 0.0 else False
-        """ Step 1: Network forward, get detections & embeddings"""
-        if len(pred_dets) > 0 and not empty_pred:
-            pred_dets = pred_dets.numpy()
-            pred_embs = pred_embs.numpy()
-            detections = [
-                STrack(STrack.tlbr_to_tlwh(tlbrs[:4]), tlbrs[4], f, 30)
-                for (tlbrs, f) in zip(pred_dets, pred_embs)
-            ]
-        else:
-            detections = []
-        ''' Add newly detected tracklets to tracked_stracks'''
-        unconfirmed = []
-        tracked_stracks = []  # type: list[STrack]
-        for track in self.tracked_stracks:
-            if not track.is_activated:
-                # previous tracks which are not active in the current frame are added in unconfirmed list
-                unconfirmed.append(track)
-            else:
-                # Active tracks are added to the local list 'tracked_stracks'
-                tracked_stracks.append(track)
-        """ Step 2: First association, with embedding"""
-        # Combining currently tracked_stracks and lost_stracks
-        strack_pool = joint_stracks(tracked_stracks, self.lost_stracks)
-        # Predict the current location with KF
-        STrack.multi_predict(strack_pool, self.motion)
-
-        dists = matching.embedding_distance(
-            strack_pool, detections, metric=self.metric_type)
-        dists = matching.fuse_motion(self.motion, dists, strack_pool,
-                                     detections)
-        # The dists is the list of distances of the detection with the tracks in strack_pool
-        matches, u_track, u_detection = matching.linear_assignment(
-            dists, thresh=self.tracked_thresh)
-        # The matches is the array for corresponding matches of the detection with the corresponding strack_pool
-
-        for itracked, idet in matches:
-            # itracked is the id of the track and idet is the detection
-            track = strack_pool[itracked]
-            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_starcks.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)
-                refind_stracks.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]
-        # detections is now a list of the unmatched detections
-        r_tracked_stracks = []
-        # This is container for stracks which were tracked till the previous
-        # frame but no detection was found for it in the current frame.
-
-        for i in u_track:
-            if strack_pool[i].state == TrackState.Tracked:
-                r_tracked_stracks.append(strack_pool[i])
-        dists = matching.iou_distance(r_tracked_stracks, detections)
-        matches, u_track, u_detection = matching.linear_assignment(
-            dists, thresh=self.r_tracked_thresh)
-        # matches is the list of detections which matched with corresponding
-        # tracks by IOU distance method.
-
-        for itracked, idet in matches:
-            track = r_tracked_stracks[itracked]
-            det = detections[idet]
-            if track.state == TrackState.Tracked:
-                track.update(det, self.frame_id)
-                activated_starcks.append(track)
-            else:
-                track.re_activate(det, self.frame_id, new_id=False)
-                refind_stracks.append(track)
-        # Same process done for some unmatched detections, but now considering IOU_distance as measure
-
-        for it in u_track:
-            track = r_tracked_stracks[it]
-            if not track.state == TrackState.Lost:
-                track.mark_lost()
-                lost_stracks.append(track)
-        # If no detections are obtained for tracks (u_track), the tracks are added to lost_tracks list and are marked lost
-        '''Deal with unconfirmed tracks, usually tracks with only one beginning frame'''
-        detections = [detections[i] for i in u_detection]
-        dists = matching.iou_distance(unconfirmed, detections)
-        matches, u_unconfirmed, u_detection = matching.linear_assignment(
-            dists, thresh=self.unconfirmed_thresh)
-        for itracked, idet in matches:
-            unconfirmed[itracked].update(detections[idet], self.frame_id)
-            activated_starcks.append(unconfirmed[itracked])
-
-        # The tracks which are yet not matched
-        for it in u_unconfirmed:
-            track = unconfirmed[it]
-            track.mark_removed()
-            removed_stracks.append(track)
-
-        # after all these confirmation steps, if a new detection is found, it is initialized for a new 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_starcks.append(track)
-        """ Step 5: Update state"""
-        # If the tracks are lost for more frames than the threshold number, the tracks are removed.
-        for track in self.lost_stracks:
-            if self.frame_id - track.end_frame > self.max_time_lost:
-                track.mark_removed()
-                removed_stracks.append(track)
-
-        # Update the self.tracked_stracks and self.lost_stracks using the updates in this step.
-        self.tracked_stracks = [
-            t for t in self.tracked_stracks if t.state == TrackState.Tracked
-        ]
-        self.tracked_stracks = joint_stracks(self.tracked_stracks,
-                                             activated_starcks)
-        self.tracked_stracks = joint_stracks(self.tracked_stracks,
-                                             refind_stracks)
-
-        self.lost_stracks = sub_stracks(self.lost_stracks,
-                                        self.tracked_stracks)
-        self.lost_stracks.extend(lost_stracks)
-        self.lost_stracks = sub_stracks(self.lost_stracks,
-                                        self.removed_stracks)
-        self.removed_stracks.extend(removed_stracks)
-        self.tracked_stracks, self.lost_stracks = remove_duplicate_stracks(
-            self.tracked_stracks, self.lost_stracks)
-        # get scores of lost tracks
-        output_stracks = [
-            track for track in self.tracked_stracks if track.is_activated
-        ]
-
-        logger.debug('===========Frame {}=========='.format(self.frame_id))
-        logger.debug('Activated: {}'.format(
-            [track.track_id for track in activated_starcks]))
-        logger.debug('Refind: {}'.format(
-            [track.track_id for track in refind_stracks]))
-        logger.debug('Lost: {}'.format(
-            [track.track_id for track in lost_stracks]))
-        logger.debug('Removed: {}'.format(
-            [track.track_id for track in removed_stracks]))
-
-        return output_stracks

paddlex/ppdet/modeling/mot/utils.py

@@ -1,181 +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.
-
-import os
-import cv2
-import time
-import paddle
-import numpy as np
-
-__all__ = [
-    'Timer',
-    'Detection',
-    'load_det_results',
-    'preprocess_reid',
-    'get_crops',
-    'clip_box',
-    'scale_coords',
-]
-
-
-class Timer(object):
-    """
-    This class used to compute and print the current FPS while evaling.
-    """
-
-    def __init__(self):
-        self.total_time = 0.
-        self.calls = 0
-        self.start_time = 0.
-        self.diff = 0.
-        self.average_time = 0.
-        self.duration = 0.
-
-    def tic(self):
-        # using time.time instead of time.clock because time time.clock
-        # does not normalize for multithreading
-        self.start_time = time.time()
-
-    def toc(self, average=True):
-        self.diff = time.time() - self.start_time
-        self.total_time += self.diff
-        self.calls += 1
-        self.average_time = self.total_time / self.calls
-        if average:
-            self.duration = self.average_time
-        else:
-            self.duration = self.diff
-        return self.duration
-
-    def clear(self):
-        self.total_time = 0.
-        self.calls = 0
-        self.start_time = 0.
-        self.diff = 0.
-        self.average_time = 0.
-        self.duration = 0.
-
-
-class Detection(object):
-    """
-    This class represents a bounding box detection in a single image.
-
-    Args:
-        tlwh (ndarray): Bounding box in format `(top left x, top left y,
-            width, height)`.
-        confidence (ndarray): Detector confidence score.
-        feature (Tensor): A feature vector that describes the object
-            contained in this image.
-    """
-
-    def __init__(self, tlwh, confidence, feature):
-        self.tlwh = np.asarray(tlwh, dtype=np.float32)
-        self.confidence = np.asarray(confidence, dtype=np.float32)
-        self.feature = feature.numpy()
-
-    def to_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
-
-    def to_xyah(self):
-        """
-        Convert bounding box to format `(center x, center y, aspect ratio,
-        height)`, where the aspect ratio is `width / height`.
-        """
-        ret = self.tlwh.copy()
-        ret[:2] += ret[2:] / 2
-        ret[2] /= ret[3]
-        return ret
-
-
-def load_det_results(det_file, num_frames):
-    assert os.path.exists(det_file) and os.path.isfile(det_file), \
-        'Error: det_file: {} not exist or not a file.'.format(det_file)
-    labels = np.loadtxt(det_file, dtype='float32', delimiter=',')
-    results_list = []
-    for frame_i in range(0, num_frames):
-        results = {'bbox': [], 'score': []}
-        lables_with_frame = labels[labels[:, 0] == frame_i + 1]
-        for l in lables_with_frame:
-            results['bbox'].append(l[2:6])
-            results['score'].append(l[6])
-        results_list.append(results)
-    return results_list
-
-
-def scale_coords(coords, input_shape, im_shape, scale_factor):
-    im_shape = im_shape.numpy()[0]
-    ratio = scale_factor.numpy()[0][0]
-    img0_shape = [int(im_shape[0] / ratio), int(im_shape[1] / ratio)]
-
-    pad_w = (input_shape[1] - round(img0_shape[1] * ratio)) / 2
-    pad_h = (input_shape[0] - round(img0_shape[0] * ratio)) / 2
-    coords[:, 0::2] -= pad_w
-    coords[:, 1::2] -= pad_h
-    coords[:, 0:4] /= paddle.to_tensor(ratio)
-    coords[:, :4] = paddle.clip(coords[:, :4], min=0, max=coords[:, :4].max())
-    return coords.round()
-
-
-def clip_box(xyxy, input_shape, im_shape, scale_factor):
-    im_shape = im_shape.numpy()[0]
-    ratio = scale_factor.numpy()[0][0]
-    img0_shape = [int(im_shape[0] / ratio), int(im_shape[1] / ratio)]
-
-    xyxy[:, 0::2] = paddle.clip(xyxy[:, 0::2], min=0, max=img0_shape[1])
-    xyxy[:, 1::2] = paddle.clip(xyxy[:, 1::2], min=0, max=img0_shape[0])
-    return xyxy
-
-
-def get_crops(xyxy, ori_img, pred_scores, w, h):
-    crops = []
-    keep_scores = []
-    xyxy = xyxy.numpy().astype(np.int64)
-    ori_img = ori_img.numpy()
-    ori_img = np.squeeze(ori_img, axis=0).transpose(1, 0, 2)
-    pred_scores = pred_scores.numpy()
-    for i, bbox in enumerate(xyxy):
-        if bbox[2] <= bbox[0] or bbox[3] <= bbox[1]:
-            continue
-        crop = ori_img[bbox[0]:bbox[2], bbox[1]:bbox[3], :]
-        crops.append(crop)
-        keep_scores.append(pred_scores[i])
-    if len(crops) == 0:
-        return [], []
-    crops = preprocess_reid(crops, w, h)
-    return crops, keep_scores
-
-
-def preprocess_reid(imgs,
-                    w=64,
-                    h=192,
-                    mean=[0.485, 0.456, 0.406],
-                    std=[0.229, 0.224, 0.225]):
-    im_batch = []
-    for img in imgs:
-        img = cv2.resize(img, (w, h))
-        img = img[:, :, ::-1].astype('float32').transpose((2, 0, 1)) / 255
-        img_mean = np.array(mean).reshape((3, 1, 1))
-        img_std = np.array(std).reshape((3, 1, 1))
-        img -= img_mean
-        img /= img_std
-        img = np.expand_dims(img, axis=0)
-        im_batch.append(img)
-    im_batch = np.concatenate(im_batch, 0)
-    return im_batch

paddlex/ppdet/modeling/mot/visualization.py

@@ -1,130 +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.
-
-import cv2
-import numpy as np
-
-
-def tlwhs_to_tlbrs(tlwhs):
-    tlbrs = np.copy(tlwhs)
-    if len(tlbrs) == 0:
-        return tlbrs
-    tlbrs[:, 2] += tlwhs[:, 0]
-    tlbrs[:, 3] += tlwhs[:, 1]
-    return tlbrs
-
-
-def get_color(idx):
-    idx = idx * 3
-    color = ((37 * idx) % 255, (17 * idx) % 255, (29 * idx) % 255)
-    return color
-
-
-def resize_image(image, max_size=800):
-    if max(image.shape[:2]) > max_size:
-        scale = float(max_size) / max(image.shape[:2])
-        image = cv2.resize(image, None, fx=scale, fy=scale)
-    return image
-
-
-def plot_tracking(image,
-                  tlwhs,
-                  obj_ids,
-                  scores=None,
-                  frame_id=0,
-                  fps=0.,
-                  ids2=None):
-    im = np.ascontiguousarray(np.copy(image))
-    im_h, im_w = im.shape[:2]
-
-    top_view = np.zeros([im_w, im_w, 3], dtype=np.uint8) + 255
-
-    text_scale = max(1, image.shape[1] / 1600.)
-    text_thickness = 2
-    line_thickness = max(1, int(image.shape[1] / 500.))
-
-    radius = max(5, int(im_w / 140.))
-    cv2.putText(
-        im,
-        'frame: %d fps: %.2f num: %d' % (frame_id, fps, len(tlwhs)),
-        (0, int(15 * text_scale)),
-        cv2.FONT_HERSHEY_PLAIN,
-        text_scale, (0, 0, 255),
-        thickness=2)
-
-    for i, tlwh in enumerate(tlwhs):
-        x1, y1, w, h = tlwh
-        intbox = tuple(map(int, (x1, y1, x1 + w, y1 + h)))
-        obj_id = int(obj_ids[i])
-        id_text = '{}'.format(int(obj_id))
-        if ids2 is not None:
-            id_text = id_text + ', {}'.format(int(ids2[i]))
-        _line_thickness = 1 if obj_id <= 0 else line_thickness
-        color = get_color(abs(obj_id))
-        cv2.rectangle(
-            im,
-            intbox[0:2],
-            intbox[2:4],
-            color=color,
-            thickness=line_thickness)
-        cv2.putText(
-            im,
-            id_text, (intbox[0], intbox[1] + 30),
-            cv2.FONT_HERSHEY_PLAIN,
-            text_scale, (0, 0, 255),
-            thickness=text_thickness)
-    return im
-
-
-def plot_trajectory(image, tlwhs, track_ids):
-    image = image.copy()
-    for one_tlwhs, track_id in zip(tlwhs, track_ids):
-        color = get_color(int(track_id))
-        for tlwh in one_tlwhs:
-            x1, y1, w, h = tuple(map(int, tlwh))
-            cv2.circle(
-                image, (int(x1 + 0.5 * w), int(y1 + h)), 2, color, thickness=2)
-    return image
-
-
-def plot_detections(image, tlbrs, scores=None, color=(255, 0, 0), ids=None):
-    im = np.copy(image)
-    text_scale = max(1, image.shape[1] / 800.)
-    thickness = 2 if text_scale > 1.3 else 1
-    for i, det in enumerate(tlbrs):
-        x1, y1, x2, y2 = np.asarray(det[:4], dtype=np.int)
-        if len(det) >= 7:
-            label = 'det' if det[5] > 0 else 'trk'
-            if ids is not None:
-                text = '{}# {:.2f}: {:d}'.format(label, det[6], ids[i])
-                cv2.putText(
-                    im,
-                    text, (x1, y1 + 30),
-                    cv2.FONT_HERSHEY_PLAIN,
-                    text_scale, (0, 255, 255),
-                    thickness=thickness)
-            else:
-                text = '{}# {:.2f}'.format(label, det[6])
-
-        if scores is not None:
-            text = '{:.2f}'.format(scores[i])
-            cv2.putText(
-                im,
-                text, (x1, y1 + 30),
-                cv2.FONT_HERSHEY_PLAIN,
-                text_scale, (0, 255, 255),
-                thickness=thickness)
-
-        cv2.rectangle(im, (x1, y1), (x2, y2), color, 2)
-    return im

paddlex/ppdet/modeling/necks/__init__.py

@@ -1,25 +0,0 @@
-# Copyright (c) 2020 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 fpn
-from . import yolo_fpn
-from . import hrfpn
-from . import ttf_fpn
-from . import centernet_fpn
-
-from .fpn import *
-from .yolo_fpn import *
-from .hrfpn import *
-from .ttf_fpn import *
-from .centernet_fpn import *