deep_sort VS yolor

Similari is a Rust/Python framework aimed at building sophisticated tracking systems. With Similari, you can develop highly efficient parallelized SORT, DeepSORT, and other sophisticated multiple-object tracking engines.

I'm doing a Python personal project where I'm trying to use YOLOv8 and DeepSORT to detect vehicles from a car's dash cam footage. I succeeded in using YOLOv8 to output the correct bounding boxes by processing each camera frame. However, I tried to add on DeepSORT code, but it made the detection accuracy significantly worse. I'm pretty sure I need to train my own "feature extractor" for DeepSORT to create a new .pb file. I got this information from the deep_sort GitHub link: https://github.com/nwojke/deep_sort. I tried to find resources to do this but they are pretty scarce. Has anyone had experience with this problem?

The feature model well that looks like it is at that domain you mentioned but why not instead of using this repo use the original authors repo

nwojke/deep_sort

I was implementing the Kalman filter for bounding boxes during the last two days. As an inspiration source, I looked at the Python3 Kalman filter implementation that is used in the DeepSORT algorithm and uses NumPy and SciKit under the hood, so it's pretty efficient because all the operations are run inside FFI.

There's tons of work out there when it comes to object tracking such as DeepSort. We've worked to build simpler, more efficient solutions in-house though. Then past that, it's a matter of treating everything in the video as an object (including the whole frame), tracking it, and saving it in a no-SQL DB such that it's easy to query in this way.

Right now, the way we're thinking about it is to turn videos into something that works with the structure of a database like MongoDB. Everything in an image or a video is an object (even the frame itself is an object with a large bounding box), and each of these objects has some attributes and can be tracked over time with some form of object tracking. Given that the objects are tracked, they can each basically be returned as a time-series of each of the attributes associated with that object.

Deep Sort

I was wondering if I could use the same annotated data(in YOLO format) for the training of the tracker as well. I took a look at the original repo for DeepSORT, and it does mention the training using cosine metric learning, but I could not seem to understand how to replicate that for my own dataset(they show us how to do it for the MARS and Market1501 datasets).

DeepSORT is one of the best trackers https://github.com/nwojke/deep_sortIt requires an object detector tho, like YOLO https://pjreddie.com/darknet/yolo/

Fellow redditors, can you please explain to me how aforementioned structures work and applied in code? I tried to read carefully the papers on YOLOv7 and YOLOR (https://arxiv.org/pdf/2207.02696.pdf, https://arxiv.org/pdf/2105.04206.pdf) but for me it feels like explanations in text have literally no relation to implementation code (I am totally not into Torch so it makes understanding even harder) (https://github.com/WongKinYiu/yolor/blob/main/utils/layers.py)

WongKinYiu/yolor

Is there a reason to use YOLOv4 over YOLOv5 or YOLOR?

I am interested in using Docker for Deep learning models use. On Github people recommend Docker environment to use the model. I am sharing the link to the Github repo. My question is how I can use this GitHub repo and create a docker container

So there is a paper on YOLOR by Wong Kin Yiu https://github.com/WongKinYiu/yolor

[CVPR'21 WAD] Challenge - Waymo Open Dataset: https://waymo.com/open/challenges/2021/real-time-2d-prediction/ YOLOR (Scaled-YOLOv4-based) has the best speed/accuracy ratio on Waymo autonomous driving challenge ((Waymo Open Dataset): Real-time 2D Detection. Thanks Chien-Yao Wang from Academia Sinica and DiDi MapVision team to push Scaled-YOLOv4 further! * DIDI MapVision: https://arxiv.org/abs/2106.08713 * YOLOR https://arxiv.org/abs/2105.04206 * YOLOR-code (Pytorch): https://github.com/WongKinYiu/yolor * Scaled-YOLOv4(CVPR21): https://openaccess.thecvf.com/content/CVPR2021/html/Wang\_Scaled-YOLOv4\_Scaling\_Cross\_Stage\_Partial\_Network\_CVPR\_2021\_paper.html * Scaled-YOLOv4-code (Pytorch): https://github.com/WongKinYiu/ScaledYOLOv4 * YOLOv4: https://arxiv.org/abs/2004.10934 * YOLOv4-code (Darknet, Pytorch, TensorFlow, TRT, OpenCV…): https://github.com/AlexeyAB/darknet#yolo-v4-in-other-frameworks

The DiDi MapVision team has shown excellent results with the YOLOR and DIDI MapVision models, both based on Scaled-YOLOv4: * DIDI MapVision: https://arxiv.org/abs/2106.08713 * YOLOR https://arxiv.org/abs/2105.04206 * YOLOR-code (Pytorch): https://github.com/WongKinYiu/yolor * Scaled-YOLOv4(CVPR21): https://openaccess.thecvf.com/content/CVPR2021/html/Wang_Scaled-YOLOv4_Scaling_Cross_Stage_Partial_Network_CVPR_2021_paper.html * Scaled-YOLOv4-code (Pytorch): https://github.com/WongKinYiu/ScaledYOLOv4 * YOLOv4: https://arxiv.org/abs/2004.10934 * YOLOv4-code (Darknet, Pytorch, TensorFlow, TRT, OpenCV...): https://github.com/AlexeyAB/darknet#yolo-v4-in-other-frameworks

* YOLOR-code (Pytorch): https://github.com/WongKinYiu/yolor