modes/track/

[giscus[bot]]

modes/track/

Learn how to use Ultralytics YOLO for object tracking in video streams. Guides to use different trackers and customise tracker configurations.

https://docs.ultralytics.com/modes/track/

[AdadAlShabab]

Can I run two models simultaneously in one video?
Ex:
model = YOLO('E:/Ultralytics/best.pt')
model = YOLO('yolov8m-pose.pt')
results = model.track(source="file.mp4", show=True, conf=0.3, save=False)
results = model.track(source="file.mp4", show=True, conf=0.3, save=False)

I want that two models will works simultaneously with cumulative results? Is it possible? Please let me know. Thanks in advance!!

[pderrenger]

@AdadAlShabab yes, you can run two models simultaneously on one video, but you'll need to manage the inference in a way that allows both models to process the video frames concurrently. Here's a simplified example using threading to achieve this:

import threading
from ultralytics import YOLO

# Load the models
model1 = YOLO('E:/Ultralytics/best.pt')
model2 = YOLO('yolov8m-pose.pt')

# Function to run tracking
def track_video(model, source, conf, show, save):
    results = model.track(source=source, show=show, conf=conf, save=save)
    # Process results here or return them

# Create threads for each model
thread1 = threading.Thread(target=track_video, args=(model1, "file.mp4", 0.3, True, False))
thread2 = threading.Thread(target=track_video, args=(model2, "file.mp4", 0.3, True, False))

# Start the threads
thread1.start()
thread2.start()

# Wait for both threads to finish
thread1.join()
thread2.join()

This script will run both models in separate threads. If you want to combine the results from both models, you'll need to implement a mechanism to synchronize and merge the results from both threads. Keep in mind that displaying the results (show=True) from two threads might not work as expected, and you might need to handle the visualization separately.

Remember to handle the GPU memory usage carefully, as running two models simultaneously will require more memory. If you encounter any issues, consider running the models sequentially or on separate GPUs if available.

[Rid1Whitehead]

Hi,

First of all, I have been loving working with Yolov8. Great tool!

However, I have been having difficulties with a certain task. I want to use model.track on videos that I have, and then use save_crop = True, but save with a naming convention where I can track each persons ID. Currently, save_crop just gives me the cropped images of the objectes detected, but there is not way to know from which frame of the video are the crops, also, which ID is attached which cropped image. The visualization through cv2.imshow shows the IDs accross the different frames, but I cant find a way to save them. The naming convention I am looking for is something like this: "frame_30_ID_1.jpg" My current code looks something like this:

from ultralytics import YOLO
import cv2

model = YOLO("yolov8n.pt") # load model

video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

ret = True
frame_count = 0 # Initialize a frame counter

while ret:
ret, frame = cap.read()
frame_count += 1 # Increment the frame counter

# Check if the frame is the 30th frame
if ret and frame_count % 30 == 0:
    results = model.track(frame, persist=True, save_crop = True, save_txt = True)
    frame_ = results[0].plot()

    cv2.imshow("frame", frame_)
    if cv2.waitKey(25) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

Any help would be greatly apprecitated! Thanks!

[pderrenger]

@Rid1Whitehead hello! I'm glad to hear you're enjoying working with YOLOv8! 😊

For your task of saving cropped images with a specific naming convention that includes the frame number and ID, you'll need to customize the saving part of the code. The save_crop functionality in YOLOv8 does not currently support custom naming directly related to frame and ID out of the box.

Here's a modified version of your code that manually saves the cropped images with the desired naming convention:

from ultralytics import YOLO
import cv2
import os

model = YOLO("yolov8n.pt")  # load model

video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

ret = True
frame_count = 0  # Initialize a frame counter
save_dir = "path/to/save/crops"  # Directory to save the crops
os.makedirs(save_dir, exist_ok=True)  # Create the directory if it doesn't exist

while ret:
    ret, frame = cap.read()
    frame_count += 1  # Increment the frame counter

    if ret:
        results = model.track(frame, persist=True)
        for i, det in enumerate(results[0].boxes.xyxy):
            # Extract bounding box coordinates
            x1, y1, x2, y2 = map(int, det[:4])
            crop = frame[y1:y2, x1:x2]  # Crop the detected object

            # Save the cropped image with the desired naming convention
            crop_name = f"frame_{frame_count}_ID_{results[0].boxes.id[i]}.jpg"
            crop_path = os.path.join(save_dir, crop_name)
            cv2.imwrite(crop_path, crop)

        frame_ = results[0].plot()

        cv2.imshow("frame", frame_)
        if cv2.waitKey(25) & 0xFF == ord('q'):
            break

cap.release()
cv2.destroyAllWindows()

In this code, we loop through each detection in the current frame, extract the bounding box coordinates, crop the detected object from the frame, and save it with the naming convention you specified. Make sure to replace "path/to/save/crops" with the actual path where you want to save the cropped images.

Please note that this code assumes that the model.track() method returns the IDs in the results[0].boxes.id attribute. If the IDs are not available or the attribute name is different, you'll need to adjust the code accordingly.

I hope this helps! If you have any more questions or need further assistance, feel free to ask. Happy coding! 🚀

[AdadAlShabab]

Hi @pderrenger . Can I run the models using my phones camera? Can you please share the code to invoke my mobile's camera to test the model? Thanks in advance.

[pderrenger]

@AdadAlShabab hi there! 👋 Yes, you can use your phone's camera to test the YOLO models. If you're looking to connect directly from your phone, you might need an app that can stream your camera feed to a URL. Then, you can use that URL as the source in the model.track() method. Here's a basic example of how you might set it up in Python:

from ultralytics import YOLO

# Load your trained model
model = YOLO('path/to/your/model.pt')

# Replace 'your_stream_url' with the URL from your phone's camera stream
results = model.track(source='your_stream_url', show=True)

Make sure your phone and the computer running the model are on the same network. Happy tracking! 😊

[Liuchunxiao111]

There's no problem at all using your way, but when I use it, the video streaming latency is extraordinarily high, why is that?

import cv2
from ultralytics import YOLO

# Load the YOLOv8 model
model= YOLO('weights/det/yolov8n.pt')

# Open the video file
cap = cv2.VideoCapture("http://192.168.9.123:4747/video")

# Loop through the video frames
while cap.isOpened():
    # Read a frame from the video
    success, frame = cap.read()

    if success:
        # Run YOLOv8 tracking on the frame, persisting tracks between frames
        results = model.track(frame, persist=True)

        # Visualize the results on the frame
        annotated_frame = results[0].plot()

        # Display the annotated frame
        cv2.imshow("YOLOv8 Tracking", annotated_frame)

        # Break the loop if 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Break the loop if the end of the video is reached
        break

# Release the video capture object and close the display window
cap.release()
cv2.destroyAllWindows()

[pderrenger]

Hi there! 🙌 The high latency you're experiencing during video streaming might be due to a few factors. Here are a couple of things you could check or adjust to potentially reduce the latency:

1. Network Speed: If you're streaming the video over a network, ensure that your network connection is fast and stable. Camera streaming apps can sometimes consume a lot of bandwidth.

2. Frame Processing: The model's predictions and the layer of annotations being added to each frame can be computationally intensive. You could try to reduce the image size for detection or lower the frame rate to see if it helps.

3. Hardware Acceleration: If possible, make sure that your system is using any available hardware acceleration to speed up video decoding and model inference.

4. Less Compute-Intensive Model: If latency is still an issue, consider using a smaller, less compute-intensive YOLO model.

Here’s a quick example of reducing image size which might help speed up the process:

import cv2
from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO('weights/det/yolov8n.pt')

# Reduce frames size to increase performance
def resize_frame(frame, scale=0.5):
    width = int(frame.shape[1] * scale)
    height = int(frame.shape[0] * scale)
    dimensions = (width, height)

    return cv2.resize(frame, dimensions, interpolation=cv2.INTER_AREA)

# Open the video file
cap = cv2.VideoCapture("http://192.168.9.123:4747/video")

# Loop through the video frames
while cap.isOpened():
    success, frame = cap.read()

    if success:
        # Resize frame
        frame = resize_frame(frame, scale=0.5)

        # Run YOLOv8 tracking on the frame
        results = model.track(frame, persist=True)

        # Visualize the results
        annotated_frame = results[0].plot()
        cv2.imshow("YOLOv8 Tracking", annotated_frame)

        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        break

cap.release()
cv2.destroyAllWindows()

This adjusts the frame size being processed, which could potentially reduce the latency you're experiencing. Hope this helps! 😊 If issues persist, feel free to provide more information about your setup.

[Liuchunxiao111]

@pderrenger Thanks for your reply!

What puzzles me is that when I use the first method, the picture is smooth and when I use the second method, the picture has a high latency, why is that? I don't think it's a network or hardware acceleration issue.

Way 1

from ultralytics import YOLO

# Load your trained model
model= YOLO('weights/det/yolov8n.pt')

# Replace 'your_stream_url' with the URL from your phone's camera stream
results = model.track(source="http://192.168.9.123:4747/video", show=True)

Way2

import cv2
from ultralytics import YOLO

# Load the YOLOv8 model
model= YOLO('weights/det/yolov8n.pt')

# Open the video file
cap = cv2.VideoCapture("http://192.168.9.123:4747/video")

# Loop through the video frames
while cap.isOpened():
    # Read a frame from the video
    success, frame = cap.read()

    if success:
        # Run YOLOv8 tracking on the frame, persisting tracks between frames
        results = model.track(frame, persist=True)

        # Visualize the results on the frame
        annotated_frame = results[0].plot()

        # Display the annotated frame
        cv2.imshow("YOLOv8 Tracking", annotated_frame)

        # Break the loop if 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Break the loop if the end of the video is reached
        break

# Release the video capture object and close the display window
cap.release()
cv2.destroyAllWindows()

[pderrenger]

Hey @Liuchunxiao111! 🌟 The difference in latency between the two methods might be due to how the frames are processed and displayed. In the first method, the model.track() function handles both the tracking and the frame retrieval internally, which is optimized for efficiency. In the second method, using OpenCV's VideoCapture and processing each frame in a loop with model.track() introduces overhead, especially if the frame processing isn't keeping up with the frame rate of the video stream.

To reduce latency in the second method, you might consider:

• Reducing the resolution of the video stream.
• Simplifying the model if possible, or using a lighter model.
• Ensuring that the code runs on the most capable hardware available (like using a GPU if available).

These tweaks can help align the processing speed more closely with the incoming frame rate, reducing the noticeable lag. Hope this helps! 😊

[Boaruzhanchik]

Hi, help me understand why I get this error when tracking with segmentation model . My ultimate goal is to use a custom car plate segmentation model for tracking. Thank you very much

  File "/home/iosif/Documents/Dev/yolo_model/yolov8_train/yolov8_tracking_car_number/tracking_v4.py", line 80, in <module>
    annotated_frame = results[0].plot()
  File "/home/iosif/.local/lib/python3.10/site-packages/ultralytics/engine/results.py", line 239, in plot
    annotator.masks(pred_masks.data, colors=[colors(x, True) for x in idx], im_gpu=im_gpu)
  File "/home/iosif/.local/lib/python3.10/site-packages/ultralytics/utils/plotting.py", line 237, in masks
    self.im[:] = im_mask_np if retina_masks else ops.scale_image(im_mask_np, self.im.shape)
ValueError: could not broadcast input array from shape (384,640,3) into shape (568,1012,3)


from ultralytics import YOLO
import cv2
from collections import defaultdict
import numpy as np

class_list = [0, 2]
model = YOLO("/home/iosif/Documents/Dev/yolo_model/yolov8_train/yolov8s-seg.pt")
cap = cv2.VideoCapture('/home/iosif/Documents/Dev/yolo_model/yolov8_train/yolov8_tracking_car_number/reac_high_way2.mp4')
track_history = defaultdict(lambda: [])

while cap.isOpened():
    success, frame = cap.read()

    if success:
        results = model.track(frame, show=False, verbose=False, conf=0.4, classes=class_list, persist=True)
        if results[0].boxes.id is not None:
            boxes = results[0].boxes.xywh.cpu()
            track_ids = results[0].boxes.id.cpu().numpy().astype(int)
            annotated_frame = results[0].plot()

            for box, track_id in zip(boxes, track_ids):
                x, y, w, h = box
                track = track_history[track_id]
                track.append((float(x), float(y)))
                if len(track) > 40:
                    track.pop(0)
                points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
                cv2.polylines(annotated_frame, [points], isClosed=False, color=(0, 0, 255), thickness=5)
            cv2.imshow("YOLOv8 Tracking", annotated_frame)


            class_ids = []
            boxes_id = results[0].boxes.id
            if len(boxes_id) > 1:
                id_values = boxes_id.tolist()
            else:
                id_value = boxes_id.item()

            clss = results[0].boxes.cls.cpu().tolist()
            names = results[0].names
            for box, cls in zip(boxes_id, clss):
                class_ids.append(cls)
                if cls == 0.0:
                    print("People detect")

        

        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        break

cap.release()
cv2.destroyAllWindows()

[pderrenger]

Hey there! 👋 It looks like you're encountering a shape mismatch error when plotting your tracking results. This often happens when the image dimensions don't align with the mask dimensions expected by the plot() function.

To resolve this, ensure that the image size you're using for tracking matches the size expected by the model. If you're using a custom model, double-check that the image size during training and inference is consistent.

Here's a quick fix you might try:

# Before plotting, resize your frame to match the model's expected input size
frame_resized = cv2.resize(frame, (model.imgsz[1], model.imgsz[0]))

# Now use the resized frame for tracking and plotting
results = model.track(frame_resized, show=False, verbose=False, conf=0.4, classes=class_list, persist=True)

Make sure to replace model.imgsz[1] and model.imgsz[0] with the actual width and height used during training if model.imgsz is not available.

Give this a shot, and if you're still stuck, feel free to share more details or reach out again! Happy tracking! 🚗💨

[Boaruzhanchik]

Thank you more for such a quick response, it worked

[glenn-jocher]

@Boaruzhanchik hey, that's awesome to hear it worked out for you! 🎉 If you dive into tracking with your custom car plate segmentation model and have any more questions or cool results to share, don't hesitate to reach out. Happy tracking! 🚗🔍

[Elvis-Kiilu2]

@glenn-jocher Hey, how do you implement with custom seg modem, kindly illustrate

[glenn-jocher]

Hey there! Implementing tracking with a custom segmentation model is pretty straightforward. You'll want to load your model and then use the track() method, specifying any particular classes you're interested in. Here's a quick example using a custom segmentation model for car plates:

from ultralytics import YOLO

# Load your custom segmentation model
model = YOLO('path/to/your/custom-seg-model.pt')

# Run tracking on your video source
results = model.track(source='path/to/your/video.mp4', classes=[your_car_plate_class_id])

Just replace 'path/to/your/custom-seg-model.pt' with the actual path to your model and your_car_plate_class_id with the class ID for car plates in your model. If you need more help or have specific questions, feel free to ask! 🚀

[potatoouoo]

Yolov8 has very high overall practicality. Can I implement tracking with two cameras? I hope that when a car tracked by camera A moves to camera B, its frame ID remains the same. However, currently there is always an ID switch happening. Is it because of the model's accuracy?
EX:
def cam1():
model = YOLO('updated-model.pt')
# cap.imgCap()
results = model.track(source="http://192.168.50.204:8080/?action=stream",show = True)
cv2.waitKey(0)
cv2.destroyAllWindows()

def cam2():
model = YOLO('updated-model.pt')
# cap.imgCap()
results = model.track(source="http://192.168.50.69:8080/?action=stream",show = True)
cv2.waitKey(0)
cv2.destroyAllWindows()

cap=cam

a = threading.Thread(target=cam1)
b = threading.Thread(target=cam2)

a.start()
b.start()

[glenn-jocher]

Hey there! Tracking continuity across multiple cameras, especially to maintain the same ID as an object moves from camera A to camera B, is indeed a complex task that involves more than just the accuracy of the model. It requires a method to correlate tracks across the different camera views, often referred to as multi-camera tracking or re-identification (Re-ID).

Regarding access to the global track ID or maintaining consistent IDs across cameras, it's correct that basetrack.py (or similar files, depending on the tracking implementation you're using) manages these IDs. However, for multi-camera setups, you might need to implement or use an existing Re-ID system that can match IDs based on features or appearance.

A simplistic approach could involve:

1. Extracting features of tracked objects.
2. Comparing features of new detections in the second camera with ongoing tracks from the first camera.
3. Assigning the same ID based on the similarity of the features.

This can get quite involved, as it requires managing the timing and spatial-correlation of detections across cameras, and the model's accuracy is just one of many factors.

For directly accessing or setting the track ID, if you're using a specific tracker that has its global track ID in basetrack.py, you might interact with it directly within your code (varying by implementation). However, multi-camera ID continuity typically requires a higher-level management system than what's provided in individual tracker files.

I hope that sheds a bit more light on it! Let me know if you delve into the re-identification approach or if you have other questions. 😊👍

[potatoouoo]

I have a new question, can I know the distance to the camera while tracking?

[glenn-jocher]

Hey there!

Regarding your question about knowing the distance to the camera while tracking, YOLOv8 or most object tracking algorithms, including those implemented in Ultralytics YOLO, primarily focus on detecting objects and potentially tracking their movement across frames. They don't inherently provide distance measurements since that would require additional depth-sensing hardware or methods.

However, if you have a calibrated camera setup or additional information about the scene, you might estimate distances using object sizes or other cues. For instance, in specific, controlled environments, the apparent size of known objects can give clues about distance based on their expected real-world size.

Alternatively, employing depth cameras or stereo vision setups can directly provide depth information. If using such sensors, depth data can be combined with tracking data to estimate distances of tracked objects.

I hope that helps a bit! If you're diving deeper into this, consider exploring topics like camera calibration, depth sensing technologies, and stereo vision. 😊📏🎥

[potatoouoo]

Hello, I would like to ask, my current tracking program is as shown below
retList2, frameTmp2 = cap2.imgCap()
results = model.track(frameTmp2,persist=True,show = True)

             if text2:
                 boxes = results[0].boxes.xywh.cpu()
                 if results[0].boxes.id is not None:
                     track_ids1 = results[0].boxes.id.int().cpu().tolist()
                     plate_info = tracker.get_plate_info()
                     print(plate_info)
                     time.sleep(1)

I need the X1X2Y1Y2 of the tracking frame in each frame to calculate the distance. Is there a way to get it?

[glenn-jocher]

Hello! To get the bounding box coordinates (X1, Y1, X2, Y2) for each tracked object, you can access the .xyxy attribute from the results object. Here’s how you can modify your code to print these coordinates along with the track IDs:

def cam1():
    global shard_track
    model = YOLO('updated-model.pt')
    shard_track = model.track(source="http://192.168.50.204:8080/?action=stream", show=True)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

def track_and_print_cam1():
    global shard_track
    if hasattr(shard_track, 'xyxy'):
        for det in shard_track.xyxy[0]:  # Assuming shard_track is the results object
            x1, y1, x2, y2, conf, cls, track_id = det
            print(f'Track ID: {track_id.item()}, BBox: ({x1.item()}, {y1.item()}, {x2.item()}, {y2.item()})')
    else:
        print("No tracking data found.")

This modification ensures you're extracting the bounding box coordinates directly from the detection results, which should help you calculate distances or any other metrics based on the positions of the objects. If you have any more questions or need further assistance, feel free to ask! 😊

[samyak197]

Hey there,
First of all, I love working with YOLO , functionalities for basically everything.

          Currently i was working with a project that requires me to track different employee in a shop and was wandering if YOLO could help me assigning identities to each employees and if i t cpuld track for the entire working day.

[pderrenger]

@samyak197 hey there! 😊

Absolutely, YOLO can assist with tracking employees in a shop. You can use our tracking models to assign unique IDs and track them throughout the day. For long-term tracking, make sure your video feed is continuous and the model is configured for persistent tracking.

Here's a quick example using YOLOv8:

from ultralytics import YOLO

# Load your custom trained model or an official YOLOv8 model
model = YOLO('path/to/your/custom-model.pt')  # Custom trained model

# Track employees in a video
results = model.track(source="path/to/shop/video.mp4", persist=True)

This will keep the identities consistent across frames. For more details, check out our tracking documentation. If you have any more questions or need further assistance, feel free to ask. Happy tracking! 🚀

[ParkerLischwe]

Hi I saw that I can use an openvino IR format model just like any other pytorch model and then run tracking like normal. I was wondering how I would load the IR '.xml' and '.bin' files as arguments into YOLO(), or if I should load my model using openvino library? Thanks.

[glenn-jocher]

Hey there! 👋

To load OpenVINO IR '.xml' and '.bin' files into YOLO(), you'll want to simply point to their containing directory, i.e.:

from ultralytics import YOLO

# Load your YOLOv8 OpenVINO model
model = YOLO('path/to/yolov8n_openvino_model/')  # exported with YOLO('yolov8n.pt').export(format='openvino')

# Track employees in a video
results = model.track(source="path/to/shop/video.mp4", persist=True)

Once you have your model loaded with OpenVINO, you can then proceed with tracking as you would normally with the YOLO model. You might want to use stream=True also for longer videos and streams. If you need further assistance, feel free to ask. Happy tracking! 😊

[ParkerLischwe]

Will give this a try, appreciate the timely response!

[pderrenger]

@ParkerLischwe glad to hear you're giving it a try! If you have any questions or need a hand with the tracking setup, just drop a message. Happy tracking! 😊🚀

[ANIRUDH1080Z]

Can i use yolov8 model to track and reidentify person with same id assigned to it in multiple camera feed ?

[glenn-jocher]

@ANIRUDH1080Z yes, you can use YOLOv8 models for multi-object tracking across multiple camera feeds. Each detected person can be assigned a unique ID that persists as they move through the field of view of different cameras. You can choose from different trackers like BoT-SORT and ByteTrack, and even customize the tracker configurations to suit your specific needs. Here's a simple example using the default tracker:

from ultralytics import YOLO

# Load a YOLOv8 model
model = YOLO('yolov8n.pt')

# Perform tracking on a video source
results = model.track(source="path/to/camera_feed.mp4", show=True)

For tracking across multiple cameras, you might need to synchronize the cameras and handle the ID reidentification logic, as the trackers maintain IDs within a single video stream. If you have a custom solution or improvements, consider contributing to our Trackers section! 🚀

[ANIRUDH1080Z]

Thank u so much for enlightening me about this.

[glenn-jocher]

You're welcome! I'm glad the information was helpful. If you're looking to implement multi-object tracking across multiple camera feeds, you can certainly use YOLOv8 models. While YOLOv8 can assign unique IDs within a single video stream, tracking across multiple cameras (especially with non-overlapping fields of view) typically requires additional logic to handle ID reidentification.

For such cases, you might consider integrating your YOLOv8 tracking with a reidentification (ReID) system that can match IDs based on appearance features. Here's a simple example of how you might set up tracking for a single camera feed:

from ultralytics import YOLO

# Load a YOLOv8 model
model = YOLO('yolov8n.pt')

# Perform tracking on a video source
results = model.track(source="path/to/camera_feed.mp4", show=True)

For multi-camera setups, after tracking, you would extract features from detected objects and use a ReID model to match identities across different camera feeds.

If you're developing a solution or have improvements, we'd love to see your contributions to our tracking capabilities! 🚀

[kshweikeh]

How can we only track moving objects in the Plotting Tracks Over Time code:

from collections import defaultdict

import cv2
import numpy as np

from ultralytics import YOLO

Load the YOLOv8 model

model = YOLO('yolov8n.pt')

Open the video file

video_path = "path/to/video.mp4"
cap = cv2.VideoCapture(video_path)

Store the track history

track_history = defaultdict(lambda: [])

Loop through the video frames

while cap.isOpened():
# Read a frame from the video
success, frame = cap.read()

if success:
    # Run YOLOv8 tracking on the frame, persisting tracks between frames
    results = model.track(frame, persist=True)

    # Get the boxes and track IDs
    boxes = results[0].boxes.xywh.cpu()
    track_ids = results[0].boxes.id.int().cpu().tolist()

    # Visualize the results on the frame
    annotated_frame = results[0].plot()

    # Plot the tracks
    for box, track_id in zip(boxes, track_ids):
        x, y, w, h = box
        track = track_history[track_id]
        track.append((float(x), float(y)))  # x, y center point
        if len(track) > 30:  # retain 90 tracks for 90 frames
            track.pop(0)

        # Draw the tracking lines
        points = np.hstack(track).astype(np.int32).reshape((-1, 1, 2))
        cv2.polylines(annotated_frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)

    # Display the annotated frame
    cv2.imshow("YOLOv8 Tracking", annotated_frame)

    # Break the loop if 'q' is pressed
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break
else:
    # Break the loop if the end of the video is reached
    break

Release the video capture object and close the display window

cap.release()
cv2.destroyAllWindows()

[kshweikeh]

I forgot to write "only " so its MOVING OBJECTS ONLY

[glenn-jocher]

@kshweikeh hey there! 👋 To track only moving objects, you can modify the code to calculate the displacement of each object between frames and only plot the tracks for those with significant movement. Here's a quick example of how you might do that:

# ... [previous code]

# Define a movement threshold (this value may need tuning)
movement_threshold = 5  # pixels

# Loop through the video frames
while cap.isOpened():
    # ... [previous code]

    # Get the previous and current center points
    for track_id in track_ids:
        if len(track_history[track_id]) >= 2:
            prev_center = track_history[track_id][-2]
            curr_center = track_history[track_id][-1]
            displacement = np.sqrt((curr_center[0] - prev_center[0]) ** 2 + (curr_center[1] - prev_center[1]) ** 2)

            # Only plot the track if the displacement is above the threshold
            if displacement > movement_threshold:
                points = np.array(track_history[track_id], dtype=np.int32).reshape((-1, 1, 2))
                cv2.polylines(annotated_frame, [points], isClosed=False, color=(230, 230, 230), thickness=10)

    # ... [previous code]

This snippet calculates the Euclidean distance between the previous and current positions of each tracked object and only draws the track if the object has moved more than the movement_threshold. You can adjust the threshold to fit the specifics of your scenario. Happy coding! 🚀

[kshweikeh]

Thanks!!

[glenn-jocher]

@kshweikeh hey there! 👋

Absolutely, happy to help! For tracking moving objects with YOLOv8, you can utilize the track method with a custom tracker configuration that focuses on objects with significant displacement between frames. Here's a quick snippet to get you started:

from ultralytics import YOLO

# Load your model
model = YOLO('path/to/your/model.pt')

# Run the tracker
results = model.track(source='path/to/your/video.mp4', tracker='custom_tracker.yaml')

In your custom_tracker.yaml, you might want to adjust parameters that affect the detection of stationary vs. moving objects, such as minimum displacement thresholds or object persistence criteria.

If you need more guidance or have specific requirements, feel free to share, and we can dive deeper! 🚀

[RNVALA]

import cv2
from ultralytics import YOLO
import numpy as np

model = YOLO('yolov8_custom_train.engine', task="detect")

Path to the input video file

input_video_path = '/content/gdrive/MyDrive/yolov8-tensorrt/inference/output_video.mp4'

Path to the output video file

output_video_path = 'outputtest_video.mp4'

Define the coordinates of the polygon

polygon_points = [(670, 66), (1237, 550), (514, 1054), (161, 295)]
polygon_points = np.array(polygon_points)

Open the input video file

cap = cv2.VideoCapture(input_video_path)

Get video properties

frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
fps = int(cap.get(cv2.CAP_PROP_FPS))
total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

Define the codec and create VideoWriter object

fourcc = cv2.VideoWriter_fourcc(*'mp4v')
out = cv2.VideoWriter(output_video_path, fourcc, fps, (frame_width, frame_height))

Function for finding the centroid

def calculate_centroid(box):
x_min, y_min, x_max, y_max = map(int, box)
centroid_x = (x_min + x_max) // 2
centroid_y = (y_min + y_max) // 2
return (centroid_x, centroid_y)

Function to check if two bounding boxes overlap

def check_overlap(box1, box2):
x1_min, y1_min, x1_max, y1_max = map(int, box1)
x2_min, y2_min, x2_max, y2_max = map(int, box2)
overlap_x = max(0, min(x1_max, x2_max) - max(x1_min, x2_min))
overlap_y = max(0, min(y1_max, y2_max) - max(y1_min, y2_min))
overlap_area = overlap_x * overlap_y
return overlap_area

Read until video is completed

while cap.isOpened():
# Read a frame from the video
ret, frame = cap.read()

# If frame is read correctly ret is True
if not ret:
    break

results = model.track(source=frame, device=0)
# Extract bounding boxes, classes, names, and confidences
boxes = results[0].boxes.xyxy.tolist()
classes = results[0].boxes.cls.tolist()
names = results[0].names
confidences = results[0].boxes.conf.tolist()
#id=results[0].boxes.id
# Iterate through the results
red_area_count = 0
blue_area_count = 0
crowded_area_detected = False
crowded_box = None

for i, box1 in enumerate(boxes):
    overlap_count = 0
    for j, box2 in enumerate(boxes):
        if i != j:
            overlap_area = check_overlap(box1, box2)
            if overlap_area > 0:
                overlap_count += 1
                if overlap_count >= 2:
                    crowded_area_detected = True
                    if crowded_box is None:
                        crowded_box = box1
                    else:
                        crowded_box = [
                            min(crowded_box[0], box1[0]),
                            min(crowded_box[1], box1[1]),
                            max(crowded_box[2], box1[2]),
                            max(crowded_box[3], box1[3])
                        ]
                    break

for box, cls, conf in zip(boxes, classes, confidences):
    x1, y1, x2, y2 = box
    confidence = conf
    detected_class = cls
    name = names[int(cls)]
    
    if cv2.pointPolygonTest(polygon_points, calculate_centroid(box), False) >= 0:
        red_area_count += 1
        color = (0, 0, 255)
    else:
        color = (0, 255, 0)
        blue_area_count += 1

    x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)
    cv2.rectangle(frame, (x1, y1), (x2, y2), color, 2)
for i,det in enumerate(results[0].boxes.xyxy):
    x1, y1, x2, y2 = map(int, det[:4])
    cv2.putText(frame, f'ID: {results[0].boxes.id[i]}', (x1+5, y1+25), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255,255,255), 2, cv2.LINE_AA)
    
if crowded_area_detected:
    crowded_boxes = [box for box in boxes if check_overlap(crowded_box, box) > 0]
    x1, y1, x2, y2 = crowded_box
    for box in crowded_boxes:
        if box != crowded_box and check_overlap(crowded_box, box) > 0:
            x1 = min(x1, box[0])
            y1 = min(y1, box[1])
            x2 = max(x2, box[2])
            y2 = max(y2, box[3])
    cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 255), 2)
    cv2.putText(frame, 'Crowded Area', (int(x1), int(y1) - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 255), 2)

font = cv2.FONT_HERSHEY_SIMPLEX

cv2.putText(frame, 'People working with attention - {}'.format(blue_area_count), (1125, 24), font, 1, (0, 255, 0), 2, cv2.LINE_AA)
cv2.putText(frame, 'People not working - {}'.format(red_area_count), (1124, 75), font, 1, (0, 0, 255), 2, cv2.LINE_AA)
cv2.line(frame, (668, 66), (1237, 550), (255, 0, 0), 2)
cv2.line(frame, (1237, 550), (515, 1052), (255, 0, 0), 2)

# Write the frame into the output video file
out.write(frame)

# Display the frame
# cv2_imshow(frame)

# Press Q on keyboard to exit
if cv2.waitKey(25) & 0xFF == ord('q'):
    break

Release video objects

cap.release()
out.release()

Close all OpenCV windows

cv2.destroyAllWindows()

In this, I am tracking a label Person but in the next 2 to 3 frames, ids are changing so any solution for this?
means if person having id 1, so after few frame it give as id 3, and every time the id is changing

[pderrenger]

Hey there! 👋 It looks like you're experiencing some ID consistency issues with your custom-trained model during tracking. This can happen due to various reasons, such as similar-looking objects or occlusions.

One approach to mitigate this is to fine-tune your tracker's hyperparameters. If you're using the default BoT-SORT tracker, you might want to experiment with the bytetrack.yaml configuration, which is designed to handle ID switches more robustly. Here's a quick example of how to switch to ByteTrack:

from ultralytics import YOLO

# Load your custom-trained model
model = YOLO('yolov8_custom_train.engine', task="detect")

# Perform tracking with ByteTrack
results = model.track(source="your_video.mp4", tracker="bytetrack.yaml")

If you've already tried adjusting the tracker settings and the issue persists, consider revisiting your training dataset to ensure it's diverse and representative enough to handle the scenarios where ID switches occur.

Keep us posted on your progress, and if you need more assistance, we're here to help! 😊

[RNVALA]

I have already used the bytetrack.yaml and this is ouput video , https://drive.google.com/file/d/1E95m456dbZAUDRrodfrvrsSA4zcs3KiA/view?usp=sharing , please analyze it

[pderrenger]

Hey there! Thanks for reaching out and sharing the video link. 🎥 I took a look, and it seems like the ID switches might be due to occlusions or similar-looking objects. Here are a couple of quick suggestions:

1. Tweak the IOU Threshold: Adjust the iou_thresh parameter in your bytetrack.yaml to a value that might help in maintaining consistent IDs.
2. Increase Detection Confidence: A higher conf_thresh could reduce false positives, which sometimes cause ID confusion.

If you've already fine-tuned these without success, consider:

• Re-training with Augmented Data: More varied training data can improve tracking robustness.
• Post-Processing: Implement a custom ID management system in post-processing to smooth out ID switches.

If you're still facing issues, feel free to share more details or reach out for further assistance. We're here to help! 😊👍

[Dmonzer]

What is the difference between these attributes of results[0].boxes:
xywh: tensor([], size=(0, 4))
xywhn: tensor([], size=(0, 4))
xyxy: tensor([], size=(0, 4))
xyxyn: tensor([], size=(0, 4))

[glenn-jocher]

Hey there! 👋 The attributes you're asking about represent different formats of bounding box coordinates:

• xywh: Bounding boxes in (center x, center y, width, height) format.
• xywhn: Normalized (center x, center y, width, height), with values from 0 to 1 relative to image size.
• xyxy: Bounding boxes in (top left x, top left y, bottom right x, bottom right y) format.
• xyxyn: Normalized (top left x, top left y, bottom right x, bottom right y), with values from 0 to 1.

The tensors being empty (size=(0, 4)) suggests no detections were made in the frame. If you have further questions or need assistance, feel free to ask! Happy coding! 😊

[WooFy11]

is it possible to use our own weighs as a model to track? or we must include the yolov8n.pt?

[pderrenger]

Absolutely, you can use your own custom weights for tracking! Just load your trained model instead of the default yolov8n.pt. Here's a quick example in Python:

from ultralytics import YOLO

# Load your custom trained model
model = YOLO('path/to/your/custom-weights.pt')

# Perform tracking with your model
results = model.track(source="path/to/your/video.mp4", show=True)

And that's it! Your custom model will now be used for tracking objects in your video stream. 🚀 If you have any more questions or need further assistance, feel free to ask. Happy tracking!

[WooFy11]

do you a discord so we can discuss about my project?

[pderrenger]

Hey there! 👋 We don't have an official Discord channel, but we're happy to help you right here or on our GitHub discussions page. If you have any questions about your project or need assistance with object tracking using YOLOv8, feel free to drop your questions, and we'll do our best to assist you! 🚀 If it's code-specific, you can also share snippets or error messages, and we'll take a look. Happy tracking!

[WooFy11]

i had an error when everytime i try to run a code, it crashed on 4xx/600, and i must restart it, and 2nd question can we make a custom annotator?

[pderrenger]

Hey there! 👋 It sounds like you're encountering a crash during your code execution. To better assist you, could you please share the specific error message you're getting? This will help us pinpoint the issue more accurately.

Regarding your second question, yes, you can create a custom annotator. If you're working with YOLOv8, you can use tools like CVAT or LabelImg for annotation, and then train your model with these custom annotations. Here's a quick example of how you might load and use your custom model for tracking:

from ultralytics import YOLO

# Load your custom trained model
model = YOLO('path/to/your/custom_model.pt')

# Perform tracking on your video
results = model.track(source='path/to/your/video.mp4', show=True)

This will use your custom weights for tracking objects in the video. If you have any more questions or need further assistance, feel free to ask! 🚀

[tumitoto007]

So I am using Yolov8 for my current project, it's been a breeze so far. I do have a question on the tracking method provided by the Yolov8. When I am using the generic yolov8n model(or even a custom model mixed with few objects), I know I can specifically filter out things that doesn't interest me by their ID as below:

    for data in .....boxes.data.tolist():
            # extract the id associated with the detection
            objectID= data[5]
   if not interested skip this object....

But, when I caught the an object that I am interested, can I at that time or at that frame, issue a track command to start tracking it? if it can be done, can you tell me how? an short example will be even better! thanks in advance.

[glenn-jocher]

@tumitoto007 hey there! 😊 It's great to hear that YOLOv8 has been a breeze for your project. Regarding your question about initiating tracking on a specific object at a certain frame, YOLOv8's tracking functionality is designed to automatically track all detected objects continuously across frames. However, if you're interested in tracking a specific object after its detection, you can filter detections by their IDs as you've mentioned and then focus on tracking that specific object ID across the frames.

Here's a simplified example to illustrate how you might approach this:

from ultralytics import YOLO

# Load your model
model = YOLO('yolov8n.pt')  # or your custom model

# Assuming you're processing video frames in a loop
interested_object_id = None  # Placeholder for the ID of the object you're interested in tracking
for frame in video_frames:
    results = model.track(frame, persist=True)
    for box in results[0].boxes:
        objectID = box.id.item()  # Get the ID of the current object
        if objectID == interested_object_id:
            # This is the object you're interested in, now you can track it specifically
            # Process the tracking data as needed
            pass

In this example, interested_object_id should be set to the ID of the object you're interested in tracking once you've identified it. From that point on, you can specifically process or track that object in subsequent frames.

Remember, the tracking starts automatically for all detected objects, so the key is filtering and focusing on the object of interest in your processing loop.

Hope this helps! If you have any more questions or need further assistance, feel free to ask. Happy tracking! 🚀

[tumitoto007]

Cool! I will give this a try once I get back to town. Thanks again for your great support.

[glenn-jocher]

Hey there! 🎉 I'm thrilled to hear you're planning to give tracking a try with YOLOv8 once you're back in town. It sounds like you're on an exciting journey with your project! If you have any questions or need further assistance when you dive into it, don't hesitate to reach out. Our community and docs are here to support you every step of the way. Happy tracking, and safe travels back to town! 🚀

[KhizarHashmi]

Hi, I want some detailed help and guidance on how to use custom tracker models with my custom yolov8 pose model, the Re-identification problem is being face using bytetrack.yaml so I think I should use StrongSORT or DeepSORT. Therefore, I want the ultralytics team to help me on selecting my tracker model or use multiple tracker models, and guide me properly on how to use them with my YOLOv8 custom trained model.
Thanks

[KhizarHashmi]

@glenn-jocher

[glenn-jocher]

@KhizarHashmi hi there! 👋 It sounds like you're exploring advanced tracking options for your custom YOLOv8 pose model. If ByteTrack isn't meeting your re-identification needs, exploring StrongSORT or DeepSORT could indeed be beneficial. These trackers offer sophisticated mechanisms for handling occlusions and maintaining identity across frames, which might be what you're looking for.

To integrate a custom tracker like StrongSORT or DeepSORT with your YOLOv8 model, you'll typically need to:

1. Ensure your tracker can process the detection output format of YOLOv8. This usually involves bounding box coordinates, confidence scores, and class IDs.
2. Modify your tracking script to use the YOLOv8 model for detection, feeding these detections into your chosen tracker for each frame of your video.

Here's a simplified example of how you might set this up in Python, assuming you have a function custom_tracker that takes detections and returns tracked objects:

from ultralytics import YOLO

# Load your custom trained YOLOv8 model
model = YOLO('path/to/your/custom_model.pt')

# Function to perform detection and tracking on a frame
def detect_and_track(frame):
    # Perform detection
    results = model(frame)
    
    # Extract detections (example format, adjust as needed)
    detections = results.pandas().xyxy[0]  # DataFrame of detections
    
    # Perform tracking with your custom tracker
    tracked_objects = custom_tracker(detections)
    
    return tracked_objects

# Example usage with a video stream
# ... video capture setup here ...
while True:
    ret, frame = cap.read()
    if not ret:
        break
    tracked_objects = detect_and_track(frame)
    # ... visualization and further processing here ...

Regarding using multiple trackers, it's possible to switch between trackers based on the scenario or even combine their strengths, though this can get complex. You might start with one tracker and evaluate its performance thoroughly before experimenting with combining them.

For more detailed guidance on integrating specific trackers or handling complex tracking scenarios, the documentation and community forums for those trackers can be valuable resources. Additionally, our Ultralytics Docs provide further insights into tracking configurations and options.

If you're developing new tracking capabilities or have insights to share, we'd love to see your contributions to our GitHub repo. Your expertise could greatly benefit the YOLO and tracking community! 🚀

Hope this helps! Let us know if you have more questions.

[Vinrub]

import random
import cv2
import numpy as np
from ultralytics import YOLO

opening the file in read mode

my_file = open("utils/coco.txt", "r")

reading the file

data = my_file.read()

replacing end splitting the text | when newline ('\n') is seen.

class_list = data.split("\n")
my_file.close()

Generate random colors for class list

detection_colors = []
for i in range(len(class_list)):
r = random.randint(0, 255)
g = random.randint(0, 255)
b = random.randint(0, 255)
detection_colors.append((b, g, r))

load a pretrained YOLOv8n model

model = YOLO("weights/yolov8n.pt", "v8")

Vals to resize video frames | small frame optimise the run

frame_wid = 640
frame_hyt = 480

def CarBehaviour(frame, color_threshold=1100):
# Convert the frame to HSV for color thresholding
hsv_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

# Define the lower and upper bounds for the color of the rear lights (adjust as needed)
lower_color = np.array([0, 100, 100])  # Lower bound for red color
upper_color = np.array([10, 255, 255]) # Upper bound for red color

# Create a mask using the inRange function to threshold the color
mask = cv2.inRange(hsv_frame, lower_color, upper_color)

# Calculate the number of nonzero pixels in the mask
color_pixels = cv2.countNonZero(mask)

# Check if color pixels are present
if color_pixels > color_threshold:
    return True, 'Braking'  # If color threshold is met, indicate braking
else:
    return False, 'Not Braking'  # Otherwise, indicate not braking

def detect_and_draw(frame, model, class_list, detection_colors):
# Predict on image
detect_params = model.track(source=[frame], conf=0.45, save=False)

# Convert tensor array to numpy
DP = detect_params[0].cpu().numpy()

if len(DP) != 0:
    for i in range(len(detect_params[0])):
        boxes = detect_params[0].boxes
        box = boxes[i]  # returns one box
        clsID = box.cls.cpu().numpy()[0]
        conf = box.conf.cpu().numpy()[0]
        bb = box.xyxy.cpu().numpy()[0]

        cv2.rectangle(
            frame,
            (int(bb[0]), int(bb[1])),
            (int(bb[2]), int(bb[3])),
            detection_colors[int(clsID)],
            3,
        )

        # Display class name and confidence
        font = cv2.FONT_HERSHEY_COMPLEX
        cv2.putText(
            frame,
            class_list[int(clsID)] + " " + str(round(conf, 3)) + "%",
            (int(bb[0]), int(bb[1]) - 10),
            font,
            1,
            (255, 255, 255),
            2,
        )

# Check car behavior
is_braking, behavior = CarBehaviour(frame)
# Display car behavior
cv2.putText(
    frame,
    "Car Behavior: " + behavior,
    (50, 50),
    cv2.FONT_HERSHEY_SIMPLEX,
    1,
    (0, 255, 0),
    2,
    cv2.LINE_AA,
)

Open video capture

cap = cv2.VideoCapture("/home/opencv_env/Vehicle-rear-lights-analyser-master/testing_data/road_2.mp4")

if not cap.isOpened():
print("Cannot open camera")
exit()

while True:
# Capture frame-by-frame
ret, frame = cap.read()
# if frame is read correctly ret is True

if not ret:
    print("Can't receive frame (stream end?). Exiting ...")
    break

#  resize the frame | small frame optimise the run
# frame = cv2.resize(frame, (frame_wid, frame_hyt))

# Detect and draw objects
detect_and_draw(frame, model, class_list, detection_colors)

# Display the resulting frame
cv2.imshow("ObjectDetection", frame)

# Terminate run when "Q" pressed
if cv2.waitKey(1) == ord("q"):
    break

When everything done, release the capture

cap.release()
cv2.destroyAllWindows()
in this code can i add tracking id number using yolov8

[glenn-jocher]

Absolutely, you can add tracking IDs to your detections using YOLOv8! 🚀 To do this, you'll want to utilize the track method available in the Ultralytics YOLO API. This method not only performs object detection but also assigns unique IDs to each detected object, allowing you to track their movement across frames.

Here's a simplified example to get you started:

from ultralytics import YOLO

# Load your model
model = YOLO("weights/yolov8n.pt")

# Assuming 'frame' is your input frame
results = model.track(source=[frame])

# Now, each detected object in 'results' has a unique tracking ID
for det in results[0].boxes:
    # Extract tracking ID
    track_id = det.id.cpu().numpy()
    print(f"Tracking ID: {track_id}")

This will print the tracking ID for each detected object in the frame. Make sure to loop over your video frames to continuously track objects. Happy tracking! 🎉

[Boaruzhan]

Hi, can you please tell me if the tracker works better on more modern version of ultralytics or version 8.3.68 is no different from 8.1.34 ? (When using botsort.yaml)

[glenn-jocher]

@Boaruzhan the performance of trackers like BoT-SORT (via botsort.yaml) can vary between versions due to improvements in the underlying framework, bug fixes, or optimizations. I recommend testing the tracker on your specific use case with both versions (8.3.68 and 8.1.34) to evaluate any differences. Additionally, consider using the latest version of Ultralytics for the most up-to-date features and enhancements.

[rohith-aiunika]

Is it good to have more points in my label file?
i have used auto annotation with my base model(segmentation) and when i loaded that data in my annotating workspace it is showing more points and my label file size is also increased
is it good to have those many points or shall i rework on the dataset and do manual annotations?

my dataset size is 30k images having total of 16 classes

[glenn-jocher]

@rohith-aiunika thank you for your question! For segmentation tasks, having more points in your labels can provide higher precision but may increase computational load. We recommend reviewing a sample of your auto-annotated masks - if they maintain good object boundaries while being reasonably efficient, they're likely acceptable. For optimal performance, ensure your annotations balance precision with simplicity. You might consider using polygon simplification tools if points are excessively redundant while preserving mask accuracy.

[Ranjith3436]

If i change the byte track parameters always it assign new track ids for same object. it's fine for same track id to different object. how can i implement this thing

[glenn-jocher]

@Ranjith3436 this behavior can occur with ByteTrack when parameter changes disrupt track continuity; try using persist=True and a tailored tracker configuration to stabilize the ID assignment.

[josefheidler]

Hey, is it possible to run tracking on already classified data (i.e., bounding boxes)?

If so, would you be able to share a code snippet?

I want to try different parameters for tracking, and it would be nice if I didn't need to run the whole detection again. It might be faster, right?

Thanks!

[glenn-jocher]

@josefheidler yes, you can run tracking on existing detections by using the model.track() method with your precomputed results. While detection is typically integrated into the tracking pipeline for real-time processing, you can optimize parameters like conf, iou, or tracker configs to refine tracking without reprocessing detections. Here's a minimal example using your existing data:

from ultralytics import YOLO

model = YOLO('yolo11n.pt')
results = model.track(source='your_data_source', tracker='bytetrack.yaml')  # Use your precomputed detections

For parameter tuning, see our tracking config docs.

[josefheidler]

Thank you but how should the source look like? Normally it would be a frame (image).

So the idea is that I will process my video, sink results in file, then load the file and try a bunch of different parameters for tracking.

[glenn-jocher]

To process existing detection results for tracking parameter tuning without reprocessing frames, you can load your saved detection data as a sequence of frames and use the persist=True argument to maintain track continuity. Here's a minimal example using your precomputed results:

from ultralytics import YOLO

model = YOLO('yolo11n.pt')  # Load any model
results = model.track(source='path/to/saved_frames', tracker='bytetrack.yaml', persist=True, conf=0.1)

For detailed parameter adjustments, see the tracking configuration options. The source should be a directory of frames or video file containing your pre-detected objects.

[josefheidler]

But is it possible to, instead of frames or videos, use saved detections, meaning for example saving detections with save_txt and then loading them up and "redoing" only tracking, not detection. Do you understand what I'm trying to solve? :) Or is the tracking based on more than just detections? Thank you!

[Ranjith3436]

Hi Guys, I am running a pipeline to track person. In between process sometimes, the model not predict the people. it detect only few people. the model miss some people, the people front of the CCTV camera. but it was not detecting. If you have ideas about this problem help me guys.

[glenn-jocher]

@Ranjith3436 for missed detections in person tracking, ensure you're using appropriate confidence thresholds and consider these steps:

1. Adjust confidence: Lower the conf parameter (default=0.3) to capture more detections:

results = model.track(source=..., conf=0.25)

2. Try ByteTrack: It handles low-confidence detections better than BoT-SORT:

results = model.track(source=..., tracker="bytetrack.yaml")

3. Use pose models: YOLOv8-pose models often achieve better human detection accuracy. For full guidance, see our tracking documentation.

[Ranjith3436]

i add the gif video, the "yolo11x-seg.pt" model is not detectiong.
https://drive.google.com/file/d/1jKCLOM7lbZPu7x-1fK32NOc-2h1kEoBz/view?usp=sharing

the link has output video. my pipeline detecting the frame using model.track. also frame given from another class. and after process tracking using VGG and ReID. then store all cropped images. this is the brief summary for processing of a frame. inbetween process we skipped other frames and get latest frames. but the model missed the detection.

[glenn-jocher]

For missed detections with yolo11x-seg.pt, first verify your model is detecting without the tracking pipeline by testing model.predict() instead of model.track(). If detections are still missed, try increasing input resolution with imgsz=1280 in your track call. Segmentation models like YOLO11x-seg may prioritize segmentation accuracy over detection recall compared to pure detection models like YOLO11x. You can find more guidance in the Ultralytics tracking documentation.

[jmartinlobo]

Hello! I have trained a custom detection model based on YOLO11n that does tiled inference using SAHI (https://docs.ultralytics.com/guides/sahi-tiled-inference/). The detection works quite well, but I am having trouble thinking of a way to combine SAHI's detections with the tracking implementations discussed in this article, since the "track" method belongs to "model" itself. Is there some solution or workaround I could try? Thank you!

[glenn-jocher]

@jmartinlobo you're correct that the track method is directly tied to the model object, presenting a challenge when integrating with SAHI's tiled inference.

Consider integrating SAHI's detection output with the model.track() method by using the results object, which you would get from SAHI, and then update to include tracking information before passing it to the tracker.

[Ranjith3436]

i add the gif video, the "yolo11x-seg.pt" model is not detectiong.
https://drive.google.com/file/d/1jKCLOM7lbZPu7x-1fK32NOc-2h1kEoBz/view?usp=sharing

the link has output video. my pipeline detecting the frame using model.track. also frame given from another class. and after process tracking using VGG and ReID. then store all cropped images. this is the brief summary for processing of a frame. inbetween process we skipped other frames and get latest frames. but the model missed the detection.

[glenn-jocher]

@Ranjith3436 to address detection issues with the yolo11x-seg.pt model, first verify your tracking parameters. Ensure you're using appropriate confidence thresholds (conf) and set persist=True to maintain track IDs across skipped frames. If detections are still missed, try adjusting the track_high_thresh in your tracker configuration file from ultralytics/cfg/trackers to better match your use case. For direct model validation, test with simpler inputs using the YOLO11 Quickstart before integrating custom processing steps.

[jmartinlobo]

@glenn-jocher Thank you for your reply! If I understand correctly, I should be able to extract SAHI's predictions, adapt them to the format expected by the tracker and feed them to the tracker. However, I am left wondering what the syntax would look like in this case: in this article, you provide instructions on how to feed a video to model.track(), but I could not find a guide to feed it existing detections, say in a format similar to YOLO annotations (relative x center, y center, width and height of bounding box, plus detection scores perhaps).

As a follow-up question to what the syntax would be: if I were to give the tracker existing predictions, would the "model" I choose for "model.track" not act only as a shell for the ByteTrack/BoT-SORT algorithm I am interested in using? I suppose it would, given that I have already detected using a different model. Thank you again!

[glenn-jocher]

For integrating external detections like SAHI with Ultralytics tracking, you can initialize a dummy model to access the tracker while bypassing detection. Here's the concise approach:

from ultralytics import YOLO

# Initialize model with tracker (detection won't be used)
model = YOLO("yolo11n.pt").tracker  # Loads tracker config only

# For each frame:
results = model.track(..., persist=True)  # Get initial tracks
# Then update with SAHI detections (xyxy format + scores + classes):
results.update(boxes=your_sahi_detections)  # Feed custom detections

The model acts primarily as a tracker container in this case. See the SAHI integration guide for detailed detection conversion steps. For tracker configuration options, check the Ultralytics tracking documentation.

[rahuulbuttaan9]

I have created a yolov8l transfer learned model for tracking cups from one place to another lets say if it passes line then it will be counted and i have used tracker deepsort now issue i am facing is tracker id is not stable and changes when it passes line so prev position of cup is missing and a new tracking id gets assigns which leads to not counting this cup can you help me here i want a tracker or logic to be built so that tracking id does not changes. and frame can have multiple cups at a time.

[glenn-jocher]

@rahuulbuttaan9 for stable tracking IDs with overlapping objects, try adjusting tracker parameters in botsort.yaml or bytetrack.yaml from ultralytics/cfg/trackers. Increase track_buffer to maintain longer track histories and lower track_high_thresh to retain low-confidence detections. Ensure you're using persist=True in your tracking loop as shown in the persisting tracks example.

[rahuulbuttaan9]

Hi Thanx That will be helpful. Also can i use these trackers with yolov8l . I had used deepsort but will move to bytetrack.
I am working on jetson orin nx8

[glenn-jocher]

Yes, you can use YOLOv8l with ByteTrack or BoT-SORT on Jetson Orin NX. All Ultralytics trackers are compatible with YOLOv8 models. For Jetson deployment, we recommend starting with the ByteTrack configuration and adjusting track_buffer (increase) and track_high_thresh (decrease) parameters specifically for your cup-tracking scenario to improve ID stability. The tracking implementation remains the same as shown in our Python examples.

[ssjswaraj]

yolo tracker assign id to object, and it starts with 1,2,3.... i want it to randomly assign ids to the object and then track it. as i want to send its data to lstm but i dont want lstm to depend on the tracking_id number

[glenn-jocher]

@ssjswaraj to use random IDs while maintaining tracking consistency, you can modify the track IDs during post-processing. Here's a concise solution:

import random
from collections import defaultdict

# Generate random IDs for each new track
id_map = defaultdict(lambda: random.randint(1000, 9999))

# In your tracking loop:
results = model.track(frame, persist=True)
track_ids = [id_map[id.item()] for id in results[0].boxes.id]

This preserves tracking consistency while providing arbitrary IDs unrelated to the original sequence. The id_map ensures consistent random IDs across frames. For implementation details, see the Tracking Arguments section in the Ultralytics Track documentation.

[ssjswaraj]

@glenn-jocher Thanks for replying, its a good way to give random number to track_id

[glenn-jocher]

@ssjswaraj thank you for your positive feedback! 😊 We're glad the random ID mapping solution works well for your use case. For those looking to implement similar functionality, the Track mode documentation provides details on working with object IDs in tracking workflows. The YOLO community appreciates your engagement!

Note: Always ensure compliance with AGPL-3.0 license requirements when using Ultralytics software in projects.

[rohith-aiunika]

Hi YOLO Team,
I've been using the following Python script to track objects with my YOLOv8 model:
from ultralytics import YOLO

model = YOLO(r"/home/best_pt_files/v1.0.2.pt")
results = model.track(r"/home/video.MP4", save=False, stream=False)

However, I noticed that my GPU memory usage gradually increases, leading to an "out of memory" error before the video finishes processing.
Interestingly, when I use the following command from the terminal, the entire video tracks successfully without excessive GPU memory consumption:
yolo track model=/home/best_pt_files/1.0.2.pt source=/home/video.MP4

Previously, the Python script worked without any issues. The memory issue has only recently started occurring. Could you please help me understand the possible reasons for this memory increase and how to address it?

i have experimented with persist= True and False,stream = true and false, show = true and false also but the issue is still there

[glenn-jocher]

@rohith-aiunika thanks for reporting this. The memory buildup in Python scripts (but not CLI) typically occurs when not using streaming mode. To match the CLI's memory behavior, modify your Python script to process frames iteratively using stream=True:

from ultralytics import YOLO

model = YOLO("/home/best_pt_files/v1.0.2.pt")
for result in model.track("/home/video.MP4", stream=True):  # Process frames iteratively
    pass  # Add your frame processing logic here

This streams frames sequentially like the CLI, preventing memory accumulation. For more details, see the streaming implementation in our Tracking documentation. Let us know if this resolves the issue!

[rohith-aiunika]

i have used stream = True, then the code is just executing without showing error and without tracking also

[glenn-jocher]

@rohith-aiunika thanks for the update. Let's ensure you're properly iterating through streaming results. Try adding a processing loop like this:

for result in model.track(source=video_path, stream=True):
    annotated_frame = result[0].plot()
    cv2.imshow('Tracking', annotated_frame)
    if cv2.waitKey(1) == ord('q'):
        break

This actively processes each frame and displays tracking annotations. If issues persist, you might need to verify your video source format using our supported inference sources documentation.

[grace-715]

Hi,
I want to detect the objects in my videos and assign Ids to each object as I'm designing a counting algorithm....but when I run the bytetrack tracker only in the results video I do not see tracks or IDs
I would greatly appreciate your help.
Thankyou

[mwasela]

Hello Grace lets see your code. The tracking algorithm is a pretty straight forward, check on model.track()

…

On Mon, Apr 7, 2025 at 9:52 AM grace-715 ***@***.***> wrote: Hi, I want to detect the objects in my videos and assign Ids to each object as I'm designing a counting algorithm....but when I run the bytetrack tracker only in the results video I do not see tracks or IDs I would greatly appreciate your help. Thankyou — Reply to this email directly, view it on GitHub <#7906 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ACXRGWG4ARLRQ3KXQ3FTOJT2YIODDAVCNFSM6AAAAABCROZ3EGVHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTENZUGY3TKOI> . You are receiving this because you were mentioned.Message ID: ***@***.*** com>

-- Regards

[maxexplorer]

Hello!
I'm using YOLO with ByteTrack and processing two separate ROIs (zone1 and zone2) sequentially, both containing the target objects (fish). When processing zone1, the object is detected with high confidence and assigned track_id=1. However, when processing zone2, although the object is also detected with high confidence, its track_id is None.
The issue is that objects in different zones are not tracked simultaneously — tracking works only for one zone at a time. If an object appears in both zone1 and zone2 in the same frame, only the detection in one of the zones receives a valid track_id, while the detection in the other zone is treated as an untracked object.
Interestingly, when there are multiple objects within a single zone, they are correctly assigned unique IDs. The problem only occurs across different zones.
I’m using the default ByteTrack config. Why does this happen, and how can I maintain consistent track_ids across multiple ROIs processed in sequence within the same frame?

Thank you in advance for your help!

[glenn-jocher]

@maxexplorer this issue occurs because tracking in YOLO maintains an internal state for each instance of model.track(). When processing different ROIs sequentially, each call to model.track() gets its own separate tracking context.

To maintain consistent tracking IDs across multiple zones, I recommend:

1. Process the entire frame with tracking first:

   results = model.track(full_frame, persist=True, tracker="bytetrack.yaml")

2. Then filter the results by zone afterward:

   # Filter for zone1
   zone1_boxes = [box for box in results[0].boxes if is_in_zone1(box.xyxy)]
   
   # Filter for zone2
   zone2_boxes = [box for box in results[0].boxes if is_in_zone2(box.xyxy)]

This approach allows the tracker to maintain a single consistent context across your entire frame, preserving IDs for objects that appear in multiple zones.

Alternatively, if you need to process zones separately for other reasons, you could try using a single tracker instance with persistence across both zone processing operations, but this is more complex to implement correctly.

[Ranjith3436]

Hii Guys,I want to know about tracking algorithm, I convert the model to tensorRT format. But it takes some processing time in jetson, without detection 75 FPS with detection it goes to 15-12 FPS. I think the tracking thing process in CPU that may be consumed the time. Do you have any option to run complete model.track algorithm run on GPU. all tracking algorithm also.

[Sea-queue]

Hi,

I'm detecting Herring fish. I've retrained the model with my own data. While using the track model, I was able to twist the bot-track parameters to get pretty good tracking results. However, there is still one issue I don't know why:

The id sometimes skips, from 18 to 20 for example:

0 0.214347 0.639162 0.20562 0.198323 0.937141 18
0 0.366081 0.715878 0.331521 0.22603 0.878951 20

My understanding is the ID-19 might be assigned to a low confidence detection / false positive, so the model ignored it, and it never appeared in the results/plots?

Could you please points out some possibilities?

If I want to count the fish base on the ID, I might just count the total number at the end, instead of relying on the id.

[olefhau]

Hi! I am working on a project where we are using Ultralytics' YOLO implementation with BoT-SORT. There was just a new update that supports the use of ReID, and I am therefore wondering how/and if I can edit the botsort.yaml file to activate ReID functionality. I am using the PyPi package of the repo.

[kyatha]

Suppose I am processing 3 videos and I want the track ids not to reset, to stay continuous in the 3 videos, what parameter changes would you recommend? Second question, for reid, I have enabled it in the botsort.yaml file, does it currently support the use of a custom reid model? I have a custom osnet model and would like to use it with botsort for the reid.