Upload entire local dataset folder

.gitignore

@@ -0,0 +1,16 @@
+# Folders
+__pycache__/
+build/
+*.egg-info
+.idea/
+
+
+# Files
+*.weights
+*.pth
+*.pt
+*.t7
+*.mp4
+*.avi
+*.so
+*.txt

.gitmodules

@@ -0,0 +1,6 @@
+[submodule "thirdparty/fast-reid"]
+	path = thirdparty/fast-reid
+	url = https://github.com/JDAI-CV/fast-reid.git
+[submodule "thirdparty/mmdetection"]
+	path = thirdparty/mmdetection
+	url = https://github.com/open-mmlab/mmdetection.git

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Ziqiang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,235 @@
+# Deep Sort with PyTorch
+
+![](demo/demo.gif)
+
+## Update(1-1-2020)
+Changes
+- fix bugs
+- refactor code
+- accerate detection by adding nms on gpu
+
+## Update(07-22)
+Changes
+- bug fix (Thanks @JieChen91 and @yingsen1 for bug reporting).  
+- using batch for feature extracting for each frame, which lead to a small speed up.  
+- code improvement.
+
+Futher improvement direction  
+- Train detector on specific dataset rather than the official one.
+- Retrain REID model on pedestrain dataset for better performance.
+- Replace YOLOv3 detector with advanced ones.
+
+## Update(23-05-2024)
+
+### tracking 
+
+- Added resnet network to the appearance feature extraction network in the deep folder
+
+- Fixed the NMS bug in the `preprocessing.py` and also fixed covariance calculation bug in the `kalmen_filter.py` in the sort folder
+
+### detecting
+
+- Added YOLOv5 detector, aligned interface, and added YOLOv5 related yaml configuration files. Codes references this repo: [YOLOv5-v6.1](https://github.com/ultralytics/yolov5/tree/v6.1).
+
+- The `train.py`, `val.py` and `detect.py` in the original YOLOv5 were deleted. This repo only need **yolov5x.pt**.
+
+### deepsort
+
+- Added tracking target category, which can display both category and tracking ID simultaneously.
+
+## Update(28-05-2024)
+
+### segmentation
+
+* Added Mask RCNN instance segmentation model. Codes references this repo: [mask_rcnn](https://github.com/WZMIAOMIAO/deep-learning-for-image-processing/tree/master/pytorch_object_detection/mask_rcnn). Visual result saved in `demo/demo2.gif`.
+* Similar to YOLOv5, `train.py`, `validation.py` and `predict.py` were deleted. This repo only need **maskrcnn_resnet50_fpn_coco.pth**.
+
+### deepsort
+
+- Added tracking target mask, which can display both category, tracking ID and target mask simultaneously.
+
+## latest Update(09-06-2024)
+
+### feature extraction network
+
+* Using `nn.parallel.DistributedDataParallel` in PyTorch to support multiple GPUs training.
+* Added [GETTING_STARTED.md](deep_sort/deep/GETTING_STARTED.md) for better using `train.py` and `train_multiGPU.py`.
+
+Updated `README.md` for previously updated content(#Update(23-05-2024) and #Update(28-05-2024)).
+
+**Any contributions to this repository is welcome!**
+
+
+## Introduction
+This is an implement of MOT tracking algorithm deep sort. Deep sort is basicly the same with sort but added a CNN model to extract features in image of human part bounded by a detector. This CNN model is indeed a RE-ID model and the detector used in [PAPER](https://arxiv.org/abs/1703.07402) is FasterRCNN , and the original source code is [HERE](https://github.com/nwojke/deep_sort).  
+However in original code, the CNN model is implemented with tensorflow, which I'm not familier with. SO I re-implemented the CNN feature extraction model with PyTorch, and changed the CNN model a little bit. Also, I use **YOLOv3** to generate bboxes instead of FasterRCNN.
+
+## Dependencies
+- python 3 **(python2 not sure)**
+- numpy
+- scipy
+- opencv-python
+- sklearn
+- torch >= 1.9
+- torchvision >= 0.13
+- pillow
+- vizer
+- edict
+- matplotlib
+- pycocotools
+- tqdm
+
+## Quick Start
+0. Check all dependencies installed
+```bash
+pip install -r requirements.txt
+```
+for user in china, you can specify pypi source to accelerate install like:
+```bash
+pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+1. Clone this repository
+```bash
+git clone [email protected]:ZQPei/deep_sort_pytorch.git
+```
+
+2. Download detector parameters
+```bash
+# if you use YOLOv3 as detector in this repo
+cd detector/YOLOv3/weight/
+wget https://pjreddie.com/media/files/yolov3.weights
+wget https://pjreddie.com/media/files/yolov3-tiny.weights
+cd ../../../
+
+# if you use YOLOv5 as detector in this repo
+cd detector/YOLOv5
+wget https://github.com/ultralytics/yolov5/releases/download/v6.1/yolov5s.pt
+or 
+wget https://github.com/ultralytics/yolov5/releases/download/v6.1/yolov5m.pt
+cd ../../
+
+# if you use Mask RCNN as detector in this repo
+cd detector/Mask_RCNN/save_weights
+wget https://download.pytorch.org/models/maskrcnn_resnet50_fpn_coco-bf2d0c1e.pth
+cd ../../../
+```
+
+3. Download deepsort feature extraction networks weight
+```bash
+# if you use original model in PAPER
+cd deep_sort/deep/checkpoint
+# download ckpt.t7 from
+https://drive.google.com/drive/folders/1xhG0kRH1EX5B9_Iz8gQJb7UNnn_riXi6 to this folder
+cd ../../../
+
+# if you use resnet18 in this repo
+cd deep_sort/deep/checkpoint
+wget https://download.pytorch.org/models/resnet18-5c106cde.pth
+cd ../../../
+```
+
+4. **(Optional)** Compile nms module if you use YOLOv3 as detetor in this repo
+```bash
+cd detector/YOLOv3/nms
+sh build.sh
+cd ../../..
+```
+
+Notice:
+If compiling failed, the simplist way is to **Upgrade your pytorch >= 1.1 and torchvision >= 0.3" and you can avoid the troublesome compiling problems which are most likely caused by either `gcc version too low` or `libraries missing`.
+
+5. **(Optional)** Prepare third party submodules
+
+[fast-reid](https://github.com/JDAI-CV/fast-reid)
+
+This library supports bagtricks, AGW and other mainstream ReID methods through providing an fast-reid adapter.
+
+to prepare our bundled fast-reid, then follow instructions in its README to install it.
+
+Please refer to `configs/fastreid.yaml` for a sample of using fast-reid. See [Model Zoo](https://github.com/JDAI-CV/fast-reid/blob/master/docs/MODEL_ZOO.md) for available methods and trained models.
+
+[MMDetection](https://github.com/open-mmlab/mmdetection)
+
+This library supports Faster R-CNN and other mainstream detection methods through providing an MMDetection adapter.
+
+to prepare our bundled MMDetection, then follow instructions in its README to install it.
+
+Please refer to `configs/mmdet.yaml` for a sample of using MMDetection. See [Model Zoo](https://github.com/open-mmlab/mmdetection/blob/master/docs/model_zoo.md) for available methods and trained models.
+
+Run
+
+```
+git submodule update --init --recursive
+```
+
+
+6. Run demo
+```bash
+usage: deepsort.py [-h]
+                   [--fastreid]
+                   [--config_fastreid CONFIG_FASTREID]
+                   [--mmdet]
+                   [--config_mmdetection CONFIG_MMDETECTION]
+                   [--config_detection CONFIG_DETECTION]
+                   [--config_deepsort CONFIG_DEEPSORT] [--display]
+                   [--frame_interval FRAME_INTERVAL]
+                   [--display_width DISPLAY_WIDTH]
+                   [--display_height DISPLAY_HEIGHT] [--save_path SAVE_PATH]
+                   [--cpu] [--camera CAM]
+                   VIDEO_PATH         
+
+# yolov3 + deepsort
+python deepsort.py [VIDEO_PATH] --config_detection ./configs/yolov3.yaml
+
+# yolov3_tiny + deepsort
+python deepsort.py [VIDEO_PATH] --config_detection ./configs/yolov3_tiny.yaml
+
+# yolov3 + deepsort on webcam
+python3 deepsort.py /dev/video0 --camera 0
+
+# yolov3_tiny + deepsort on webcam
+python3 deepsort.py /dev/video0 --config_detection ./configs/yolov3_tiny.yaml --camera 0
+
+# yolov5s + deepsort
+python deepsort.py [VIDEO_PATH] --config_detection ./configs/yolov5s.yaml
+
+# yolov5m + deepsort
+python deepsort.py [VIDEO_PATH] --config_detection ./configs/yolov5m.yaml
+
+# mask_rcnn + deepsort
+python deepsort.py [VIDEO_PATH] --config_detection ./configs/mask_rcnn.yaml --segment
+
+# fast-reid + deepsort
+python deepsort.py [VIDEO_PATH] --fastreid [--config_fastreid ./configs/fastreid.yaml]
+
+# MMDetection + deepsort
+python deepsort.py [VIDEO_PATH] --mmdet [--config_mmdetection ./configs/mmdet.yaml]
+```
+Use `--display` to enable display image per frame.  
+Results will be saved to `./output/results.avi` and `./output/results.txt`.
+
+All files above can also be accessed from BaiduDisk!  
+linker：[BaiduDisk](https://pan.baidu.com/s/1YJ1iPpdFTlUyLFoonYvozg)
+passwd：fbuw
+
+## Training the RE-ID model
+Check [GETTING_STARTED.md](deep_sort/deep/GETTING_STARTED.md) to start training progress using standard benchmark or **customized dataset**.
+
+## Demo videos and images
+[demo.avi](https://drive.google.com/drive/folders/1xhG0kRH1EX5B9_Iz8gQJb7UNnn_riXi6)
+[demo2.avi](https://drive.google.com/drive/folders/1xhG0kRH1EX5B9_Iz8gQJb7UNnn_riXi6)
+
+![1.jpg](demo/1.jpg)
+![2.jpg](demo/2.jpg)
+
+
+## References
+- paper: [Simple Online and Realtime Tracking with a Deep Association Metric](https://arxiv.org/abs/1703.07402)
+- code: [nwojke/deep_sort](https://github.com/nwojke/deep_sort)
+- paper: [YOLOv3: An Incremental Improvement](https://pjreddie.com/media/files/papers/YOLOv3.pdf)
+- code: [Joseph Redmon/yolov3](https://pjreddie.com/darknet/yolo/)
+- paper: [Mask R-CNN](https://arxiv.org/pdf/1703.06870)
+- code: [WZMIAOMIAO/Mask R-CNN](https://github.com/WZMIAOMIAO/deep-learning-for-image-processing/tree/master/pytorch_object_detection/mask_rcnn)
+- paper: [YOLOv5](https://github.com/ultralytics/yolov5)
+- code: [ultralytics/yolov5](https://github.com/ultralytics/yolov5/tree/v6.1)

coco_classes.json

@@ -0,0 +1,82 @@
+{
+  "0": "person",
+  "1": "bicycle",
+  "10": "fire hydrant",
+  "11": "stop sign",
+  "12": "parking meter",
+  "13": "bench",
+  "14": "bird",
+  "15": "cat",
+  "16": "dog",
+  "17": "horse",
+  "18": "sheep",
+  "19": "cow",
+  "2": "car",
+  "20": "elephant",
+  "21": "bear",
+  "22": "zebra",
+  "23": "giraffe",
+  "24": "backpack",
+  "25": "umbrella",
+  "26": "handbag",
+  "27": "tie",
+  "28": "suitcase",
+  "29": "frisbee",
+  "3": "motorcycle",
+  "30": "skis",
+  "31": "snowboard",
+  "32": "sports ball",
+  "33": "kite",
+  "34": "baseball bat",
+  "35": "baseball glove",
+  "36": "skateboard",
+  "37": "surfboard",
+  "38": "tennis racket",
+  "39": "bottle",
+  "4": "airplane",
+  "40": "wine glass",
+  "41": "cup",
+  "42": "fork",
+  "43": "knife",
+  "44": "spoon",
+  "45": "bowl",
+  "46": "banana",
+  "47": "apple",
+  "48": "sandwich",
+  "49": "orange",
+  "5": "bus",
+  "50": "broccoli",
+  "51": "carrot",
+  "52": "hot dog",
+  "53": "pizza",
+  "54": "donut",
+  "55": "cake",
+  "56": "chair",
+  "57": "couch",
+  "58": "potted plant",
+  "59": "bed",
+  "6": "train",
+  "60": "dining table",
+  "61": "toilet",
+  "62": "tv",
+  "63": "laptop",
+  "64": "mouse",
+  "65": "remote",
+  "66": "keyboard",
+  "67": "cell phone",
+  "68": "microwave",
+  "69": "oven",
+  "7": "truck",
+  "70": "toaster",
+  "71": "sink",
+  "72": "refrigerator",
+  "73": "book",
+  "74": "clock",
+  "75": "vase",
+  "76": "scissors",
+  "77": "teddy bear",
+  "78": "hair drier",
+  "79": "toothbrush",
+  "8": "boat",
+  "9": "traffic light"
+}

configs/deep_sort.yaml

@@ -0,0 +1,10 @@
+DEEPSORT:
+  REID_CKPT: "./deep_sort/deep/checkpoint/ckpt.t7"
+  MAX_DIST: 0.2
+  MIN_CONFIDENCE: 0.5
+  NMS_MAX_OVERLAP: 0.5
+  MAX_IOU_DISTANCE: 0.7
+  MAX_AGE: 70
+  N_INIT: 3
+  NN_BUDGET: 100
+  

configs/fastreid.yaml

@@ -0,0 +1,3 @@
+FASTREID:
+  CFG: "thirdparty/fast-reid/configs/Market1501/bagtricks_R50.yml"
+  CHECKPOINT: "deep_sort/deep/checkpoint/market_bot_R50.pth"

configs/mask_rcnn.yaml

@@ -0,0 +1,6 @@
+MASKRCNN:
+  LABEL: "./coco_classes.json"
+  WEIGHT: "./detector/Mask_RCNN/save_weights/maskrcnn_resnet50_fpn_coco.pth"
+
+  NUM_CLASSES: 90
+  BOX_THRESH: 0.5

configs/mmdet.yaml

@@ -0,0 +1,5 @@
+MMDET:
+  CFG: "thirdparty/mmdetection/configs/faster_rcnn/faster_rcnn_r50_fpn_1x_coco.py"
+  CHECKPOINT: "detector/MMDet/weight/faster_rcnn_r50_fpn_1x_coco_20200130-047c8118.pth"
+
+  SCORE_THRESH: 0.5

configs/yolov3.yaml

@@ -0,0 +1,7 @@
+YOLOV3:
+  CFG: "./detector/YOLOv3/cfg/yolo_v3.cfg"
+  WEIGHT: "./detector/YOLOv3/weight/yolov3.weights"
+  CLASS_NAMES: "./detector/YOLOv3/cfg/coco.names"
+
+  SCORE_THRESH: 0.5
+  NMS_THRESH: 0.4

configs/yolov3_tiny.yaml

@@ -0,0 +1,7 @@
+YOLOV3:
+  CFG: "./detector/YOLOv3/cfg/yolov3-tiny.cfg"
+  WEIGHT: "./detector/YOLOv3/weight/yolov3-tiny.weights"
+  CLASS_NAMES: "./detector/YOLOv3/cfg/coco.names"
+
+  SCORE_THRESH: 0.5
+  NMS_THRESH: 0.4

configs/yolov5l.yaml

@@ -0,0 +1,9 @@
+YOLOV5:
+  CFG: "./detector/YOLOv5/models/yolov5l.yaml"
+  WEIGHT: "./detector/YOLOv5/yolov5l.pt"
+  DATA: './detector/YOLOv5/data/coco128.yaml'
+
+  IMGSZ: [640, 640]
+  SCORE_THRESH: 0.25
+  NMS_THRESH: 0.45
+  MAX_DET: 100

configs/yolov5m.yaml

@@ -0,0 +1,9 @@
+YOLOV5:
+  CFG: "./detector/YOLOv5/models/yolov5m.yaml"
+  WEIGHT: "./detector/YOLOv5/yolov5m.pt"
+  DATA: './detector/YOLOv5/data/coco128.yaml'
+
+  IMGSZ: [640, 640]
+  SCORE_THRESH: 0.25
+  NMS_THRESH: 0.45
+  MAX_DET: 100

configs/yolov5n.yaml

@@ -0,0 +1,9 @@
+YOLOV5:
+  CFG: "./detector/YOLOv5/models/yolov5n.yaml"
+  WEIGHT: "./detector/YOLOv5/yolov5n.pt"
+  DATA: './detector/YOLOv5/data/coco128.yaml'
+
+  IMGSZ: [640, 640]
+  SCORE_THRESH: 0.25
+  NMS_THRESH: 0.45
+  MAX_DET: 100

configs/yolov5s.yaml

@@ -0,0 +1,9 @@
+YOLOV5:
+  CFG: "./detector/YOLOv5/models/yolov5s.yaml"
+  WEIGHT: "./detector/YOLOv5/yolov5s.pt"
+  DATA: './detector/YOLOv5/data/coco128.yaml'
+
+  IMGSZ: [640, 640]
+  SCORE_THRESH: 0.25
+  NMS_THRESH: 0.45
+  MAX_DET: 100

configs/yolov5x.yaml

@@ -0,0 +1,9 @@
+YOLOV5:
+  CFG: "./detector/YOLOv5/models/yolov5x.yaml"
+  WEIGHT: "./detector/YOLOv5/yolov5x.pt"
+  DATA: './detector/YOLOv5/data/coco128.yaml'
+
+  IMGSZ: [640, 640]
+  SCORE_THRESH: 0.25
+  NMS_THRESH: 0.45
+  MAX_DET: 100

deep_sort/README.md

@@ -0,0 +1,3 @@
+# Deep Sort 
+
+This is the implemention of deep sort with pytorch.

deep_sort/__init__.py

@@ -0,0 +1,19 @@
+from .deep_sort import DeepSort
+
+__all__ = ['DeepSort', 'build_tracker']
+
+
+def build_tracker(cfg, use_cuda):
+    if cfg.USE_FASTREID:
+        return DeepSort(model_path=cfg.FASTREID.CHECKPOINT, model_config=cfg.FASTREID.CFG,
+                        max_dist=cfg.DEEPSORT.MAX_DIST, min_confidence=cfg.DEEPSORT.MIN_CONFIDENCE,
+                        nms_max_overlap=cfg.DEEPSORT.NMS_MAX_OVERLAP, max_iou_distance=cfg.DEEPSORT.MAX_IOU_DISTANCE,
+                        max_age=cfg.DEEPSORT.MAX_AGE, n_init=cfg.DEEPSORT.N_INIT, nn_budget=cfg.DEEPSORT.NN_BUDGET,
+                        use_cuda=use_cuda)
+
+    else:
+        return DeepSort(model_path=cfg.DEEPSORT.REID_CKPT,
+                        max_dist=cfg.DEEPSORT.MAX_DIST, min_confidence=cfg.DEEPSORT.MIN_CONFIDENCE,
+                        nms_max_overlap=cfg.DEEPSORT.NMS_MAX_OVERLAP, max_iou_distance=cfg.DEEPSORT.MAX_IOU_DISTANCE,
+                        max_age=cfg.DEEPSORT.MAX_AGE, n_init=cfg.DEEPSORT.N_INIT, nn_budget=cfg.DEEPSORT.NN_BUDGET,
+                        use_cuda=use_cuda)

deep_sort/deep/GETTING_STARTED.md

@@ -0,0 +1,82 @@
+In deepsort algorithm, appearance feature extraction network used to extract features from **image_crops** for matching purpose.The original model used in paper is in `model.py`, and its parameter here [ckpt.t7](https://drive.google.com/drive/folders/1xhG0kRH1EX5B9_Iz8gQJb7UNnn_riXi6). This repository also provides a `resnet.py` script and its pre-training weights on Imagenet here.
+
+```
+# resnet18
+https://download.pytorch.org/models/resnet18-5c106cde.pth
+# resnet34    
+https://download.pytorch.org/models/resnet34-333f7ec4.pth
+# resnet50
+https://download.pytorch.org/models/resnet50-19c8e357.pth
+# resnext50_32x4d
+https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth
+```
+
+## Dataset PrePare
+
+To train the model, first you need download [Market1501](http://www.liangzheng.com.cn/Project/project_reid.html) dataset or [Mars](http://www.liangzheng.com.cn/Project/project_mars.html) dataset.  
+
+If you want to train on your **own dataset**, assuming you have already downloaded the dataset.The dataset should be arranged in the following way.
+
+```
+ ├── dataset_root: The root dir of the dataset.
+  ├── class1: Category 1 is located in the folder dir.
+   ├── xxx1.jpg: Image belonging to category 1.
+   ├── xxx2.jpg: Image belonging to category 1.
+  ├── class2: Category 2 is located in the folder dir.
+   ├── xxx3.jpg: Image belonging to category 2.
+   ├── xxx4.jpg: Image belonging to category 2.
+  ├── class3: Category 3 is located in the folder dir.
+  ...
+  ...
+```
+
+## Training the RE-ID model
+
+Assuming you have already prepare the dataset. Then you can use the following command to start your training progress.
+
+#### training on a single GPU
+
+```python
+usage: train.py [--data-dir]
+                [--epochs]
+                [--batch_size]
+                [--lr]
+                [--lrf]
+                [--weights]
+                [--freeze-layers]
+                [--gpu_id]
+
+# default use cuda:0, use Net in `model.py`
+python train.py --data-dir [dataset/root/path] --weights [(optional)pre-train/weight/path]
+# you can use `--freeze-layers` option to freeze full convolutional layer parameters except fc layers parameters
+python train.py --data-dir [dataset/root/path] --weights [(optional)pre-train/weight/path] --freeze-layers
+```
+
+#### training on multiple GPU
+
+```python
+usage: train_multiGPU.py [--data-dir]
+                         [--epochs]
+                         [--batch_size]
+                         [--lr]
+                         [--lrf]
+                         [--syncBN]
+                         [--weights]
+                         [--freeze-layers]
+                         # not change the following parameters, the system will automatically assignment
+                         [--device]
+                         [--world_size]
+                         [--dist_url]
+                         
+# default use cuda:0, cuda:1, cuda:2, cuda:3, use resnet18 in `resnet.py`
+CUDA_VISIBLE_DEVICES=0,1,2,3 torchrun --nproc_per_node=4 train_multiGPU.py --data-dir [dataset/root/path] --weights [(optional)pre-train/weight/path] 
+# you can use `--freeze-layers` option to freeze full convolutional layer parameters except fc layers parameters
+CUDA_VISIBLE_DEVICES=0,1,2,3 torchrun --nproc_per_node=4 train_multiGPU.py --data-dir [dataset/root/path] --weights [(optional)pre-train/weight/path] --freeze-layers
+```
+
+An example of training progress is as follows:
+
+![train.jpg](./train.jpg)
+
+The last, you can evaluate it using [test.py](deep_sort/deep/test.py) and [evaluate.py](deep_sort/deep/evalute.py).
+

deep_sort/deep/datasets.py

@@ -0,0 +1,92 @@
+import json
+import os
+import random
+
+import cv2
+from PIL import Image
+import torch
+from torch.utils.data import Dataset
+import matplotlib.pyplot as plt
+
+
+class ClsDataset(Dataset):
+    def __init__(self, images_path, images_labels, transform=None):
+        self.images_path = images_path
+        self.images_labels = images_labels
+        self.transform = transform
+
+    def __len__(self):
+        return len(self.images_path)
+
+    def __getitem__(self, idx):
+        img = cv2.imread(self.images_path[idx])
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        img = Image.fromarray(img)
+        label = self.images_labels[idx]
+
+        if self.transform is not None:
+            img = self.transform(img)
+        return img, label
+
+    @staticmethod
+    def collate_fn(batch):
+        images, labels = tuple(zip(*batch))
+        images = torch.stack(images, dim=0)
+        labels = torch.as_tensor(labels)
+        return images, labels
+
+
+def read_split_data(root, valid_rate=0.2):
+    assert os.path.exists(root), 'dataset root: {} does not exist.'.format(root)
+
+    class_names = [cls for cls in os.listdir(root) if os.path.isdir(os.path.join(root, cls))]
+    class_names.sort()
+
+    class_indices = {name: i for i, name in enumerate(class_names)}
+    json_str = json.dumps({v: k for k, v in class_indices.items()}, indent=4)
+    with open('class_indices.json', 'w') as f:
+        f.write(json_str)
+
+    train_images_path = []
+    train_labels = []
+    val_images_path = []
+    val_labels = []
+    per_class_num = []
+
+    supported = ['.jpg', '.JPG', '.png', '.PNG']
+    for cls in class_names:
+        cls_path = os.path.join(root, cls)
+        images_path = [os.path.join(cls_path, i) for i in os.listdir(cls_path)
+                       if os.path.splitext(i)[-1] in supported]
+        images_label = class_indices[cls]
+        per_class_num.append(len(images_path))
+
+        val_path = random.sample(images_path, int(len(images_path) * valid_rate))
+        for img_path in images_path:
+            if img_path in val_path:
+                val_images_path.append(img_path)
+                val_labels.append(images_label)
+            else:
+                train_images_path.append(img_path)
+                train_labels.append(images_label)
+
+    print("{} images were found in the dataset.".format(sum(per_class_num)))
+    print("{} images for training.".format(len(train_images_path)))
+    print("{} images for validation.".format(len(val_images_path)))
+
+    assert len(train_images_path) > 0, "number of training images must greater than zero"
+    assert len(val_images_path) > 0, "number of validation images must greater than zero"
+
+    plot_distribution = False
+    if plot_distribution:
+        plt.bar(range(len(class_names)), per_class_num, align='center')
+        plt.xticks(range(len(class_names)), class_names)
+
+        for i, v in enumerate(per_class_num):
+            plt.text(x=i, y=v + 5, s=str(v), ha='center')
+
+        plt.xlabel('classes')
+        plt.ylabel('numbers')
+        plt.title('the distribution of dataset')
+        plt.show()
+    return [train_images_path, train_labels], [val_images_path, val_labels], len(class_names)

deep_sort/deep/evaluate.py

@@ -0,0 +1,15 @@
+import torch
+
+features = torch.load("features.pth")
+qf = features["qf"]
+ql = features["ql"]
+gf = features["gf"]
+gl = features["gl"]
+
+scores = qf.mm(gf.t())
+res = scores.topk(5, dim=1)[1][:,0]
+top1correct = gl[res].eq(ql).sum().item()
+
+print("Acc top1:{:.3f}".format(top1correct/ql.size(0)))
+
+

deep_sort/deep/feature_extractor.py

@@ -0,0 +1,93 @@
+import torch
+import torchvision.transforms as transforms
+import numpy as np
+import cv2
+import logging
+
+from .model import Net
+from .resnet import resnet18
+# from fastreid.config import get_cfg
+# from fastreid.engine import DefaultTrainer
+# from fastreid.utils.checkpoint import Checkpointer
+
+
+class Extractor(object):
+    def __init__(self, model_path, use_cuda=True):
+        self.net = Net(reid=True)
+        # self.net = resnet18(reid=True)
+        self.device = "cuda" if torch.cuda.is_available() and use_cuda else "cpu"
+        state_dict = torch.load(model_path, map_location=lambda storage, loc: storage)
+        self.net.load_state_dict(state_dict if 'net_dict' not in state_dict else state_dict['net_dict'], strict=False)
+        logger = logging.getLogger("root.tracker")
+        logger.info("Loading weights from {}... Done!".format(model_path))
+        self.net.to(self.device)
+        self.size = (64, 128)
+        self.norm = transforms.Compose([
+            transforms.ToTensor(),
+            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+        ])
+
+    def _preprocess(self, im_crops):
+        """
+        TODO:
+            1. to float with scale from 0 to 1
+            2. resize to (64, 128) as Market1501 dataset did
+            3. concatenate to a numpy array
+            3. to torch Tensor
+            4. normalize
+        """
+
+        def _resize(im, size):
+            return cv2.resize(im.astype(np.float32) / 255., size)
+
+        im_batch = torch.cat([self.norm(_resize(im, self.size)).unsqueeze(0) for im in im_crops], dim=0).float()
+        return im_batch
+
+    def __call__(self, im_crops):
+        im_batch = self._preprocess(im_crops)
+        with torch.no_grad():
+            im_batch = im_batch.to(self.device)
+            features = self.net(im_batch)
+        return features.cpu().numpy()
+
+
+class FastReIDExtractor(object):
+    def __init__(self, model_config, model_path, use_cuda=True):
+        cfg = get_cfg()
+        cfg.merge_from_file(model_config)
+        cfg.MODEL.BACKBONE.PRETRAIN = False
+        self.net = DefaultTrainer.build_model(cfg)
+        self.device = "cuda" if torch.cuda.is_available() and use_cuda else "cpu"
+
+        Checkpointer(self.net).load(model_path)
+        logger = logging.getLogger("root.tracker")
+        logger.info("Loading weights from {}... Done!".format(model_path))
+        self.net.to(self.device)
+        self.net.eval()
+        height, width = cfg.INPUT.SIZE_TEST
+        self.size = (width, height)
+        self.norm = transforms.Compose([
+            transforms.ToTensor(),
+            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+        ])
+
+    def _preprocess(self, im_crops):
+        def _resize(im, size):
+            return cv2.resize(im.astype(np.float32) / 255., size)
+
+        im_batch = torch.cat([self.norm(_resize(im, self.size)).unsqueeze(0) for im in im_crops], dim=0).float()
+        return im_batch
+
+    def __call__(self, im_crops):
+        im_batch = self._preprocess(im_crops)
+        with torch.no_grad():
+            im_batch = im_batch.to(self.device)
+            features = self.net(im_batch)
+        return features.cpu().numpy()
+
+
+if __name__ == '__main__':
+    img = cv2.imread("demo.jpg")[:, :, (2, 1, 0)]
+    extr = Extractor("checkpoint/ckpt.t7")
+    feature = extr(img)
+    print(feature.shape)

deep_sort/deep/model.py

@@ -0,0 +1,105 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class BasicBlock(nn.Module):
+    def __init__(self, c_in, c_out, is_downsample=False):
+        super(BasicBlock, self).__init__()
+        self.is_downsample = is_downsample
+        if is_downsample:
+            self.conv1 = nn.Conv2d(c_in, c_out, 3, stride=2, padding=1, bias=False)
+        else:
+            self.conv1 = nn.Conv2d(c_in, c_out, 3, stride=1, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(c_out)
+        self.relu = nn.ReLU(True)
+        self.conv2 = nn.Conv2d(c_out, c_out, 3, stride=1, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(c_out)
+        if is_downsample:
+            self.downsample = nn.Sequential(
+                nn.Conv2d(c_in, c_out, 1, stride=2, bias=False),
+                nn.BatchNorm2d(c_out)
+            )
+        elif c_in != c_out:
+            self.downsample = nn.Sequential(
+                nn.Conv2d(c_in, c_out, 1, stride=1, bias=False),
+                nn.BatchNorm2d(c_out)
+            )
+            self.is_downsample = True
+
+    def forward(self, x):
+        y = self.conv1(x)
+        y = self.bn1(y)
+        y = self.relu(y)
+        y = self.conv2(y)
+        y = self.bn2(y)
+        if self.is_downsample:
+            x = self.downsample(x)
+        return F.relu(x.add(y), True)
+
+
+def make_layers(c_in, c_out, repeat_times, is_downsample=False):
+    blocks = []
+    for i in range(repeat_times):
+        if i == 0:
+            blocks += [BasicBlock(c_in, c_out, is_downsample=is_downsample), ]
+        else:
+            blocks += [BasicBlock(c_out, c_out), ]
+    return nn.Sequential(*blocks)
+
+
+class Net(nn.Module):
+    def __init__(self, num_classes=751, reid=False):
+        super(Net, self).__init__()
+        # 3 128 64
+        self.conv = nn.Sequential(
+            nn.Conv2d(3, 64, 3, stride=1, padding=1),
+            nn.BatchNorm2d(64),
+            nn.ReLU(inplace=True),
+            # nn.Conv2d(32,32,3,stride=1,padding=1),
+            # nn.BatchNorm2d(32),
+            # nn.ReLU(inplace=True),
+            nn.MaxPool2d(3, 2, padding=1),
+        )
+        # 32 64 32
+        self.layer1 = make_layers(64, 64, 2, False)
+        # 32 64 32
+        self.layer2 = make_layers(64, 128, 2, True)
+        # 64 32 16
+        self.layer3 = make_layers(128, 256, 2, True)
+        # 128 16 8
+        self.layer4 = make_layers(256, 512, 2, True)
+        # 256 8 4
+        self.avgpool = nn.AdaptiveAvgPool2d(1)
+        # 256 1 1 
+        self.reid = reid
+        self.classifier = nn.Sequential(
+            nn.Linear(512, 256),
+            nn.BatchNorm1d(256),
+            nn.ReLU(inplace=True),
+            nn.Dropout(),
+            nn.Linear(256, num_classes),
+        )
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+        x = self.avgpool(x)
+        x = x.view(x.size(0), -1)
+        # B x 128
+        if self.reid:
+            x = x.div(x.norm(p=2, dim=1, keepdim=True))
+            return x
+        # classifier
+        x = self.classifier(x)
+        return x
+
+
+if __name__ == '__main__':
+    net = Net()
+    x = torch.randn(4, 3, 128, 64)
+    y = net(x)
+

deep_sort/deep/multi_train_utils/distributed_utils.py

@@ -0,0 +1,67 @@
+import os
+
+import torch
+import torch.distributed as dist
+
+
+def init_distributed_mode(args):
+    if 'RANK' in os.environ and 'WORLD_SIZE' in os.environ:
+        args.rank = int(os.environ['RANK'])
+        args.world_size = int(os.environ['WORLD_SIZE'])
+        args.gpu = int(os.environ['LOCAL_RANK'])
+    elif 'SLURM_PROCID' in os.environ:
+        args.rank = int(os.environ['SLURM_PROCID'])
+        args.gpu = args.rank % torch.cuda.device_count()
+    else:
+        print("Not using distributed mode")
+        args.distributed = False
+        return
+
+    args.distributed = True
+
+    torch.cuda.set_device(args.gpu)
+    args.dist_backend = 'nccl'
+    print('| distributed init (rank {}): {}'.format(args.rank, args.dist_url), flush=True)
+    dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
+                            world_size=args.world_size, rank=args.rank)
+    dist.barrier()
+
+
+def cleanup():
+    dist.destroy_process_group()
+
+
+def is_dist_avail_and_initialized():
+    if not dist.is_available():
+        return False
+    if not dist.is_initialized():
+        return False
+    return True
+
+
+def get_world_size():
+    if not is_dist_avail_and_initialized():
+        return 1
+    return dist.get_world_size()
+
+
+def get_rank():
+    if not is_dist_avail_and_initialized():
+        return 0
+    return dist.get_rank()
+
+
+def is_main_process():
+    return get_rank() == 0
+
+
+def reduce_value(value, average=True):
+    world_size = get_world_size()
+    if world_size < 2:
+        return value
+    with torch.no_grad():
+        dist.all_reduce(value)
+        if average:
+            value /= world_size
+
+        return value

deep_sort/deep/multi_train_utils/train_eval_utils.py

@@ -0,0 +1,90 @@
+import sys
+
+from tqdm import tqdm
+import torch
+
+from .distributed_utils import reduce_value, is_main_process
+
+
+def load_model(state_dict, model_state_dict, model):
+    for k in state_dict:
+        if k in model_state_dict:
+            if state_dict[k].shape != model_state_dict[k].shape:
+                print('Skip loading parameter {}, required shape {}, ' \
+                      'loaded shape {}.'.format(
+                    k, model_state_dict[k].shape, state_dict[k].shape))
+                state_dict[k] = model_state_dict[k]
+        else:
+            print('Drop parameter {}.'.format(k))
+    for k in model_state_dict:
+        if not (k in state_dict):
+            print('No param {}.'.format(k))
+            state_dict[k] = model_state_dict[k]
+    model.load_state_dict(state_dict, strict=False)
+    return model
+
+
+def train_one_epoch(model, optimizer, data_loader, device, epoch):
+    model.train()
+    criterion = torch.nn.CrossEntropyLoss()
+    mean_loss = torch.zeros(1).to(device)
+    sum_num = torch.zeros(1).to(device)
+    optimizer.zero_grad()
+
+    if is_main_process():
+        data_loader = tqdm(data_loader, file=sys.stdout)
+
+    for idx, (images, labels) in enumerate(data_loader):
+        # forward
+        images, labels = images.to(device), labels.to(device)
+        outputs = model(images)
+        loss = criterion(outputs, labels)
+
+        # backward
+        loss.backward()
+        loss = reduce_value(loss, average=True)
+        mean_loss = (mean_loss * idx + loss.detach()) / (idx + 1)
+        pred = torch.max(outputs, dim=1)[1]
+        sum_num += torch.eq(pred, labels).sum()
+
+        if is_main_process():
+            data_loader.desc = '[epoch {}] mean loss {}'.format(epoch, mean_loss.item())
+
+        if not torch.isfinite(loss):
+            print('loss is infinite, ending training')
+            sys.exit(1)
+
+        optimizer.step()
+        optimizer.zero_grad()
+    if device != torch.device('cpu'):
+        torch.cuda.synchronize(device)
+    sum_num = reduce_value(sum_num, average=False)
+
+    return sum_num.item(), mean_loss.item()
+
+
+@torch.no_grad()
+def evaluate(model, data_loader, device):
+    model.eval()
+    criterion = torch.nn.CrossEntropyLoss()
+    test_loss = torch.zeros(1).to(device)
+    sum_num = torch.zeros(1).to(device)
+    if is_main_process():
+        data_loader = tqdm(data_loader, file=sys.stdout)
+
+    for idx, (inputs, labels) in enumerate(data_loader):
+        inputs, labels = inputs.to(device), labels.to(device)
+        outputs = model(inputs)
+        loss = criterion(outputs, labels)
+        loss = reduce_value(loss, average=True)
+
+        test_loss = (test_loss * idx + loss.detach()) / (idx + 1)
+        pred = torch.max(outputs, dim=1)[1]
+        sum_num += torch.eq(pred, labels).sum()
+
+    if device != torch.device('cpu'):
+        torch.cuda.synchronize(device)
+
+    sum_num = reduce_value(sum_num, average=False)
+
+    return sum_num.item(), test_loss.item()

deep_sort/deep/resnet.py

@@ -0,0 +1,173 @@
+import torch.nn as nn
+import torch
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, in_channel, out_channel, stride=1, downsample=None, **kwargs):
+        super(BasicBlock, self).__init__()
+        self.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=out_channel, kernel_size=3,
+                               stride=stride, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(out_channel)
+        self.relu = nn.ReLU()
+        self.conv2 = nn.Conv2d(in_channels=out_channel, out_channels=out_channel, kernel_size=3,
+                               stride=1, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(out_channel)
+        self.downsample = downsample
+
+    def forward(self, x):
+        identity = x
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        out += identity
+        out = self.relu(out)
+        return out
+
+
+class Bottleneck(nn.Module):
+    expansion = 4
+
+    def __init__(self, in_channel, out_channel, stride=1, downsample=None,
+                 groups=1, width_per_group=64):
+        super(Bottleneck, self).__init__()
+        width = int(out_channel * (width_per_group / 64.)) * groups
+
+        self.conv1 = nn.Conv2d(in_channels=in_channel, out_channels=width, kernel_size=1,
+                               stride=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(width)
+        self.conv2 = nn.Conv2d(in_channels=width, out_channels=width, kernel_size=3,
+                               stride=stride, padding=1, bias=False, groups=groups)
+        self.bn2 = nn.BatchNorm2d(width)
+        self.conv3 = nn.Conv2d(in_channels=width, out_channels=out_channel * self.expansion,
+                               kernel_size=1, stride=1, bias=False)
+        self.bn3 = nn.BatchNorm2d(out_channel * self.expansion)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+
+    def forward(self, x):
+        identity = x
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        out += identity
+        out = self.relu(out)
+
+        return out
+
+
+class ResNet(nn.Module):
+
+    def __init__(self, block, blocks_num, reid=False, num_classes=1000, groups=1, width_per_group=64):
+        super(ResNet, self).__init__()
+        self.reid = reid
+        self.in_channel = 64
+
+        self.groups = groups
+        self.width_per_group = width_per_group
+
+        self.conv1 = nn.Conv2d(3, self.in_channel, kernel_size=7, stride=2,
+                               padding=3, bias=False)
+        self.bn1 = nn.BatchNorm2d(self.in_channel)
+        self.relu = nn.ReLU(inplace=True)
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.layer1 = self._make_layers(block, 64, blocks_num[0])
+        self.layer2 = self._make_layers(block, 128, blocks_num[1], stride=2)
+        self.layer3 = self._make_layers(block, 256, blocks_num[2], stride=2)
+        # self.layer4 = self._make_layers(block, 512, blocks_num[3], stride=1)
+
+        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+        self.fc = nn.Linear(256 * block.expansion, num_classes)
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+    def _make_layers(self, block, channel, block_num, stride=1):
+        downsample = None
+        if stride != 1 or self.in_channel != channel * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv2d(self.in_channel, channel * block.expansion, kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm2d(channel * block.expansion)
+            )
+        layers = []
+        layers.append(block(self.in_channel, channel, downsample=downsample, stride=stride,
+                            groups=self.groups, width_per_group=self.width_per_group))
+        self.in_channel = channel * block.expansion
+
+        for _ in range(1, block_num):
+            layers.append(block(self.in_channel, channel, groups=self.groups, width_per_group=self.width_per_group))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        # x = self.layer4(x)
+        x = self.avgpool(x)
+        x = torch.flatten(x, 1)
+
+        # B x 512
+        if self.reid:
+            x = x.div(x.norm(p=2, dim=1, keepdim=True))
+            return x
+        # classifier
+        x = self.fc(x)
+        return x
+
+
+def resnet18(num_classes=1000, reid=False):
+    # https://download.pytorch.org/models/resnet18-5c106cde.pth
+    return ResNet(BasicBlock, [2, 2, 2, 2], num_classes=num_classes, reid=reid)
+
+
+def resnet34(num_classes=1000, reid=False):
+    # https://download.pytorch.org/models/resnet34-333f7ec4.pth
+    return ResNet(BasicBlock, [3, 4, 6, 3], num_classes=num_classes, reid=reid)
+
+
+def resnet50(num_classes=1000, reid=False):
+    # https://download.pytorch.org/models/resnet50-19c8e357.pth
+    return ResNet(Bottleneck, [3, 4, 6, 3], num_classes=num_classes, reid=reid)
+
+
+def resnext50_32x4d(num_classes=1000, reid=False):
+    # https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth
+    groups = 32
+    width_per_group = 4
+    return ResNet(Bottleneck, [3, 4, 6, 3], reid=reid,
+                  num_classes=num_classes, groups=groups, width_per_group=width_per_group)
+
+
+if __name__ == '__main__':
+    net = resnet18(reid=True)
+    x = torch.randn(4, 3, 128, 64)
+    y = net(x)

deep_sort/deep/test.py

@@ -0,0 +1,77 @@
+import torch
+import torch.backends.cudnn as cudnn
+import torchvision
+
+import argparse
+import os
+
+from model import Net
+
+parser = argparse.ArgumentParser(description="Train on market1501")
+parser.add_argument("--data-dir", default='data', type=str)
+parser.add_argument("--no-cuda", action="store_true")
+parser.add_argument("--gpu-id", default=0, type=int)
+args = parser.parse_args()
+
+# device
+device = "cuda:{}".format(args.gpu_id) if torch.cuda.is_available() and not args.no_cuda else "cpu"
+if torch.cuda.is_available() and not args.no_cuda:
+    cudnn.benchmark = True
+
+# data loader
+root = args.data_dir
+query_dir = os.path.join(root, "query")
+gallery_dir = os.path.join(root, "gallery")
+transform = torchvision.transforms.Compose([
+    torchvision.transforms.Resize((128, 64)),
+    torchvision.transforms.ToTensor(),
+    torchvision.transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+])
+queryloader = torch.utils.data.DataLoader(
+    torchvision.datasets.ImageFolder(query_dir, transform=transform),
+    batch_size=64, shuffle=False
+)
+galleryloader = torch.utils.data.DataLoader(
+    torchvision.datas0ets.ImageFolder(gallery_dir, transform=transform),
+    batch_size=64, shuffle=False
+)
+
+# net definition
+net = Net(reid=True)
+assert os.path.isfile("./checkpoint/ckpt.t7"), "Error: no checkpoint file found!"
+print('Loading from checkpoint/ckpt.t7')
+checkpoint = torch.load("./checkpoint/ckpt.t7")
+net_dict = checkpoint['net_dict']
+net.load_state_dict(net_dict, strict=False)
+net.eval()
+net.to(device)
+
+# compute features
+query_features = torch.tensor([]).float()
+query_labels = torch.tensor([]).long()
+gallery_features = torch.tensor([]).float()
+gallery_labels = torch.tensor([]).long()
+
+with torch.no_grad():
+    for idx, (inputs, labels) in enumerate(queryloader):
+        inputs = inputs.to(device)
+        features = net(inputs).cpu()
+        query_features = torch.cat((query_features, features), dim=0)
+        query_labels = torch.cat((query_labels, labels))
+
+    for idx, (inputs, labels) in enumerate(galleryloader):
+        inputs = inputs.to(device)
+        features = net(inputs).cpu()
+        gallery_features = torch.cat((gallery_features, features), dim=0)
+        gallery_labels = torch.cat((gallery_labels, labels))
+
+gallery_labels -= 2
+
+# save features
+features = {
+    "qf": query_features,
+    "ql": query_labels,
+    "gf": gallery_features,
+    "gl": gallery_labels
+}
+torch.save(features, "features.pth")

deep_sort/deep/train.py

@@ -0,0 +1,151 @@
+import argparse
+import os
+import tempfile
+
+import math
+import warnings
+import matplotlib.pyplot as plt
+import torch
+import torchvision
+from torch.optim import lr_scheduler
+
+from multi_train_utils.distributed_utils import init_distributed_mode, cleanup
+from multi_train_utils.train_eval_utils import train_one_epoch, evaluate, load_model
+import torch.distributed as dist
+from datasets import ClsDataset, read_split_data
+
+from model import Net
+from resnet import resnet18
+
+# plot figure
+x_epoch = []
+record = {'train_loss': [], 'train_err': [], 'test_loss': [], 'test_err': []}
+fig = plt.figure()
+ax0 = fig.add_subplot(121, title="loss")
+ax1 = fig.add_subplot(122, title="top1_err")
+
+
+def draw_curve(epoch, train_loss, train_err, test_loss, test_err):
+    global record
+    record['train_loss'].append(train_loss)
+    record['train_err'].append(train_err)
+    record['test_loss'].append(test_loss)
+    record['test_err'].append(test_err)
+
+    x_epoch.append(epoch)
+    ax0.plot(x_epoch, record['train_loss'], 'bo-', label='train')
+    ax0.plot(x_epoch, record['test_loss'], 'ro-', label='val')
+    ax1.plot(x_epoch, record['train_err'], 'bo-', label='train')
+    ax1.plot(x_epoch, record['test_err'], 'ro-', label='val')
+    if epoch == 0:
+        ax0.legend()
+        ax1.legend()
+    fig.savefig("train.jpg")
+
+
+def main(args):
+    batch_size = args.batch_size
+    device = 'cuda:{}'.format(args.gpu_id) if torch.cuda.is_available() else 'cpu'
+
+    train_info, val_info, num_classes = read_split_data(args.data_dir, valid_rate=0.2)
+    train_images_path, train_labels = train_info
+    val_images_path, val_labels = val_info
+
+    transform_train = torchvision.transforms.Compose([
+        torchvision.transforms.RandomCrop((128, 64), padding=4),
+        torchvision.transforms.RandomHorizontalFlip(),
+        torchvision.transforms.ToTensor(),
+        torchvision.transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+    ])
+    transform_val = torchvision.transforms.Compose([
+        torchvision.transforms.Resize((128, 64)),
+        torchvision.transforms.ToTensor(),
+        torchvision.transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+    ])
+
+    train_dataset = ClsDataset(
+        images_path=train_images_path,
+        images_labels=train_labels,
+        transform=transform_train
+    )
+    val_dataset = ClsDataset(
+        images_path=val_images_path,
+        images_labels=val_labels,
+        transform=transform_val
+    )
+
+    number_workers = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])
+    print('Using {} dataloader workers every process'.format(number_workers))
+
+    train_loader = torch.utils.data.DataLoader(
+        train_dataset,
+        batch_size=batch_size,
+        shuffle=True,
+        pin_memory=True,
+        num_workers=number_workers
+    )
+    val_loader = torch.utils.data.DataLoader(
+        val_dataset,
+        batch_size=batch_size,
+        shuffle=False,
+        pin_memory=True,
+        num_workers=number_workers,
+    )
+
+    # net definition
+    start_epoch = 0
+    net = Net(num_classes=num_classes)
+    if args.weights:
+        print('Loading from ', args.weights)
+        checkpoint = torch.load(args.weights, map_location='cpu')
+        net_dict = checkpoint if 'net_dict' not in checkpoint else checkpoint['net_dict']
+        start_epoch = checkpoint['epoch'] if 'epoch' in checkpoint else start_epoch
+        net = load_model(net_dict, net.state_dict(), net)
+
+    if args.freeze_layers:
+        for name, param in net.named_parameters():
+            if 'classifier' not in name:
+                param.requires_grad = False
+
+    net.to(device)
+
+    # loss and optimizer
+    pg = [p for p in net.parameters() if p.requires_grad]
+    optimizer = torch.optim.SGD(pg, args.lr, momentum=0.9, weight_decay=5e-4)
+
+    lr = lambda x: ((1 + math.cos(x * math.pi / args.epochs)) / 2) * (1 - args.lrf) + args.lrf
+    scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lr)
+    for epoch in range(start_epoch, start_epoch + args.epochs):
+        train_positive, train_loss = train_one_epoch(net, optimizer, train_loader, device, epoch)
+        train_acc = train_positive / len(train_dataset)
+        scheduler.step()
+
+        test_positive, test_loss = evaluate(net, val_loader, device)
+        test_acc = test_positive / len(val_dataset)
+
+        print('[epoch {}] accuracy: {}'.format(epoch, test_acc))
+
+        state_dict = {
+            'net_dict': net.state_dict(),
+            'acc': test_acc,
+            'epoch': epoch
+        }
+        torch.save(state_dict, './checkpoint/model_{}.pth'.format(epoch))
+        draw_curve(epoch, train_loss, 1 - train_acc, test_loss, 1 - test_acc)
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description="Train on market1501")
+    parser.add_argument("--data-dir", default='data', type=str)
+    parser.add_argument('--epochs', type=int, default=40)
+    parser.add_argument('--batch_size', type=int, default=32)
+    parser.add_argument("--lr", default=0.001, type=float)
+    parser.add_argument('--lrf', default=0.1, type=float)
+
+    parser.add_argument('--weights', type=str, default='./checkpoint/resnet18.pth')
+    parser.add_argument('--freeze-layers', action='store_true')
+
+    parser.add_argument('--gpu_id', default='0', help='gpu id')
+    args = parser.parse_args()
+
+    main(args)

deep_sort/deep/train_multiGPU.py

@@ -0,0 +1,189 @@
+import argparse
+import os
+import tempfile
+
+import math
+import warnings
+import matplotlib.pyplot as plt
+import torch
+import torchvision
+from torch.optim import lr_scheduler
+
+from multi_train_utils.distributed_utils import init_distributed_mode, cleanup
+from multi_train_utils.train_eval_utils import train_one_epoch, evaluate, load_model
+import torch.distributed as dist
+from datasets import ClsDataset, read_split_data
+
+from resnet import resnet18
+
+
+# plot figure
+x_epoch = []
+record = {'train_loss': [], 'train_err': [], 'test_loss': [], 'test_err': []}
+fig = plt.figure()
+ax0 = fig.add_subplot(121, title="loss")
+ax1 = fig.add_subplot(122, title="top1_err")
+
+
+def draw_curve(epoch, train_loss, train_err, test_loss, test_err):
+    global record
+    record['train_loss'].append(train_loss)
+    record['train_err'].append(train_err)
+    record['test_loss'].append(test_loss)
+    record['test_err'].append(test_err)
+
+    x_epoch.append(epoch)
+    ax0.plot(x_epoch, record['train_loss'], 'bo-', label='train')
+    ax0.plot(x_epoch, record['test_loss'], 'ro-', label='val')
+    ax1.plot(x_epoch, record['train_err'], 'bo-', label='train')
+    ax1.plot(x_epoch, record['test_err'], 'ro-', label='val')
+    if epoch == 0:
+        ax0.legend()
+        ax1.legend()
+    fig.savefig("train.jpg")
+
+
+def main(args):
+    init_distributed_mode(args)
+
+    rank = args.rank
+    device = torch.device(args.device)
+    batch_size = args.batch_size
+    weights_path = args.weights
+    args.lr *= args.world_size
+    checkpoint_path = ''
+
+    if rank == 0:
+        print(args)
+        if os.path.exists('./checkpoint') is False:
+            os.mkdir('./checkpoint')
+
+    train_info, val_info, num_classes = read_split_data(args.data_dir, valid_rate=0.2)
+    train_images_path, train_labels = train_info
+    val_images_path, val_labels = val_info
+
+    transform_train = torchvision.transforms.Compose([
+        torchvision.transforms.RandomCrop((128, 64), padding=4),
+        torchvision.transforms.RandomHorizontalFlip(),
+        torchvision.transforms.ToTensor(),
+        torchvision.transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+    ])
+    transform_val = torchvision.transforms.Compose([
+        torchvision.transforms.Resize((128, 64)),
+        torchvision.transforms.ToTensor(),
+        torchvision.transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
+    ])
+
+    train_dataset = ClsDataset(
+        images_path=train_images_path,
+        images_labels=train_labels,
+        transform=transform_train
+    )
+    val_dataset = ClsDataset(
+        images_path=val_images_path,
+        images_labels=val_labels,
+        transform=transform_val
+    )
+    train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset)
+    val_sampler = torch.utils.data.distributed.DistributedSampler(val_dataset)
+
+    train_batch_sampler = torch.utils.data.BatchSampler(train_sampler, batch_size, drop_last=True)
+
+    number_workers = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])
+
+    if rank == 0:
+        print('Using {} dataloader workers every process'.format(number_workers))
+
+    train_loader = torch.utils.data.DataLoader(
+        train_dataset,
+        batch_sampler=train_batch_sampler,
+        pin_memory=True,
+        num_workers=number_workers
+    )
+    val_loader = torch.utils.data.DataLoader(
+        val_dataset,
+        sampler=val_sampler,
+        batch_size=batch_size,
+        pin_memory=True,
+        num_workers=number_workers,
+    )
+
+    # net definition
+    start_epoch = 0
+    net = resnet18(num_classes=num_classes)
+    if args.weights:
+        print('Loading from ', args.weights)
+        checkpoint = torch.load(args.weights, map_location='cpu')
+        net_dict = checkpoint if 'net_dict' not in checkpoint else checkpoint['net_dict']
+        start_epoch = checkpoint['epoch'] if 'epoch' in checkpoint else start_epoch
+        net = load_model(net_dict, net.state_dict(), net)
+    else:
+        warnings.warn("better providing pretraining weights")
+        checkpoint_path = os.path.join(tempfile.gettempdir(), 'initial_weights.pth')
+        if rank == 0:
+            torch.save(net.state_dict(), checkpoint_path)
+
+        dist.barrier()
+        net.load_state_dict(torch.load(checkpoint_path, map_location='cpu'))
+
+    if args.freeze_layers:
+        for name, param in net.named_parameters():
+            if 'fc' not in name:
+                param.requires_grad = False
+    else:
+        if args.syncBN:
+            net = torch.nn.SyncBatchNorm.convert_sync_batchnorm(net)
+    net.to(device)
+
+    net = torch.nn.parallel.DistributedDataParallel(net, device_ids=[args.gpu])
+
+    # loss and optimizer
+    pg = [p for p in net.parameters() if p.requires_grad]
+    optimizer = torch.optim.SGD(pg, args.lr, momentum=0.9, weight_decay=5e-4)
+
+    lr = lambda x: ((1 + math.cos(x * math.pi / args.epochs)) / 2) * (1 - args.lrf) + args.lrf
+    scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lr)
+    for epoch in range(start_epoch, start_epoch + args.epochs):
+        train_positive, train_loss = train_one_epoch(net, optimizer, train_loader, device, epoch)
+        train_acc = train_positive / len(train_dataset)
+        scheduler.step()
+
+        test_positive, test_loss = evaluate(net, val_loader, device)
+        test_acc = test_positive / len(val_dataset)
+
+        if rank == 0:
+            print('[epoch {}] accuracy: {}'.format(epoch, test_acc))
+
+            state_dict = {
+                'net_dict': net.module.state_dict(),
+                'acc': test_acc,
+                'epoch': epoch
+            }
+            torch.save(state_dict, './checkpoint/model_{}.pth'.format(epoch))
+        draw_curve(epoch, train_loss, 1 - train_acc, test_loss, 1 - test_acc)
+
+    if rank == 0:
+        if os.path.exists(checkpoint_path) is True:
+            os.remove(checkpoint_path)
+    cleanup()
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description="Train on market1501")
+    parser.add_argument("--data-dir", default='data', type=str)
+    parser.add_argument('--epochs', type=int, default=40)
+    parser.add_argument('--batch_size', type=int, default=32)
+    parser.add_argument("--lr", default=0.001, type=float)
+    parser.add_argument('--lrf', default=0.1, type=float)
+    parser.add_argument('--syncBN', type=bool, default=True)
+
+    parser.add_argument('--weights', type=str, default='./checkpoint/resnet18.pth')
+    parser.add_argument('--freeze-layers', action='store_true')
+
+    # not change the following parameters, the system will automatically assignment
+    parser.add_argument('--device', default='cuda', help='device id (i.e. 0 or 0, 1 or cpu)')
+    parser.add_argument('--world_size', default=4, type=int, help='number of distributed processes')
+    parser.add_argument('--dist_url', default='env://', help='url used to set up distributed training')
+    args = parser.parse_args()
+
+    main(args)

deep_sort/deep_sort.py

@@ -0,0 +1,121 @@
+import numpy as np
+import torch
+
+from .deep.feature_extractor import Extractor, FastReIDExtractor
+from .sort.nn_matching import NearestNeighborDistanceMetric
+from .sort.preprocessing import non_max_suppression
+from .sort.detection import Detection
+from .sort.tracker import Tracker
+
+__all__ = ['DeepSort']
+
+
+class DeepSort(object):
+    def __init__(self, model_path, model_config=None, max_dist=0.2, min_confidence=0.3, nms_max_overlap=1.0,
+                 max_iou_distance=0.7, max_age=70, n_init=3, nn_budget=100, use_cuda=True):
+        self.min_confidence = min_confidence
+        self.nms_max_overlap = nms_max_overlap
+
+        if model_config is None:
+            self.extractor = Extractor(model_path, use_cuda=use_cuda)
+        else:
+            self.extractor = FastReIDExtractor(model_config, model_path, use_cuda=use_cuda)
+
+        max_cosine_distance = max_dist
+        metric = NearestNeighborDistanceMetric("cosine", max_cosine_distance, nn_budget)
+        self.tracker = Tracker(metric, max_iou_distance=max_iou_distance, max_age=max_age, n_init=n_init)
+
+    def update(self, bbox_xywh, confidences, classes, ori_img, masks=None):
+        self.height, self.width = ori_img.shape[:2]
+        # generate detections
+        features = self._get_features(bbox_xywh, ori_img)
+        bbox_tlwh = self._xywh_to_tlwh(bbox_xywh)
+        detections = [Detection(bbox_tlwh[i], conf, label, features[i], None if masks is None else masks[i])
+                      for i, (conf, label) in enumerate(zip(confidences, classes))
+                      if conf > self.min_confidence]
+
+        # run on non-maximum supression
+        boxes = np.array([d.tlwh for d in detections])
+        scores = np.array([d.confidence for d in detections])
+        indices = non_max_suppression(boxes, self.nms_max_overlap, scores)
+        detections = [detections[i] for i in indices]
+
+        # update tracker
+        self.tracker.predict()
+        self.tracker.update(detections)
+
+        # output bbox identities
+        outputs = []
+        mask_outputs = []
+        for track in self.tracker.tracks:
+            if not track.is_confirmed() or track.time_since_update > 1:
+                continue
+            box = track.to_tlwh()
+            x1, y1, x2, y2 = self._tlwh_to_xyxy(box)
+            track_id = track.track_id
+            track_cls = track.cls
+            outputs.append(np.array([x1, y1, x2, y2, track_cls, track_id], dtype=np.int32))
+            if track.mask is not None:
+                mask_outputs.append(track.mask)
+        if len(outputs) > 0:
+            outputs = np.stack(outputs, axis=0)
+        return outputs, mask_outputs
+
+    """
+    TODO:
+        Convert bbox from xc_yc_w_h to xtl_ytl_w_h
+    Thanks [email protected] for reporting this bug!
+    """
+
+    @staticmethod
+    def _xywh_to_tlwh(bbox_xywh):
+        if isinstance(bbox_xywh, np.ndarray):
+            bbox_tlwh = bbox_xywh.copy()
+        elif isinstance(bbox_xywh, torch.Tensor):
+            bbox_tlwh = bbox_xywh.clone()
+        bbox_tlwh[:, 0] = bbox_xywh[:, 0] - bbox_xywh[:, 2] / 2.
+        bbox_tlwh[:, 1] = bbox_xywh[:, 1] - bbox_xywh[:, 3] / 2.
+        return bbox_tlwh
+
+    def _xywh_to_xyxy(self, bbox_xywh):
+        x, y, w, h = bbox_xywh
+        x1 = max(int(x - w / 2), 0)
+        x2 = min(int(x + w / 2), self.width - 1)
+        y1 = max(int(y - h / 2), 0)
+        y2 = min(int(y + h / 2), self.height - 1)
+        return x1, y1, x2, y2
+
+    def _tlwh_to_xyxy(self, bbox_tlwh):
+        """
+        TODO:
+            Convert bbox from xtl_ytl_w_h to xc_yc_w_h
+        Thanks [email protected] for reporting this bug!
+        """
+        x, y, w, h = bbox_tlwh
+        x1 = max(int(x), 0)
+        x2 = min(int(x + w), self.width - 1)
+        y1 = max(int(y), 0)
+        y2 = min(int(y + h), self.height - 1)
+        return x1, y1, x2, y2
+
+    @staticmethod
+    def _xyxy_to_tlwh(bbox_xyxy):
+        x1, y1, x2, y2 = bbox_xyxy
+
+        t = x1
+        l = y1
+        w = int(x2 - x1)
+        h = int(y2 - y1)
+        return t, l, w, h
+
+    def _get_features(self, bbox_xywh, ori_img):
+        im_crops = []
+        for box in bbox_xywh:
+            x1, y1, x2, y2 = self._xywh_to_xyxy(box)
+            im = ori_img[y1:y2, x1:x2]
+            im_crops.append(im)
+        if im_crops:
+            features = self.extractor(im_crops)
+        else:
+            features = np.array([])
+        return features

deep_sort/sort/detection.py

@@ -0,0 +1,51 @@
+# vim: expandtab:ts=4:sw=4
+import numpy as np
+
+
+class Detection(object):
+    """
+    This class represents a bounding box detection in a single image.
+
+    Parameters
+    ----------
+    tlwh : array_like
+        Bounding box in format `(x, y, w, h)`.
+    confidence : float
+        Detector confidence score.
+    feature : array_like
+        A feature vector that describes the object contained in this image.
+
+    Attributes
+    ----------
+    tlwh : ndarray
+        Bounding box in format `(top left x, top left y, width, height)`.
+    confidence : ndarray
+        Detector confidence score.
+    feature : ndarray | NoneType
+        A feature vector that describes the object contained in this image.
+
+    """
+
+    def __init__(self, tlwh, confidence, label, feature, mask=None):
+        self.tlwh = np.asarray(tlwh, dtype=np.float32)
+        self.confidence = float(confidence)
+        self.cls = int(label)
+        self.feature = np.asarray(feature, dtype=np.float32)
+        self.mask = mask
+
+    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

deep_sort/sort/iou_matching.py

@@ -0,0 +1,81 @@
+# vim: expandtab:ts=4:sw=4
+from __future__ import absolute_import
+import numpy as np
+from . import linear_assignment
+
+
+def iou(bbox, candidates):
+    """Computer intersection over union.
+
+    Parameters
+    ----------
+    bbox : ndarray
+        A bounding box in format `(top left x, top left y, width, height)`.
+    candidates : ndarray
+        A matrix of candidate bounding boxes (one per row) in the same format
+        as `bbox`.
+
+    Returns
+    -------
+    ndarray
+        The intersection over union in [0, 1] between the `bbox` and each
+        candidate. A higher score means a larger fraction of the `bbox` is
+        occluded by the candidate.
+
+    """
+    bbox_tl, bbox_br = bbox[:2], bbox[:2] + bbox[2:]
+    candidates_tl = candidates[:, :2]
+    candidates_br = candidates[:, :2] + candidates[:, 2:]
+
+    tl = np.c_[np.maximum(bbox_tl[0], candidates_tl[:, 0])[:, np.newaxis],
+               np.maximum(bbox_tl[1], candidates_tl[:, 1])[:, np.newaxis]]
+    br = np.c_[np.minimum(bbox_br[0], candidates_br[:, 0])[:, np.newaxis],
+               np.minimum(bbox_br[1], candidates_br[:, 1])[:, np.newaxis]]
+    wh = np.maximum(0., br - tl)
+
+    area_intersection = wh.prod(axis=1)
+    area_bbox = bbox[2:].prod()
+    area_candidates = candidates[:, 2:].prod(axis=1)
+    return area_intersection / (area_bbox + area_candidates - area_intersection)
+
+
+def iou_cost(tracks, detections, track_indices=None,
+             detection_indices=None):
+    """An intersection over union distance metric.
+
+    Parameters
+    ----------
+    tracks : List[deep_sort.track.Track]
+        A list of tracks.
+    detections : List[deep_sort.detection.Detection]
+        A list of detections.
+    track_indices : Optional[List[int]]
+        A list of indices to tracks that should be matched. Defaults to
+        all `tracks`.
+    detection_indices : Optional[List[int]]
+        A list of indices to detections that should be matched. Defaults
+        to all `detections`.
+
+    Returns
+    -------
+    ndarray
+        Returns a cost matrix of shape
+        len(track_indices), len(detection_indices) where entry (i, j) is
+        `1 - iou(tracks[track_indices[i]], detections[detection_indices[j]])`.
+
+    """
+    if track_indices is None:
+        track_indices = np.arange(len(tracks))
+    if detection_indices is None:
+        detection_indices = np.arange(len(detections))
+
+    cost_matrix = np.zeros((len(track_indices), len(detection_indices)))
+    for row, track_idx in enumerate(track_indices):
+        if tracks[track_idx].time_since_update > 1:
+            cost_matrix[row, :] = linear_assignment.INFTY_COST
+            continue
+
+        bbox = tracks[track_idx].to_tlwh()
+        candidates = np.asarray([detections[i].tlwh for i in detection_indices])
+        cost_matrix[row, :] = 1. - iou(bbox, candidates)
+    return cost_matrix

deep_sort/sort/kalman_filter.py

@@ -0,0 +1,231 @@
+# vim: expandtab:ts=4:sw=4
+import numpy as np
+import scipy.linalg
+
+
+"""
+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}
+
+
+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.
+
+        Parameters
+        ----------
+        measurement : ndarray
+            Bounding box coordinates (x, y, a, h) with center position (x, y),
+            aspect ratio a, and height h.
+
+        Returns
+        -------
+        (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, covariance):
+        """Run Kalman filter prediction step.
+
+        Parameters
+        ----------
+        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
+        -------
+        (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(self._motion_mat, mean)
+        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.
+
+        Parameters
+        ----------
+        mean : ndarray
+            The state's mean vector (8 dimensional array).
+        covariance : ndarray
+            The state's covariance matrix (8x8 dimensional).
+
+        Returns
+        -------
+        (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 update(self, mean, covariance, measurement):
+        """Run Kalman filter correction step.
+
+        Parameters
+        ----------
+        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
+        -------
+        (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))
+        new_covariance = covariance - np.linalg.multi_dot((
+            kalman_gain, self._update_mat, covariance))
+        return new_mean, new_covariance
+
+    def gating_distance(self, mean, covariance, measurements,
+                        only_position=False):
+        """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.
+
+        Parameters
+        ----------
+        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.
+
+        Returns
+        -------
+        ndarray
+            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]
+
+        cholesky_factor = np.linalg.cholesky(covariance)
+        d = measurements - mean
+        z = scipy.linalg.solve_triangular(
+            cholesky_factor, d.T, lower=True, check_finite=False,
+            overwrite_b=True)
+        squared_maha = np.sum(z * z, axis=0)
+        return squared_maha

deep_sort/sort/linear_assignment.py

@@ -0,0 +1,192 @@
+# vim: expandtab:ts=4:sw=4
+from __future__ import absolute_import
+import numpy as np
+# from sklearn.utils.linear_assignment_ import linear_assignment
+from scipy.optimize import linear_sum_assignment as linear_assignment
+from . import kalman_filter
+
+
+INFTY_COST = 1e+5
+
+
+def min_cost_matching(
+        distance_metric, max_distance, tracks, detections, track_indices=None,
+        detection_indices=None):
+    """Solve linear assignment problem.
+
+    Parameters
+    ----------
+    distance_metric : Callable[List[Track], List[Detection], List[int], List[int]) -> ndarray
+        The distance metric is given a list of tracks and detections as well as
+        a list of N track indices and M detection indices. The metric should
+        return the NxM dimensional cost matrix, where element (i, j) is the
+        association cost between the i-th track in the given track indices and
+        the j-th detection in the given detection_indices.
+    max_distance : float
+        Gating threshold. Associations with cost larger than this value are
+        disregarded.
+    tracks : List[track.Track]
+        A list of predicted tracks at the current time step.
+    detections : List[detection.Detection]
+        A list of detections at the current time step.
+    track_indices : List[int]
+        List of track indices that maps rows in `cost_matrix` to tracks in
+        `tracks` (see description above).
+    detection_indices : List[int]
+        List of detection indices that maps columns in `cost_matrix` to
+        detections in `detections` (see description above).
+
+    Returns
+    -------
+    (List[(int, int)], List[int], List[int])
+        Returns a tuple with the following three entries:
+        * A list of matched track and detection indices.
+        * A list of unmatched track indices.
+        * A list of unmatched detection indices.
+
+    """
+    if track_indices is None:
+        track_indices = np.arange(len(tracks))
+    if detection_indices is None:
+        detection_indices = np.arange(len(detections))
+
+    if len(detection_indices) == 0 or len(track_indices) == 0:
+        return [], track_indices, detection_indices  # Nothing to match.
+
+    cost_matrix = distance_metric(
+        tracks, detections, track_indices, detection_indices)
+    cost_matrix[cost_matrix > max_distance] = max_distance + 1e-5
+
+    row_indices, col_indices = linear_assignment(cost_matrix)
+
+    matches, unmatched_tracks, unmatched_detections = [], [], []
+    for col, detection_idx in enumerate(detection_indices):
+        if col not in col_indices:
+            unmatched_detections.append(detection_idx)
+    for row, track_idx in enumerate(track_indices):
+        if row not in row_indices:
+            unmatched_tracks.append(track_idx)
+    for row, col in zip(row_indices, col_indices):
+        track_idx = track_indices[row]
+        detection_idx = detection_indices[col]
+        if cost_matrix[row, col] > max_distance:
+            unmatched_tracks.append(track_idx)
+            unmatched_detections.append(detection_idx)
+        else:
+            matches.append((track_idx, detection_idx))
+    return matches, unmatched_tracks, unmatched_detections
+
+
+def matching_cascade(
+        distance_metric, max_distance, cascade_depth, tracks, detections,
+        track_indices=None, detection_indices=None):
+    """Run matching cascade.
+
+    Parameters
+    ----------
+    distance_metric : Callable[List[Track], List[Detection], List[int], List[int]) -> ndarray
+        The distance metric is given a list of tracks and detections as well as
+        a list of N track indices and M detection indices. The metric should
+        return the NxM dimensional cost matrix, where element (i, j) is the
+        association cost between the i-th track in the given track indices and
+        the j-th detection in the given detection indices.
+    max_distance : float
+        Gating threshold. Associations with cost larger than this value are
+        disregarded.
+    cascade_depth: int
+        The cascade depth, should be se to the maximum track age.
+    tracks : List[track.Track]
+        A list of predicted tracks at the current time step.
+    detections : List[detection.Detection]
+        A list of detections at the current time step.
+    track_indices : Optional[List[int]]
+        List of track indices that maps rows in `cost_matrix` to tracks in
+        `tracks` (see description above). Defaults to all tracks.
+    detection_indices : Optional[List[int]]
+        List of detection indices that maps columns in `cost_matrix` to
+        detections in `detections` (see description above). Defaults to all
+        detections.
+
+    Returns
+    -------
+    (List[(int, int)], List[int], List[int])
+        Returns a tuple with the following three entries:
+        * A list of matched track and detection indices.
+        * A list of unmatched track indices.
+        * A list of unmatched detection indices.
+
+    """
+    if track_indices is None:
+        track_indices = list(range(len(tracks)))
+    if detection_indices is None:
+        detection_indices = list(range(len(detections)))
+
+    unmatched_detections = detection_indices
+    matches = []
+    for level in range(cascade_depth):
+        if len(unmatched_detections) == 0:  # No detections left
+            break
+
+        track_indices_l = [
+            k for k in track_indices
+            if tracks[k].time_since_update == 1 + level
+        ]
+        if len(track_indices_l) == 0:  # Nothing to match at this level
+            continue
+
+        matches_l, _, unmatched_detections = \
+            min_cost_matching(
+                distance_metric, max_distance, tracks, detections,
+                track_indices_l, unmatched_detections)
+        matches += matches_l
+    unmatched_tracks = list(set(track_indices) - set(k for k, _ in matches))
+    return matches, unmatched_tracks, unmatched_detections
+
+
+def gate_cost_matrix(
+        kf, cost_matrix, tracks, detections, track_indices, detection_indices,
+        gated_cost=INFTY_COST, only_position=False):
+    """Invalidate infeasible entries in cost matrix based on the state
+    distributions obtained by Kalman filtering.
+
+    Parameters
+    ----------
+    kf : The Kalman filter.
+    cost_matrix : ndarray
+        The NxM dimensional cost matrix, where N is the number of track indices
+        and M is the number of detection indices, such that entry (i, j) is the
+        association cost between `tracks[track_indices[i]]` and
+        `detections[detection_indices[j]]`.
+    tracks : List[track.Track]
+        A list of predicted tracks at the current time step.
+    detections : List[detection.Detection]
+        A list of detections at the current time step.
+    track_indices : List[int]
+        List of track indices that maps rows in `cost_matrix` to tracks in
+        `tracks` (see description above).
+    detection_indices : List[int]
+        List of detection indices that maps columns in `cost_matrix` to
+        detections in `detections` (see description above).
+    gated_cost : Optional[float]
+        Entries in the cost matrix corresponding to infeasible associations are
+        set this value. Defaults to a very large value.
+    only_position : Optional[bool]
+        If True, only the x, y position of the state distribution is considered
+        during gating. Defaults to False.
+
+    Returns
+    -------
+    ndarray
+        Returns the modified cost matrix.
+
+    """
+    gating_dim = 2 if only_position else 4
+    gating_threshold = kalman_filter.chi2inv95[gating_dim]
+    measurements = np.asarray(
+        [detections[i].to_xyah() for i in detection_indices])
+    for row, track_idx in enumerate(track_indices):
+        track = tracks[track_idx]
+        gating_distance = kf.gating_distance(
+            track.mean, track.covariance, measurements, only_position)
+        cost_matrix[row, gating_distance > gating_threshold] = gated_cost
+    return cost_matrix

deep_sort/sort/nn_matching.py

@@ -0,0 +1,176 @@
+# vim: expandtab:ts=4:sw=4
+import numpy as np
+
+
+def _pdist(a, b):
+    """Compute pair-wise squared distance between points in `a` and `b`.
+
+    Parameters
+    ----------
+    a : array_like
+        An NxM matrix of N samples of dimensionality M.
+    b : array_like
+        An LxM matrix of L samples of dimensionality M.
+
+    Returns
+    -------
+    ndarray
+        Returns a matrix of size len(a), len(b) such that eleement (i, j)
+        contains the squared distance between `a[i]` and `b[j]`.
+
+    """
+    a, b = np.asarray(a), np.asarray(b)
+    if len(a) == 0 or len(b) == 0:
+        return np.zeros((len(a), len(b)))
+    a2, b2 = np.square(a).sum(axis=1), np.square(b).sum(axis=1)
+    r2 = -2. * np.dot(a, b.T) + a2[:, None] + b2[None, :]
+    r2 = np.clip(r2, 0., float(np.inf))
+    return r2
+
+
+def _cosine_distance(a, b, data_is_normalized=False):
+    """Compute pair-wise cosine distance between points in `a` and `b`.
+
+    Parameters
+    ----------
+    a : array_like
+        An NxM matrix of N samples of dimensionality M.
+    b : array_like
+        An LxM matrix of L samples of dimensionality M.
+    data_is_normalized : Optional[bool]
+        If True, assumes rows in a and b are unit length vectors.
+        Otherwise, a and b are explicitly normalized to lenght 1.
+
+    Returns
+    -------
+    ndarray
+        Returns a matrix of size len(a), len(b) such that eleement (i, j)
+        contains the squared distance between `a[i]` and `b[j]`.
+
+    """
+    if not data_is_normalized:
+        a = np.asarray(a) / np.linalg.norm(a, axis=1, keepdims=True)
+        b = np.asarray(b) / np.linalg.norm(b, axis=1, keepdims=True)
+    return 1. - np.dot(a, b.T)
+
+
+def _nn_euclidean_distance(x, y):
+    """ Helper function for nearest neighbor distance metric (Euclidean).
+
+    Parameters
+    ----------
+    x : ndarray
+        A matrix of N row-vectors (sample points).
+    y : ndarray
+        A matrix of M row-vectors (query points).
+
+    Returns
+    -------
+    ndarray
+        A vector of length M that contains for each entry in `y` the
+        smallest Euclidean distance to a sample in `x`.
+
+    """
+    distances = _pdist(x, y)
+    return np.maximum(0.0, distances.min(axis=0))
+
+
+def _nn_cosine_distance(x, y):
+    """ Helper function for nearest neighbor distance metric (cosine).
+
+    Parameters
+    ----------
+    x : ndarray
+        A matrix of N row-vectors (sample points).
+    y : ndarray
+        A matrix of M row-vectors (query points).
+
+    Returns
+    -------
+    ndarray
+        A vector of length M that contains for each entry in `y` the
+        smallest cosine distance to a sample in `x`.
+
+    """
+    distances = _cosine_distance(x, y)
+    return distances.min(axis=0)
+
+
+class NearestNeighborDistanceMetric(object):
+    """
+    A nearest neighbor distance metric that, for each target, returns
+    the closest distance to any sample that has been observed so far.
+
+    Parameters
+    ----------
+    metric : str
+        Either "euclidean" or "cosine".
+    matching_threshold: float
+        The matching threshold. Samples with larger distance are considered an
+        invalid match.
+    budget : Optional[int]
+        If not None, fix samples per class to at most this number. Removes
+        the oldest samples when the budget is reached.
+
+    Attributes
+    ----------
+    samples : Dict[int -> List[ndarray]]
+        A dictionary that maps from target identities to the list of samples
+        that have been observed so far.
+
+    """
+
+    def __init__(self, metric, matching_threshold, budget=None):
+
+        if metric == "euclidean":
+            self._metric = _nn_euclidean_distance
+        elif metric == "cosine":
+            self._metric = _nn_cosine_distance
+        else:
+            raise ValueError(
+                "Invalid metric; must be either 'euclidean' or 'cosine'")
+        self.matching_threshold = matching_threshold
+        self.budget = budget
+        self.samples = {}
+
+    def partial_fit(self, features, targets, active_targets):
+        """Update the distance metric with new data.
+
+        Parameters
+        ----------
+        features : ndarray
+            An NxM matrix of N features of dimensionality M.
+        targets : ndarray
+            An integer array of associated target identities.
+        active_targets : List[int]
+            A list of targets that are currently present in the scene.
+
+        """
+        for feature, target in zip(features, targets):
+            self.samples.setdefault(target, []).append(feature)
+            if self.budget is not None:
+                self.samples[target] = self.samples[target][-self.budget:]
+        self.samples = {k: self.samples[k] for k in active_targets}
+
+    def distance(self, features, targets):
+        """Compute distance between features and targets.
+
+        Parameters
+        ----------
+        features : ndarray
+            An NxM matrix of N features of dimensionality M.
+        targets : List[int]
+            A list of targets to match the given `features` against.
+
+        Returns
+        -------
+        ndarray
+            Returns a cost matrix of shape len(targets), len(features), where
+            element (i, j) contains the closest squared distance between
+            `targets[i]` and `features[j]`.
+
+        """
+        cost_matrix = np.zeros((len(targets), len(features)))
+        for i, target in enumerate(targets):
+            cost_matrix[i, :] = self._metric(self.samples[target], features)
+        return cost_matrix

deep_sort/sort/preprocessing.py

@@ -0,0 +1,73 @@
+# vim: expandtab:ts=4:sw=4
+import numpy as np
+import cv2
+
+
+def non_max_suppression(boxes, max_bbox_overlap, scores=None):
+    """Suppress overlapping detections.
+
+    Original code from [1]_ has been adapted to include confidence score.
+
+    .. [1] http://www.pyimagesearch.com/2015/02/16/
+           faster-non-maximum-suppression-python/
+
+    Examples
+    --------
+
+        >>> boxes = [d.roi for d in detections]
+        >>> scores = [d.confidence for d in detections]
+        >>> indices = non_max_suppression(boxes, max_bbox_overlap, scores)
+        >>> detections = [detections[i] for i in indices]
+
+    Parameters
+    ----------
+    boxes : ndarray
+        Array of ROIs (x, y, width, height).
+    max_bbox_overlap : float
+        ROIs that overlap more than this values are suppressed.
+    scores : Optional[array_like]
+        Detector confidence score.
+
+    Returns
+    -------
+    List[int]
+        Returns indices of detections that have survived non-maxima suppression.
+
+    """
+    if len(boxes) == 0:
+        return []
+
+    boxes = boxes.astype(np.float32)
+    pick = []
+
+    x1 = boxes[:, 0]
+    y1 = boxes[:, 1]
+    x2 = boxes[:, 2] + boxes[:, 0]
+    y2 = boxes[:, 3] + boxes[:, 1]
+
+    area = (x2 - x1 + 1) * (y2 - y1 + 1)
+    if scores is not None:
+        idxs = np.argsort(scores)
+    else:
+        idxs = np.argsort(y2)
+
+    while len(idxs) > 0:
+        last = len(idxs) - 1
+        i = idxs[last]
+        pick.append(i)
+
+        xx1 = np.maximum(x1[i], x1[idxs[:last]])
+        yy1 = np.maximum(y1[i], y1[idxs[:last]])
+        xx2 = np.minimum(x2[i], x2[idxs[:last]])
+        yy2 = np.minimum(y2[i], y2[idxs[:last]])
+
+        w = np.maximum(0, xx2 - xx1 + 1)
+        h = np.maximum(0, yy2 - yy1 + 1)
+
+        overlap = (w * h) / (area[idxs[:last]] + area[idxs[last]] - w * h)
+
+        idxs = np.delete(
+            idxs, np.concatenate(
+                ([last], np.where(overlap > max_bbox_overlap)[0])))
+
+    return pick

deep_sort/sort/track.py

@@ -0,0 +1,169 @@
+# vim: expandtab:ts=4:sw=4
+
+
+class TrackState:
+    """
+    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
+
+
+class Track:
+    """
+    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.
+
+    Parameters
+    ----------
+    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`.
+    feature : Optional[ndarray]
+        Feature vector of the detection this track originates from. If not None,
+        this feature is added to the `features` cache.
+
+    Attributes
+    ----------
+    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.
+    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,
+                 feature=None, cls=None, mask=None):
+        self.mean = mean
+        self.covariance = covariance
+        self.track_id = track_id
+        self.hits = 1
+        self.age = 1
+        self.time_since_update = 0
+
+        self.state = TrackState.Tentative
+        self.cls = cls
+        self.mask = mask
+        self.features = []
+        if feature is not None:
+            self.features.append(feature)
+
+        self._n_init = n_init
+        self._max_age = max_age
+
+    def to_tlwh(self):
+        """Get current position in bounding box format `(top left x, top left y,
+        width, height)`.
+
+        Returns
+        -------
+        ndarray
+            The bounding box.
+
+        """
+        ret = self.mean[:4].copy()
+        ret[2] *= ret[3]
+        ret[:2] -= ret[2:] / 2
+        return ret
+
+    def to_tlbr(self):
+        """Get current position in bounding box format `(min x, miny, max x,
+        max y)`.
+
+        Returns
+        -------
+        ndarray
+            The bounding box.
+
+        """
+        ret = self.to_tlwh()
+        ret[2:] = ret[:2] + ret[2:]
+        return ret
+
+    def predict(self, kf):
+        """Propagate the state distribution to the current time step using a
+        Kalman filter prediction step.
+
+        Parameters
+        ----------
+        kf : kalman_filter.KalmanFilter
+            The Kalman filter.
+
+        """
+        self.mean, self.covariance = kf.predict(self.mean, self.covariance)
+        self.age += 1
+        self.time_since_update += 1
+
+    def update(self, kf, detection):
+        """Perform Kalman filter measurement update step and update the feature
+        cache.
+
+        Parameters
+        ----------
+        kf : kalman_filter.KalmanFilter
+            The Kalman filter.
+        detection : Detection
+            The associated detection.
+
+        """
+        self.mask = detection.mask
+        self.mean, self.covariance = kf.update(
+            self.mean, self.covariance, detection.to_xyah())
+        self.features.append(detection.feature)
+
+        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

deep_sort/sort/tracker.py

@@ -0,0 +1,138 @@
+# vim: expandtab:ts=4:sw=4
+from __future__ import absolute_import
+import numpy as np
+from . import kalman_filter
+from . import linear_assignment
+from . import iou_matching
+from .track import Track
+
+
+class Tracker:
+    """
+    This is the multi-target tracker.
+
+    Parameters
+    ----------
+    metric : nn_matching.NearestNeighborDistanceMetric
+        A distance metric for measurement-to-track association.
+    max_age : int
+        Maximum number of missed misses before a track is deleted.
+    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.
+
+    Attributes
+    ----------
+    metric : nn_matching.NearestNeighborDistanceMetric
+        The distance metric used for measurement to track association.
+    max_age : int
+        Maximum number of missed misses before a track is deleted.
+    n_init : int
+        Number of frames that a track remains in initialization phase.
+    kf : kalman_filter.KalmanFilter
+        A Kalman filter to filter target trajectories in image space.
+    tracks : List[Track]
+        The list of active tracks at the current time step.
+
+    """
+
+    def __init__(self, metric, max_iou_distance=0.7, max_age=70, n_init=3):
+        self.metric = metric
+        self.max_iou_distance = max_iou_distance
+        self.max_age = max_age
+        self.n_init = n_init
+
+        self.kf = kalman_filter.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.kf)
+
+    def update(self, detections):
+        """Perform measurement update and track management.
+
+        Parameters
+        ----------
+        detections : List[deep_sort.detection.Detection]
+            A list of detections at the current time step.
+
+        """
+        # 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.kf, 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)
+
+    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 = linear_assignment.gate_cost_matrix(
+                self.kf, 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 = \
+            linear_assignment.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 = \
+            linear_assignment.min_cost_matching(
+                iou_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.kf.initiate(detection.to_xyah())
+        self.tracks.append(Track(
+            mean, covariance, self._next_id, self.n_init, self.max_age,
+            detection.feature, detection.cls, detection.mask))
+        self._next_id += 1

deepsort.py

@@ -0,0 +1,189 @@
+import os
+import cv2
+import time
+import argparse
+import torch
+import warnings
+import json
+import sys
+
+sys.path.append(os.path.join(os.path.dirname(__file__), 'thirdparty/fast-reid'))
+
+from detector import build_detector
+from deep_sort import build_tracker
+from utils.draw import draw_boxes
+from utils.parser import get_config
+from utils.log import get_logger
+from utils.io import write_results
+
+
+class VideoTracker(object):
+    def __init__(self, cfg, args, video_path):
+        self.cfg = cfg
+        self.args = args
+        self.video_path = video_path
+        self.logger = get_logger("root")
+
+        use_cuda = args.use_cuda and torch.cuda.is_available()
+        if not use_cuda:
+            warnings.warn("Running in cpu mode which maybe very slow!", UserWarning)
+
+        if args.display:
+            cv2.namedWindow("test", cv2.WINDOW_NORMAL)
+            cv2.resizeWindow("test", args.display_width, args.display_height)
+
+        if args.cam != -1:
+            print("Using webcam " + str(args.cam))
+            self.vdo = cv2.VideoCapture(args.cam)
+        else:
+            self.vdo = cv2.VideoCapture()
+        self.detector = build_detector(cfg, use_cuda=use_cuda, segment=self.args.segment)
+        self.deepsort = build_tracker(cfg, use_cuda=use_cuda)
+        self.class_names = self.detector.class_names
+
+    def __enter__(self):
+        if self.args.cam != -1:
+            ret, frame = self.vdo.read()
+            assert ret, "Error: Camera error"
+            self.im_width = frame.shape[0]
+            self.im_height = frame.shape[1]
+
+        else:
+            assert os.path.isfile(self.video_path), "Path error"
+            self.vdo.open(self.video_path)
+            self.im_width = int(self.vdo.get(cv2.CAP_PROP_FRAME_WIDTH))
+            self.im_height = int(self.vdo.get(cv2.CAP_PROP_FRAME_HEIGHT))
+            assert self.vdo.isOpened()
+
+        if self.args.save_path:
+            os.makedirs(self.args.save_path, exist_ok=True)
+            # TODO save masks
+
+            # path of saved video and results
+            self.save_video_path = os.path.join(self.args.save_path, "results.avi")
+            self.save_results_path = os.path.join(self.args.save_path, "results.txt")
+
+            # create video writer
+            fourcc = cv2.VideoWriter_fourcc(*'MJPG')
+            self.writer = cv2.VideoWriter(self.save_video_path, fourcc, 20, (self.im_width, self.im_height))
+
+            # logging
+            self.logger.info("Save results to {}".format(self.args.save_path))
+
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_traceback):
+        if exc_type:
+            print(exc_type, exc_value, exc_traceback)
+
+    def run(self):
+        results = []
+        idx_frame = 0
+        with open('coco_classes.json', 'r') as f:
+            idx_to_class = json.load(f)
+        while self.vdo.grab():
+            idx_frame += 1
+            if idx_frame % self.args.frame_interval:
+                continue
+
+            start = time.time()
+            _, ori_im = self.vdo.retrieve()
+            im = cv2.cvtColor(ori_im, cv2.COLOR_BGR2RGB)
+
+            # do detection
+            if self.args.segment:
+                bbox_xywh, cls_conf, cls_ids, seg_masks = self.detector(im)
+            else:
+                bbox_xywh, cls_conf, cls_ids = self.detector(im)
+
+            # select person class
+            mask = cls_ids == 0
+
+            bbox_xywh = bbox_xywh[mask]
+            # bbox dilation just in case bbox too small, delete this line if using a better pedestrian detector
+            bbox_xywh[:, 2:] *= 1.2
+            cls_conf = cls_conf[mask]
+            cls_ids = cls_ids[mask]
+
+            # do tracking
+            if self.args.segment:
+                seg_masks = seg_masks[mask]
+                outputs, mask_outputs = self.deepsort.update(bbox_xywh, cls_conf, cls_ids, im, seg_masks)
+            else:
+                outputs, _ = self.deepsort.update(bbox_xywh, cls_conf, cls_ids, im)
+
+            # draw boxes for visualization
+            if len(outputs) > 0:
+                bbox_tlwh = []
+                bbox_xyxy = outputs[:, :4]
+                identities = outputs[:, -1]
+                cls = outputs[:, -2]
+                names = [idx_to_class[str(label)] for label in cls]
+
+                ori_im = draw_boxes(ori_im, bbox_xyxy, names, identities, None if not self.args.segment else mask_outputs)
+
+                for bb_xyxy in bbox_xyxy:
+                    bbox_tlwh.append(self.deepsort._xyxy_to_tlwh(bb_xyxy))
+
+                results.append((idx_frame - 1, bbox_tlwh, identities, cls))
+
+            end = time.time()
+
+            if self.args.display:
+                cv2.imshow("test", ori_im)
+                cv2.waitKey(1)
+
+            if self.args.save_path:
+                self.writer.write(ori_im)
+
+            # save results
+            write_results(self.save_results_path, results, 'mot')
+
+            # logging
+            self.logger.info("time: {:.03f}s, fps: {:.03f}, detection numbers: {}, tracking numbers: {}" \
+                             .format(end - start, 1 / (end - start), bbox_xywh.shape[0], len(outputs)))
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--VIDEO_PATH", type=str, default='demo.avi')
+    parser.add_argument("--config_mmdetection", type=str, default="./configs/mmdet.yaml")
+    parser.add_argument("--config_detection", type=str, default="./configs/mask_rcnn.yaml")
+    parser.add_argument("--config_deepsort", type=str, default="./configs/deep_sort.yaml")
+    parser.add_argument("--config_fastreid", type=str, default="./configs/fastreid.yaml")
+    parser.add_argument("--fastreid", action="store_true")
+    parser.add_argument("--mmdet", action="store_true")
+    parser.add_argument("--segment", action="store_true")
+    # parser.add_argument("--ignore_display", dest="display", action="store_false", default=True)
+    parser.add_argument("--display", action="store_true")
+    parser.add_argument("--frame_interval", type=int, default=1)
+    parser.add_argument("--display_width", type=int, default=800)
+    parser.add_argument("--display_height", type=int, default=600)
+    parser.add_argument("--save_path", type=str, default="./output/")
+    parser.add_argument("--cpu", dest="use_cuda", action="store_false", default=True)
+    parser.add_argument("--camera", action="store", dest="cam", type=int, default="-1")
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    cfg = get_config()
+    if args.segment:
+        cfg.USE_SEGMENT = True
+    else:
+        cfg.USE_SEGMENT = False
+    if args.mmdet:
+        cfg.merge_from_file(args.config_mmdetection)
+        cfg.USE_MMDET = True
+    else:
+        cfg.merge_from_file(args.config_detection)
+        cfg.USE_MMDET = False
+    cfg.merge_from_file(args.config_deepsort)
+    if args.fastreid:
+        cfg.merge_from_file(args.config_fastreid)
+        cfg.USE_FASTREID = True
+    else:
+        cfg.USE_FASTREID = False
+
+    with VideoTracker(cfg, args, video_path=args.VIDEO_PATH) as vdo_trk:
+        vdo_trk.run()

deepsort_new.py

@@ -0,0 +1,229 @@
+# Modified deepsort.py — Target ID recovery with IOU threshold and smooth tracking
+import os
+import cv2
+import time
+import argparse
+import torch
+import warnings
+import json
+import sys
+import numpy as np
+
+sys.path.append(os.path.join(os.path.dirname(__file__), 'thirdparty/fast-reid'))
+
+from detector import build_detector
+from deep_sort import build_tracker
+from utils.draw import draw_boxes
+from utils.parser import get_config
+from utils.log import get_logger
+from utils.io import write_results
+
+
+def compute_iou(box1, box2):
+    if box1 is None or box2 is None:
+        return 0.0
+    xi1, yi1 = max(box1[0], box2[0]), max(box1[1], box2[1])
+    xi2, yi2 = min(box1[2], box2[2]), min(box1[3], box2[3])
+    inter_area = max(0, xi2 - xi1) * max(0, yi2 - yi1)
+    box1_area = (box1[2] - box1[0]) * (box1[3] - box1[1])
+    box2_area = (box2[2] - box2[0]) * (box2[3] - box2[1])
+    union = box1_area + box2_area - inter_area
+    return inter_area / union if union > 0 else 0.0
+
+def get_best_iou_track(outputs, target_bbox, return_iou=False):
+    if target_bbox is None:
+        return (None, 0.0) if return_iou else None
+    best_iou = 0
+    best_id = None
+    for det in outputs:
+        x1, y1, x2, y2 = det[:4]
+        track_id = int(det[-1])
+        iou = compute_iou([x1, y1, x2, y2], target_bbox)
+        if iou > best_iou:
+            best_iou = iou
+            best_id = track_id
+    if return_iou:
+        return best_id, best_iou
+    return best_id
+
+class VideoTracker:
+    def __init__(self, cfg, args, video_path):
+        self.cfg = cfg
+        self.args = args
+        self.video_path = video_path
+        self.logger = get_logger("root")
+        self.first_frame_flag = True
+        self.target_id = None
+        self.last_known_bbox = None
+
+        use_cuda = args.use_cuda and torch.cuda.is_available()
+        if not use_cuda:
+            warnings.warn("Running in cpu mode which maybe very slow!", UserWarning)
+
+        if args.display:
+            cv2.namedWindow("test", cv2.WINDOW_NORMAL)
+            cv2.resizeWindow("test", args.display_width, args.display_height)
+
+        if args.cam != -1:
+            self.vdo = cv2.VideoCapture(args.cam)
+        else:
+            self.vdo = cv2.VideoCapture(video_path)
+
+        self.detector = build_detector(cfg, use_cuda=use_cuda, segment=args.segment)
+        self.deepsort = build_tracker(cfg, use_cuda=use_cuda)
+
+    def run(self):
+        results = []
+        idx_frame = 0
+        with open('coco_classes.json', 'r') as f:
+            idx_to_class = json.load(f)
+
+        if not self.vdo.isOpened():
+            raise IOError("Failed to open video")
+
+        im_width = int(self.vdo.get(cv2.CAP_PROP_FRAME_WIDTH))
+        im_height = int(self.vdo.get(cv2.CAP_PROP_FRAME_HEIGHT))
+
+        if self.args.save_path:
+            os.makedirs(self.args.save_path, exist_ok=True)
+            self.writer = cv2.VideoWriter(
+                os.path.join(self.args.save_path, "results.avi"),
+                cv2.VideoWriter_fourcc(*'MJPG'),
+                20, (im_width, im_height))
+
+        while self.vdo.grab():
+            idx_frame += 1
+            if idx_frame % self.args.frame_interval:
+                continue
+
+            _, ori_im = self.vdo.retrieve()
+            im = cv2.cvtColor(ori_im, cv2.COLOR_BGR2RGB)
+
+            if self.args.segment:
+                bbox_xywh, cls_conf, cls_ids, seg_masks = self.detector(im)
+            else:
+                bbox_xywh, cls_conf, cls_ids = self.detector(im)
+
+            mask = cls_ids == 0  # person class
+            bbox_xywh = bbox_xywh[mask]
+            cls_conf = cls_conf[mask]
+            cls_ids = cls_ids[mask]
+            if bbox_xywh.shape[0] == 0:
+                continue
+
+            bbox_xywh[:, 2:] *= 1.2
+
+            if self.args.segment:
+                seg_masks = seg_masks[mask]
+                outputs, mask_outputs = self.deepsort.update(bbox_xywh, cls_conf, cls_ids, im, seg_masks)
+            else:
+                outputs, _ = self.deepsort.update(bbox_xywh, cls_conf, cls_ids, im)
+
+            if self.first_frame_flag and len(outputs) > 0:
+                cv2.imshow("Select target", ori_im)
+                cv2.waitKey(1)
+                target_roi = cv2.selectROI("Select target", ori_im, False, False)
+                cv2.destroyWindow("Select target")
+                target_bbox = [target_roi[0], target_roi[1], target_roi[0] + target_roi[2], target_roi[1] + target_roi[3]]
+                self.target_id = get_best_iou_track(outputs, target_bbox)
+                self.last_known_bbox = target_bbox
+                print(f"[INFO] Selected target ID: {self.target_id}")
+                self.first_frame_flag = False
+                continue
+
+            bbox_tlwh = []
+            filtered_outputs = []
+            for det in outputs:
+                if int(det[-1]) == self.target_id:
+                    filtered_outputs.append(det)
+                    self.last_known_bbox = det[:4]
+
+            if len(filtered_outputs) == 0 and self.last_known_bbox is not None:
+                new_id, best_iou = get_best_iou_track(outputs, self.last_known_bbox, return_iou=True)
+                if best_iou > 0.4:
+                    self.target_id = new_id
+                    print(f"[INFO] Target temporarily lost. Reassigned to ID {self.target_id} (IOU={best_iou:.2f})")
+                    for det in outputs:
+                        if int(det[-1]) == self.target_id:
+                            filtered_outputs.append(det)
+                            self.last_known_bbox = det[:4]
+                else:
+                    print("[INFO] IOU too low to reassign. Skipping reassignment.")
+
+            if len(filtered_outputs) > 0:
+                def box_center(box):
+                    return np.array([(box[0] + box[2]) / 2, (box[1] + box[3]) / 2])
+
+                smoothed_outputs = []
+                for det in filtered_outputs:
+                    if self.last_known_bbox is None:
+                        smoothed_outputs.append(det)
+                        continue
+                    dist = np.linalg.norm(box_center(det[:4]) - box_center(self.last_known_bbox))
+                    if dist < 300:
+                        smoothed_outputs.append(det)
+                    else:
+                        print(f"[INFO] Skipped jumpy box with dist={dist:.2f}")
+
+                if len(smoothed_outputs) > 0:
+                    bbox_xyxy = np.array([det[:4] for det in smoothed_outputs])
+                    identities = [int(det[-1]) for det in smoothed_outputs]
+                    cls = [int(det[-2]) for det in smoothed_outputs]
+                    names = [idx_to_class[str(label)] for label in cls]
+
+                    ori_im = draw_boxes(ori_im, bbox_xyxy, names, identities)
+
+                    for box in bbox_xyxy:
+                        bbox_tlwh.append(self.deepsort._xyxy_to_tlwh(box))
+
+                    results.append((idx_frame - 1, bbox_tlwh, identities, cls))
+
+            if self.args.display:
+                cv2.imshow("test", ori_im)
+                if cv2.waitKey(1) & 0xFF == ord('q'):
+                    break
+
+            if self.args.save_path:
+                self.writer.write(ori_im)
+
+        if self.args.save_path:
+            write_results(os.path.join(self.args.save_path, "results.txt"), results, 'mot')
+
+        self.vdo.release()
+        if self.args.display:
+            cv2.destroyAllWindows()
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--VIDEO_PATH", type=str, default="demo.avi")
+    parser.add_argument("--config_mmdetection", type=str, default="./configs/mmdet.yaml")
+    parser.add_argument("--config_detection", type=str, default="./configs/mask_rcnn.yaml")
+    parser.add_argument("--config_deepsort", type=str, default="./configs/deep_sort.yaml")
+    parser.add_argument("--config_fastreid", type=str, default="./configs/fastreid.yaml")
+    parser.add_argument("--fastreid", action="store_true")
+    parser.add_argument("--mmdet", action="store_true")
+    parser.add_argument("--segment", action="store_true")
+    parser.add_argument("--display", action="store_true")
+    parser.add_argument("--frame_interval", type=int, default=1)
+    parser.add_argument("--display_width", type=int, default=800)
+    parser.add_argument("--display_height", type=int, default=600)
+    parser.add_argument("--save_path", type=str, default="./output/")
+    parser.add_argument("--cpu", dest="use_cuda", action="store_false", default=True)
+    parser.add_argument("--camera", action="store", dest="cam", type=int, default="-1")
+    return parser.parse_args()
+
+if __name__ == "__main__":
+    args = parse_args()
+    cfg = get_config()
+
+    cfg.USE_SEGMENT = args.segment
+    cfg.USE_MMDET = args.mmdet
+    cfg.USE_FASTREID = args.fastreid
+
+    cfg.merge_from_file(args.config_mmdetection if args.mmdet else args.config_detection)
+    cfg.merge_from_file(args.config_deepsort)
+    if args.fastreid:
+        cfg.merge_from_file(args.config_fastreid)
+
+    tracker = VideoTracker(cfg, args, video_path=args.VIDEO_PATH)
+    tracker.run()

detector/MMDet/__init__.py

@@ -0,0 +1,2 @@
+from .detector import MMDet
+__all__ = ['MMDet']

detector/MMDet/detector.py

@@ -0,0 +1,52 @@
+import logging
+import numpy as np
+import torch
+
+from mmdet.apis import init_detector, inference_detector
+from .mmdet_utils import xyxy_to_xywh
+
+
+class MMDet(object):
+    def __init__(self, cfg_file, checkpoint_file, score_thresh=0.7,
+                 is_xywh=False, use_cuda=True):
+        # net definition
+        self.device = "cuda" if use_cuda else "cpu"
+        self.net = init_detector(cfg_file, checkpoint_file, device=self.device)
+        logger = logging.getLogger("root.detector")
+        logger.info('Loading weights from %s... Done!' % (checkpoint_file))
+
+        #constants
+        self.score_thresh = score_thresh
+        self.use_cuda = use_cuda
+        self.is_xywh = is_xywh
+        self.class_names = self.net.CLASSES
+        self.num_classes = len(self.class_names)
+
+    def __call__(self, ori_img):
+        # forward
+        bbox_result = inference_detector(self.net, ori_img)
+        bboxes = np.vstack(bbox_result)
+
+        if len(bboxes) == 0:
+            bbox = np.array([]).reshape([0, 4])
+            cls_conf = np.array([])
+            cls_ids = np.array([])
+            return bbox, cls_conf, cls_ids
+
+        bbox = bboxes[:, :4]
+        cls_conf = bboxes[:, 4]
+        cls_ids = [
+            np.full(bbox.shape[0], i, dtype=np.int32)
+            for i, bbox in enumerate(bbox_result)
+        ]
+        cls_ids = np.concatenate(cls_ids)
+
+        selected_idx = cls_conf > self.score_thresh
+        bbox = bbox[selected_idx, :]
+        cls_conf = cls_conf[selected_idx]
+        cls_ids = cls_ids[selected_idx]
+
+        if self.is_xywh:
+            bbox = xyxy_to_xywh(bbox)
+
+        return bbox, cls_conf, cls_ids