index

[giscus[bot]]

index

Explore a complete guide to Ultralytics YOLOv8, a high-speed, high-accuracy object detection & image segmentation model. Installation, prediction, training tutorials and more.

https://docs.ultralytics.com/

[glenn-jocher]

Hey everyone, Glenn here! 🚀

Dive into our comprehensive guide on YOLOv8, the pinnacle of real-time object detection and image segmentation technology. Whether you're just starting out or you're deep into the machine learning world, this page is your go-to resource for installing, predicting, and training with YOLOv8. Got questions or insights?

This is the perfect spot to share your thoughts and learn from others in the community. Let's make the most of YOLOv8 together! 💡👥

[Zulkazeem]

Hello,

I am super new to computer vision, and I want to know if there is a way to isolate the detected texts (like you would isolate in Roboflow, where all the text areas detected will be split) so I can use it better in my text extraction model.

Thank you.

[glenn-jocher]

Hello there! 🌟

Absolutely, you can isolate detected texts with YOLOv8 by following a simple two-step process:

1. Detect Text Regions: First, use YOLOv8 to detect areas in your images that contain text. If you're working with a custom dataset, you might need to train your model to recognize text areas. Here's a quick example on how to predict with a model:

from ultralytics import YOLO

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

# Run detection
results = model('path/to/your/image.jpg')

# results.show()  # To visualize the detections

2. Extract and Process Text Regions: Once you have the bounding boxes for text areas, you can crop these regions from your original image and feed them into your text extraction model.

Here's how you might crop detected regions:

for *xyxy, conf, cls in results.pred[0]:
    # Assuming results.pred[0] contains your detections
    # Crop using PIL or OpenCV here
    pass

This approach allows you to specifically target and extract text regions for further processing. If you need more detailed guidance or have any other questions, feel free to ask!

Happy coding! 🚀

[Zulkazeem]

Hello, I have been trying this for a while but it keep returning an error.this is my code though.
img_path = r"C:\Users\yomid\OneDrive\Desktop\ICR Project\colored_images\400000.png"
import cv2

#pathe to trained model
path_to_model = r"C:\Users\yomid\OneDrive\Desktop\ICR Project\Field-Result-Detection.v5i.yolov8\Trained_Detection_Model.pt"
pred_model = YOLO(path_to_model)
pred = pred_model.predict(source = img_path)

for xyxy, conf, cls in pred.pred[0]:
# Assuming results.pred[0] contains your detections
# xyxy contains the coordinates of the bounding box in the format (xmin, ymin, xmax, ymax)
xmin, ymin, xmax, ymax = xyxy
# Crop the detected object from the image
cropped_object = image[ymin:ymax, xmin:xmax]
# Display the original image and the cropped segment
cv2.imshow("Original Image", image)
cv2.imshow("Cropped Segment", cropped_object)
cv2.waitKey(0) # Wait indefinitely until a key is pressed
cv2.destroyAllWindows() # Close all OpenCV windows after key press

[Zulkazeem]

The error is thus: AttributeError: 'list' object has no attribute 'pred'

[Zulkazeem]

I modified the code as this .
img_path = r"C:\Users\yomid\OneDrive\Desktop\ICR Project\colored_images\400000.png"

#pathe to trained model
path_to_model = r"C:\Users\yomid\OneDrive\Desktop\ICR Project\Field-Result-Detection.v5i.yolov8\Trained_Detection_Model.pt"
pred_model = YOLO(path_to_model)
pred = pred_model.predict(source = img_path)

for r in pred:
img = np.copy(r.orig_img)
img_name = Path(r.path).stem

for ci, c in enumerate(r):
    label = c.names[c.boxes.cls.tolist().pop()]

    b_mask = np.zeros(img.shape[:2], np.uint8)

            # Create contour mask 
    contour = c.masks.xy.pop().astype(np.int32).reshape(-1, 1, 2)
    _ = cv2.drawContours(b_mask, [contour], -1, (255, 255, 255), cv2.FILLED)

    # Isolate object with transparent background
    isolated = np.dstack([img, b_mask])

    # Detection crop
    x1, y1, x2, y2 = c.boxes.xyxy.cpu().numpy().squeeze().astype(np.int32)

    # Save the isolated object into subfolder
    objects_folder = os.path.splitext(seg_img_path)[0]  # Folder to save isolated objects
    create_folder_if_not_exist(objects_folder)
    isolated_object = isolated[y1:y2, x1:x2]
    object_save_path = os.path.join(objects_folder, f"object_{ci}.jpg")
    cv2.imwrite(object_save_path, isolated_object)      
    print(f"Objects isolated and saved from {seg_img_path} into {objects_folder}")

But it keeps saying no detection

[glenn-jocher]

@Zulkazeem hey there! 👋 It looks like your code is almost there, but if you're not getting any detections, there might be a few things to check:

1. Model Confidence: Ensure your model's confidence threshold isn't set too high, which might prevent detections. Try lowering the conf argument in your predict call.

2. Image Path: Double-check the image path to ensure it's correct and the image is accessible.

3. Model Compatibility: Make sure the model you're using is appropriate for the task. If it's trained on a very different dataset or for a different task, it might not perform well on your images.

4. Looping Through Results: The way you're iterating through pred and then r seems a bit off. After calling predict, you should directly access the detections, like so:

results = pred_model.predict(source=img_path)
for result in results:
    for *xyxy, conf, cls in result.pred[0]:
        # Process each detection here

5. Visualization: Before trying to save or further process detections, simply try visualizing them with result.show() to ensure detections are being made.

If you've checked these and still face issues, it might be helpful to share more details or error messages you're encountering. Keep experimenting, and don't hesitate to reach out for more help! 🚀

[Praneeth33]

if i pass the model an image if i want to extract class id and class name from result how can i do that

[98ShufangZheng]

Hello,

You can find relevant information in Ultralytics documentation—working with results.

Please try to check this link and use boxes properties: id and cls, like this :

from ultralytics import YOLO

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

# Run inference on an image
results = model.track('path/to/your/image.jpg')  

# View results
for r in results:
    print(r.boxes.id, r.boxes.cls)  # print the class id and class name

The outcome would be like this as an example :

image 1/1 ...(path to your image)...\meetingRoom.jpg: 448x640 5 persons, 1 tie, 20.9ms
Speed: 8.0ms preprocess, 20.9ms inference, 11.0ms postprocess per image at shape (1, 3, 448, 640)
tensor([1., 2., 3., 4., 5., 6.]) tensor([ 0.,  0.,  0.,  0., 27.,  0.])

where tensor([1., 2., 3., 4., 5., 6.]) is the class ids you've detected, and tensor([ 0., 0., 0., 0., 27., 0.] is their corresponding class names.

Hope it's helpful ! :)

[pderrenger]

@98ShufangZheng hello! 😊

To extract class IDs and names from your results, you can access the cls attribute from the boxes object in your results. Here's a quick example:

from ultralytics import YOLO

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

# Run inference
results = model('path/to/your/image.jpg')

# Extract class IDs and names
for result in results:
    class_ids = result.boxes.cls
    class_names = [model.names[int(cls_id)] for cls_id in class_ids]

    print("Class IDs:", class_ids)
    print("Class Names:", class_names)

This will give you the class IDs and their corresponding names for the detected objects in your image. Hope this helps!

[98ShufangZheng]

This is the outcome, the class names are more direct and clear, which is perfect !

Class IDs: tensor([ 0.,  0.,  0.,  0., 27.,  0., 60., 39., 41., 39.], device='cuda:0')
Class Names: ['person', 'person', 'person', 'person', 'tie', 'person', 'dining table', 'bottle', 'cup', 'bottle']

Thank u a lot ! @pderrenger 🥰

[98ShufangZheng]

Please note that there maybe two interpretations for "class id", which I refer to as object_ids and class_ids respectively. Their explannations are shown in the code block below.

from ultralytics import YOLO

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

# Run inference
results = model.track('meetingRoom.jpg')

# Extract class IDs and names
for r in results:
    # All the results are converted to <list> type for the convenience of further analysis
    object_ids = r.boxes.id.cpu().numpy().tolist()  # Non-repetitive, each object have a specific ID, even they are of the same type of object
    class_ids = r.boxes.cls.cpu().numpy().tolist()  # means which kind of object it is, all the persons detected own a same classID
    class_names = [model.names[int(cls_id)] for cls_id in class_ids]  # the name of that kind of object
    
    print("Object IDs:", object_ids)  # type <class 'list'>
    print("Class IDs:", class_ids)  
    print("Class Names:", class_names)  

It output:

image 1/1 D:\...\meetingRoom.jpg: 448x640 5 persons, 1 tie, 18.0ms
Speed: 9.0ms preprocess, 18.0ms inference, 11.0ms postprocess per image at shape (1, 3, 448, 640)
Object IDs: [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
Class IDs: [0.0, 0.0, 0.0, 0.0, 27.0, 0.0]
Class Names: ['person', 'person', 'person', 'person', 'tie', 'person']

We can see that Object IDs and Class IDs aren't the same. 😉

[pderrenger]

Hey there! 😊

Thanks for reaching out! It looks like you're diving into the details of object and class IDs with YOLOv8, which is awesome. You're right; there's a distinction between object_ids and class_ids. object_ids are unique to each detected object across frames, making them super useful for tracking, while class_ids tell us about the type of object detected (like all persons having the same class ID).

Your code snippet and explanation are spot on! If you're looking to further analyze or work with these IDs, you're already on the right track. Just remember, class_names gives you the human-readable labels for those class_ids, making your results more interpretable.

If you have any more questions or need further clarification, feel free to ask. Happy coding! 🚀

[VandeshSawant]

Hello,
I am a student and I want to find out how YOLO calculates bounding boxes. Is there any good article or documentation where I can find it?

[glenn-jocher]

Hello there! 😊

For understanding how YOLO calculates bounding boxes, I'd recommend starting with the original YOLO paper by Joseph Redmon and Ali Farhadi, which lays the foundation for how bounding boxes are predicted. You can find it here.

Additionally, our Ultralytics YOLOv8 Docs provide a comprehensive overview of YOLOv8, including its architecture and features, which build upon the original YOLO principles for bounding box predictions. While the docs focus on using YOLOv8, the underlying concepts of bounding box prediction remain consistent across versions.

For a quick snippet, YOLO divides the image into a grid and predicts bounding boxes and probabilities for each grid cell. The model applies non-max suppression to refine these boxes.

I hope this helps! If you have more questions, feel free to ask. Happy learning! 🚀

[Zulkazeem]

I tried using result.show() bit it says it has no obect show and using your code, it says list has no object pred.

…

On Sun, Mar 10, 2024, 3:34 AM Glenn Jocher ***@***.***> wrote: @Zulkazeem <https://github.com/Zulkazeem> hey there! 👋 It looks like your code is almost there, but if you're not getting any detections, there might be a few things to check: 1. *Model Confidence:* Ensure your model's confidence threshold isn't set too high, which might prevent detections. Try lowering the conf argument in your predict call. 2. *Image Path:* Double-check the image path to ensure it's correct and the image is accessible. 3. *Model Compatibility:* Make sure the model you're using is appropriate for the task. If it's trained on a very different dataset or for a different task, it might not perform well on your images. 4. *Looping Through Results:* The way you're iterating through pred and then r seems a bit off. After calling predict, you should directly access the detections, like so: results = pred_model.predict(source=img_path)for result in results: for *xyxy, conf, cls in result.pred[0]: # Process each detection here 1. *Visualization:* Before trying to save or further process detections, simply try visualizing them with result.show() to ensure detections are being made. If you've checked these and still face issues, it might be helpful to share more details or error messages you're encountering. Keep experimenting, and don't hesitate to reach out for more help! 🚀 — Reply to this email directly, view it on GitHub <#8012 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ARQRRZCLUDZ4XTCWWM4NNBDYXQEG3AVCNFSM6AAAAABCZBK6B6VHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4DOMZUGA4TK> . You are receiving this because you were mentioned.Message ID: ***@***.*** com>

[glenn-jocher]

@Zulkazeem hey there! It seems like there might be a small mix-up in accessing the results. After running predictions with a YOLO model, the results are stored in a list of Results objects, each corresponding to an input image or frame. To visualize the predictions, you should iterate through this list and call .show() on each Results object. Here's a quick example:

from ultralytics import YOLO

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

# Run predictions
results = model(['path/to/image1.jpg', 'path/to/image2.jpg'])

# Iterate through results and visualize
for result in results:
    result.show()  # This should work!

If you encounter 'list' object has no attribute 'pred', it might be due to directly accessing attributes that exist within each Results object in the list, rather than on the list itself. Make sure you're iterating through the list as shown above. 😊

Let me know if this helps or if you're still facing any issues!

[sxwebster]

Hi,

I'm new to running models myself, and the last time I did any image training was about 15 years ago, though I am a Python veteran. I'd like to try running the building footprint models. Do you have a video series that can take me through setting up YOLOv8 and then running the model to extract footprints?

[glenn-jocher]

@sxwebster hey there!

Welcome back to the world of image training! It's great to have Python veterans like yourself exploring YOLOv8. 😊 While we currently don't have a video series specifically for setting up YOLOv8 to extract building footprints, getting started with YOLOv8 is straightforward, and I'm here to guide you through the key steps.

First, make sure you have Python installed, then install YOLOv8 using pip:

pip install ultralytics

Next, to predict or extract building footprints from images, you can use a pre-trained YOLOv8 model. Here's a simple Python example to get you started:

from ultralytics import YOLO

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

# Perform inference on an image or images
results = model('path/to/your/image.jpg')

# Results contain predictions
results.show()  # Display the image with predictions
results.save()  # Save the image with predictions

Adjust 'path/to/your/model.pt' and 'path/to/your/image.jpg' to your model and image path.

For more detailed instructions on installation, predictions, and even training your model, check out our Get Started section and the Predict on Images page. These guides should provide a solid base for your journey with YOLOv8.

I hope this helps. Feel free to share your progress or any questions you might have. Happy footprint extraction! 🚀

[excellencior]

Hi,
I am need of changing the loss function to "DioU" for some reason. How do I run the model with this modification or any kind of modification?

Can someone please help?

Thanks in advance

[glenn-jocher]

Hey there! 👋

Sure, I'd be happy to guide you on modifying the loss function to use DIoU. For YOLOv8, customizing the loss function involves editing the source code. You can start by locating the loss computation part within the model's code. Typically, you'll find this in the files responsible for model architecture or training routine.

Here's a simplified step you could follow:

1. Navigate to the file that defines the loss computation. This is often in something like a models.py or loss.py file.
2. Look for the section that computes the bounding box loss. It might currently use IoU, GIoU, etc.
3. Replace the existing loss computation with DIoU according to the DIoU formula.

For example, if you find a line like:

loss_box = (1.0 - iou(pred_boxes, target_boxes)).mean()

You might replace it with something like:

loss_box = (1.0 - diou(pred_boxes, target_boxes)).mean()

Assuming diou() is a function you've defined or imported that computes the DIoU loss.

Remember to import or define any necessary functions or libraries you need for DIoU computation.

🚀 It's always exciting to experiment with custom modifications! Be sure to thoroughly test your changes to validate the performance improvements.

Let me know how it goes or if you hit any snags. Happy coding!

P.S. For more detailed instructions on your exact requirement, checking our GitHub or documentation might give you additional insights.

[TeoThanh]

Hi,
I tried to show detection conf with this:
with torch.no_grad():
results=model.predict(source=test_imgs_dir,conf=0.20,iou=0.70, show_conf=True, show_labels=True)
but this doesnt work. How can i fix this

[TeoThanh]

So here is it runs, I tried to change into results[imgs] or results.img and results[img] but it doesnt work

[TeoThanh]

In addition, this is my model

[glenn-jocher]

Hi there! 👋 It looks like you're having some trouble with accessing properties of the results object. To access the images and their corresponding predictions, you should use results.render() for visualizing or results.imgs and results.pred respectively for raw access.

For displaying detection confidences directly on images, the results.show() function should automatically include them if they are present. If you're looking to programmatically access and use confidence scores, here's a quick snippet:

for result in results:
    for (xmin, ymin, xmax, ymax, conf, cls) in result.pred[0]:
        print(f"Confidence: {conf:.2f}")

Please note that result.pred[0] contains the detections for the first image in your batch with each detection in the form of [xmin, ymin, xmax, ymax, confidence, class].

If you're directly manipulating or visualizing the results and need further assistance, don't hesitate to share more details or reach out. We're here to help! 🚀

[TeoThanh]

@glenn-jocher thanks for your help, my code has run as I expected. Big appreciate for you!

[glenn-jocher]

Hey there! 🎉

I'm thrilled to hear that your code is running just as expected. Your kind words mean a lot! If you have any more questions or dive further into YOLOv8, the Ultralytics YOLOv8 Docs are packed with useful information to help you explore the full capabilities of YOLOv8. Happy coding!🚀

[tryprncp]

hi, I'm a student and I'm doing this for my undergraduate thesis. I'm implementing yolov8 model in android gallery's search mechanism. the purpose of yolov8 model is to scan media files and return images that has a bounding box label that matches the search query. i can make it work with yolov5s.torchscript.ptl using org.pytorch:pytorch_android_lite:1.10.0 and org.pytorch:pytorch_android_torchvision_lite:1.10.0 but it wont work with yolov8s.torchscript. the yolov5s.torchscript.ptl has a function to load the model and the classes.txt, is the yolov8 model wont need that?

[pderrenger]

Hi there! I'm glad to hear you're working on integrating YOLOv8 into your thesis project for Android. 🚀 It sounds like an exciting application.

For YOLOv8 models to work similarly to YOLOv5 models in terms of loading with org.pytorch:pytorch_android_lite and using classes.txt, you should ensure that the YOLOv8 model is correctly exported to TorchScript format. YOLOv8 models should indeed be compatible with mobile deployment, including functionality for loading model and class labels, but the process might slightly differ from YOLOv5 due to updates or changes in the model structure or export process.

Here's a quick guide on exporting YOLOv8 models to TorchScript:

from ultralytics import YOLO

# Load your YOLOv8 model
model = YOLO('path/to/yolov8s.pt')  # Or your specific model file

# Export to TorchScript
model.export(format='torchscript', imgsz=[640, 640], simplify=True)  # Specify desired imgsz

After this, you'll have a .torchscript file that you can use in your Android app. Regarding loading classes.txt, the process should be pretty straightforward as it was with YOLOv5, where you manually load the classes into your application and match them with the detection indices the model returns.

If you face specific issues with the YOLOv8 TorchScript model in your application, it would be helpful to know any error messages or behaviors you're encountering. That way, I can provide more targeted advice. Keep up the great work on your thesis! 🎓

[Asshok1]

when i am training yolov8 model i need to store current epoch number to a variable that can be used where ever i want ?
How i can solve this one ?

[pderrenger]

Hi there! 👋 To store the current epoch number during training in a variable that you can use, you'll likely need to modify the training loop in your code. The exact implementation can vary based on how you're running the training, but here's a simplified example on how you might accomplish this:

for epoch in range(total_epochs):
    print(f'Starting Epoch {epoch}')
    current_epoch = epoch
    # Your training logic here

# Now you can use current_epoch anywhere in your code after this point

Keep in mind that if you're using a specific framework or methodology for training (like using a script or a Jupyter notebook), the way you access and use this variable might differ. If you're working directly with the Ultralytics YOLOv8 repository, consider exploring the training script to see where the epoch is iterated and capture it from there.

Hope this helps! Let us know if you have further questions or issues. Happy training! 😊

[Asshok1]

Hey pderrenger I am using a script for training then at that how can I access the current epoch number separately?

[pderrenger]

Hey there! 😊 To access the current epoch number during training in a script, you usually have access to it directly within the training loop. Below is a simple example assuming you're using a loop to iterate through epochs:

for epoch in range(epochs):
    print(f'Current epoch: {epoch}')
    # Your training logic here

In this example, epoch is the variable that holds the current epoch number. You can use it wherever you need inside the loop. If you're working with a more complex setup or the Ultralytics YOLOv8 training script, the principle remains the same - the epoch number is usually iterated in a loop, and you can capture it from there.

Hope that helps! Let me know if there's anything else you're curious about. Happy coding! 🚀

[RudeNinja]

Hey Glenn,
I am trying to evaluate the VisDrone dataset (validation) using model.val() for different models.

However I just wanna obtain the metrics for the lower half of the images. I tried modifying the labels and annotations files of the validation split to contain only those bounding boxes which are in the lower half. However this doesn't seem to work. Any suggestions?
Any help is appreciated...

[RudeNinja]

I observed that the upper half of the image containing people is not getting detected. So ignoring the top half should ideally increase the mAP, P and R but it is not so

[glenn-jocher]

Hey there! Thanks for reaching out with your observation and attempt to focus on the lower half for better model performance. If adjusting the labels to include only the bounding boxes in the lower half didn't yield the expected improvement in metrics, it could be that the model still relies on context from the whole image for its predictions.

A different approach you might consider is manually cropping the images themselves to only include the lower half before passing them to the model.val(). This way, the model has no choice but to focus only on the portion of the image you're interested in. Here's a quick snippet on how you could do this:

from PIL import Image

# Assuming 'image_path' is the path to your validation image
image = Image.open(image_path)
width, height = image.size

# Crop the lower half
image_cropped = image.crop((0, height // 2, width, height))

# Now save or directly use 'image_cropped' for your validation
image_cropped.save('path_to_save_cropped_image')

Make sure to adjust your validation dataset to include these cropped images and then proceed with the usual evaluation process. Let me know if that helps or if you need further assistance!

[casperdias]

Hi, I have a question about the YOLOv8 model. In the pre-trained model, there are labels like "person" and others, but if I create a new model with only the "person" label, will there be a performance difference on my computer between the pre-trained model and the model I create?

[glenn-jocher]

@casperdias hi there! 😊

Great question about the performance differences between the pre-trained YOLOv8 model and a newly created model focusing only on the "person" label. The short answer is: yes, there might be a performance difference, but it largely depends on your specific setup and the dataset size for training the "person" label model.

Creating a model that is specifically trained on the "person" label might perform better for person detection tasks due to its specialization. It could potentially run faster on your computer as the model may become simpler after training on a more focused dataset. However, the extent of performance improvement also depends on the complexity of the scenes you're analyzing and how well the model has been optimized during training.

For the best results, ensure your custom "person" model is thoroughly trained and validated on a diverse and representative dataset of people images. Here's a simplified example of how you might start this training process:

yolo train data=your_custom_person_dataset.yaml model=your_base_model.yaml epochs=100

Remember, the actual performance can vary based on many factors including the hardware of your computer, the specifics of your dataset, and how well the model is tuned. Happy modeling! 🚀

[Nithinpbabu]

In yolo v8.1 I can't find confusion matrix and results.png? Where is it stored?? This is how I started my training:

%cd /kaggle/working/HOME/YOLO_V8_OUTPUT

!yolo train model=yolov8l.pt data=/kaggle/working/HOME/FRUITS_AND_VEGITABLES_NITHIN-6/data.yaml epochs=100 imgsz=640 patience = 10 device=0,1 project=/kaggle/working/HOME/YOLO_V8_OUTPUT

[glenn-jocher]

Hello! 😊

For YOLOv8.1, the confusion matrix and results.png are automatically saved in your specified project directory under a new experiment folder that gets created each time you start a new training session. Based on your command, they should be located in:

/kaggle/working/HOME/YOLO_V8_OUTPUT/exp/

If you've run multiple training sessions, each session's outputs are saved in separate expN directories like exp, exp2, exp3, etc. The highest number corresponds to the most recent training session. Inside, you'll find results.png along with other valuable metrics and visualization files.

If you have any more questions or need further assistance, feel free to ask. Happy training! 🚀

[ajay78123]

I am tasked with developing a shelf management system tailored for a specific brand. This system aims to automate the process of sales personnel visiting stores to assess product stock levels and required replenishments. Utilizing object detection, I intend to accurately count the products on the shelves and inform the salesperson of the quantities needed to refill. One major challenge to address is product occlusion, where items may partially or fully obscure others, complicating accurate counting. I'm particularly interested in exploring how YOLOv8, a popular object detection model, can be employed to tackle this problem effectively. Any guidance or insights on implementing such a solution would be greatly appreciated.

[glenn-jocher]

@ajay78123 absolutely, your project sounds like a great application for YOLOv8! For managing occlusions in a retail environment like shelves, YOLOv8 is quite capable due to its accuracy and efficiency in object detection. Here are a few tips to help you get started:

1. Data Preparation: Gather images of the shelves with your specific brand’s products from various angles and lighting conditions. Annotations should be as precise as possible, especially for partially occluded objects.

2. Training on Custom Dataset: Once you have your annotated dataset, you can train a YOLOv8 model tailored to your needs. Light occlusions are usually manageable by the model if the training data represents these scenarios well.

3. Handling Severe Occlusions: For items heavily occluded, consider strategies like training separate models for different shelf layers or using advanced techniques such as segment or pose estimation tasks supported by YOLOv8, which might give better context on item placements.

Here's a basic example to train your custom model:

yolo train data=your_dataset.yaml model=yolov8n.yaml epochs=100

And for detecting products in an image:

yolo predict model=best.pt source='path/to/your/image.jpg'

It's crucial to iterate on your training data based on initial performance, focusing on cases where the model struggles, especially with occlusions. Engage with the community for shared learnings and consider the Enterprise License if your solution is going commercial. Happy shelving! 🛒

[ajay78123]

Let's say I've trained a model specifically for a single product, and it's performing well. Now, this product is available in 20 different stores, each with varying shelf space. I want to create an interface where users can select a specific store, and the model will predict the product count for that particular shelf in that store. How can we approach this problem? Any ideas or solutions?

[glenn-jocher]

@ajay78123 hey there! 😄 Great to hear your model is doing well. For your scenario with products in different stores, you can approach it by creating a metadata file or database that maps store identifiers to specific shelf configurations. When a user selects a store, the system retrieves the configuration for that store and adjusts the inference parameters accordingly (image crop, resize, etc., depending on how shelf space varies).

Here’s a rough idea using Python and a hypothetical store_config.json:

import json
from ultralytics import YOLO

# Load store configurations
with open('store_config.json') as f:
  store_configs = json.load(f)

def predict_shelf_count(store_id, image_path):
    # Load model
    model = YOLO('path/to/your/model.pt')
    
    # Load store-specific config
    config = store_configs.get(store_id)
    if not config:
        return 'Store configuration not found'
    
    # Adjust model to store config (e.g., imgsz)
    results = model.predict(source=image_path, imgsz=config['imgsz'])
    # Assuming you have post-processing to count items from results
    
    return results  # or your processed count

# Example usage
store_id = 'store_01'
image_path = 'path/to/image.jpg'
count = predict_shelf_count(store_id, image_path)
print(f'Product count for {store_id}:', count)

Your store_config.json could look like this:

{
  "store_01": {"imgsz": 640},
  "store_02": {"imgsz": 480},
  ...
}

Adjust the code & JSON structure based on your actual config data (e.g. shelf areas to focus on). This way, you dynamically adjust model inference based on the store's shelf configurations! 🛍️

[arslansalyana]

Hi @glenn-jocher can you please have a look at this google doc, I have tried to explain the problem through screenshots, i am facing after fine tuning the model, I would really appreciate your kind guidance.

https://docs.google.com/document/d/1WJ5SBdunWSqyd3FjgYgrZn2KjeYxezlel2LeXspmWAQ/edit?usp=sharing

[glenn-jocher]

Hi there! Thanks for reaching out and providing the document with your issue details. Unfortunately, I'm unable to access external documents like Google Docs for security reasons. However, I'd be happy to help right here! Could you please describe the problem you're encountering with your fine-tuned model, or share any error messages or specific issues directly in this thread? This way, I can provide more targeted assistance. Looking forward to your response! 😊

[rohith-aiunika]

Hello team Ultralytics,
I have done object tracking with my custom segmentation model for a video and i am getting the count of objects but is it possible to do object tracking for a set of images in a folder?

[glenn-jocher]

@rohith-aiunika yes, you can perform object tracking on a set of images in a folder using YOLO11. You would need to iterate over each image in the folder and apply the model.track method to process them individually. If you need further guidance on implementing this, please refer to the Ultralytics tracking documentation.

[rohith-aiunika]

I have trained my custom seg model(yolov8-seg m model), i need to track only using that model is it possible?
And i also need to know how it is possible to track at image level without giving video as input
And is it possible to extract timestamp of the video while tracking? assume that meta data of the video is there

[glenn-jocher]

Yes, you can track using your custom YOLOv8 segmentation model. For tracking at the image level, process each image individually in a loop using model.track on a folder of images. To extract timestamps while tracking a video, ensure the video metadata is available and utilize libraries like OpenCV to access this information. For more details, refer to the tracking documentation.

[maoxiuyuan]

Thank you. I got it. The usage of different YOLO models involves loading &nbsp;different yolov(8,11)&nbsp;n.yaml files isn’t it ? 发自我的iPhone

…

------------------ Original ------------------ From: Glenn Jocher ***@***.***&gt; Date: Tue,Nov 19,2024 2:30 AM To: ultralytics/ultralytics ***@***.***&gt; Cc: xiuyuan mao ***@***.***&gt;, Mention ***@***.***&gt; Subject: Re: [ultralytics/ultralytics] index (Discussion #8012) @maoxiuyuan hello, thank you for your question. YOLOv8 has not been merged into YOLOv11 files; they are separate models. You can find YOLOv8 in the Ultralytics repository, and I recommend checking the Ultralytics documentation for instructions on downloading and using YOLOv8 models. If you have further questions, feel free to check the YOLOv8 documentation. — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you were mentioned.Message ID: ***@***.***&gt;

[glenn-jocher]

@maoxiuyuan yes, that's correct. Different YOLO models require loading different YAML files (e.g., yolov8n.yaml for YOLOv8 or yolo11n.yaml for YOLO11) to configure the model architecture and parameters. For detailed guidance, you can refer to the respective model documentation.

[maoxiuyuan]

I’m really appreciate for your reply ,it’s strongly useful for me. 发自我的iPhone

…

------------------ Original ------------------ From: Glenn Jocher ***@***.***&gt; Date: Wed,Nov 20,2024 2:44 AM To: ultralytics/ultralytics ***@***.***&gt; Cc: xiuyuan mao ***@***.***&gt;, Mention ***@***.***&gt; Subject: Re: [ultralytics/ultralytics] index (Discussion #8012) @maoxiuyuan yes, that's correct. Different YOLO models require loading different YAML files (e.g., yolov8n.yaml for YOLOv8 or yolo11n.yaml for YOLO11) to configure the model architecture and parameters. For detailed guidance, you can refer to the respective model documentation. — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you were mentioned.Message ID: ***@***.***&gt;

[glenn-jocher]

@maoxiuyuan thank you for your kind words! The YOLO community and the Ultralytics team work hard to provide useful resources, and it's great to hear they're helpful to you. If you have any further questions or need more information, feel free to ask.

[zlelik]

I want to use YOLO for object detection in the images. Is there ready pre-trained model, which can have many (al least 500) classes (labels) and not the standard COCO model with only 90 classes? Also, I would prefer that model can detect objects in the image of any size.
If yes, which one I can use and is there any examples, preferably with tensorflow.js?

[glenn-jocher]

@zlelik for detecting a large number of classes, you might consider training a custom YOLO11 model on a dataset that meets your class requirements. Ultralytics models can be adapted for diverse tasks beyond the standard COCO dataset. For TensorFlow.js, you can export the trained model to a compatible format like ONNX or TFLite and then convert it to TensorFlow.js using the appropriate tools. For guidance on training and exporting models, refer to the Ultralytics documentation.

[zlelik]

@glenn-jocher
Thank you for your reply.
Do you mean that for YOLO11 there is no any other pre-trained models except pre-trained with COCO dataset?

Also, I found YOLOv8 model trained with Open Image v7 dataset with 600 labels here https://github.com/ultralytics/ultralytics/tree/v8.2.94, but when I run it, it returns so many results (shape [1, 605, 8400]) that I do not know what to do with all these numbers. Is there any description of the output of YOLOv8 model? I run it like this

tensor - my input image.

prediction = model.execute(tensor);

and prediction has a shape = [1, 8400, 605] (5082000 numbers).

[glenn-jocher]

@zlelik for YOLO11, pre-trained models are primarily trained on the COCO dataset. However, Ultralytics YOLO models can be fine-tuned on other datasets to meet specific requirements. Regarding the YOLOv8 model trained with Open Images v7, the output shape you mentioned indicates a prediction for multiple classes and bounding boxes. You can find documentation on interpreting these outputs in the Ultralytics documentation. If you need further details, please refer to the YOLOv8 documentation.

[zlelik]

Thank you for your help. My problem is, that if I go to YOLOv8 page here https://docs.ultralytics.com/models/yolov8/#supported-tasks-and-modes I can download the models, but once I click link "Detection Docs" in the sentence "See Detection Docs for usage examples", then I redirected to YOLO11 documentation and actually I cannot really find YOLOv8 documentation.

…

On Thu, 21 Nov 2024 at 07:06, Glenn Jocher ***@***.***> wrote: @zlelik <https://github.com/zlelik> for YOLO11, pre-trained models are primarily trained on the COCO dataset. However, Ultralytics YOLO models can be fine-tuned on other datasets to meet specific requirements. Regarding the YOLOv8 model trained with Open Images v7, the output shape you mentioned indicates a prediction for multiple classes and bounding boxes. You can find documentation on interpreting these outputs in the Ultralytics documentation. If you need further details, please refer to the YOLOv8 documentation <https://docs.ultralytics.com/models/yolov8/>. — Reply to this email directly, view it on GitHub <#8012 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ADTQ4K6PUOM7OZCCE4EUT4D2BVZ4VAVCNFSM6AAAAABCZBK6B6VHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTCMZTGIZDIMQ> . You are receiving this because you were mentioned.Message ID: ***@***.*** com>

[glenn-jocher]

@zlelik thank you for pointing out the issue with the documentation link. We apologize for the confusion. The "Detection Docs" link should ideally lead to the YOLOv8-specific detection documentation. We'll work on updating the links to ensure they direct to the correct pages. Meanwhile, you can refer to the YOLOv8-specific details directly in the YOLOv8 documentation. If you have any further questions, please let us know!

[zlelik]

Finally, I found an example which works with YOLOv8 and model trained on Open Images v7 with 600 labels. This is the link: https://github.com/asouqi/yolo-tfjs
specifically, this function preprocessImage here https://github.com/asouqi/yolo-tfjs for image preprocessing and this function getPredictionData here https://github.com/asouqi/yolo-tfjs/blob/master/src/yolo/YoloV8.ts were very useful.

[glenn-jocher]

Thank you for sharing those references! While we focus on supporting the official Ultralytics repository, it's great to hear you've found useful resources like yolo-tfjs. For official YOLOv8 guidance, I recommend exploring our documentation at Ultralytics Docs and GitHub repository. Let us know if you need further assistance!

[zlelik]

This was the problem. The official documentation does not cover this :(

[glenn-jocher]

@zlelik thank you for your feedback. The official documentation does aim to be comprehensive, but gaps can occasionally occur. We'll forward your concerns about missing details for YOLOv8 to the appropriate team to improve the resource. In the meantime, feel free to explore the YOLOv8 documentation, and let us know if you need further assistance.

[MKaczkow]

Hi,

I believe there is a link misdirection in Datasets. After clicking on ImageNet in the docs I am getting redirected to https://docs.ultralytics.com/classify/imagenet/, which results in HTTP 404 Not Found error. The page itself can be found at https://docs.ultralytics.com/datasets/classify/imagenet/, so it seems /datasets part is missing. The same holds for all datasets link.

[glenn-jocher]

@MKaczkow thank you for bringing this to our attention! It indeed seems like a URL issue in the documentation. We will look into this and align the links to the correct paths. Please stay updated, and you can check back soon for fixes. If you need further assistance, don't hesitate to ask!

[mobin3399]

Is it possible to train YOLO segmentation models using the Cityscapes dataset?

[glenn-jocher]

@mobin3399 yes, YOLO segmentation models can be trained on the Cityscapes dataset, but you will need to convert the dataset into the YOLO segmentation format. Tools like JSON2YOLO can assist with this process. Once in the correct format, you can train the model using the commands provided in the segmentation task documentation. Let us know if you need further details!

[mobin3399]

Thank you for your explanation🙏. I followed the steps you mentioned, but the evaluation parameters were very low.

[glenn-jocher]

If your evaluation parameters are low, consider troubleshooting by ensuring your data preparation is correct (e.g., dataset format, annotations), fine-tuning hyperparameters (e.g., learning rate, batch size), and verifying model configuration. You can also validate your dataset using tools like Roboflow to catch any potential issues. Let us know if you encounter specific errors!

[JerbiFeres]

Hey everyone,

I encountered a situation where I have only 1 instance, and I get the YOLO results as follows:
Precision = 0.9522
Recall = 1
F1 score = 0.9755
mAP@50 = 0.995
mAP@50-95 = 0.2985
How come Precision is 0.95 instead of 1, given that I only have one instance? Could the background class generated by the YOLO model affect the calculation of Precision when there is only one instance in the test data?

[glenn-jocher]

@FeresJerbi1 the Precision value of 0.9522 instead of 1 could result from false positives in the inference, even with only one true instance. YOLO models may predict additional objects (background or noise) that don't match the ground truth, reducing Precision. Background predictions shouldn't directly influence Precision but can indirectly affect it if interpreted as object predictions. For more on evaluation metrics, refer to the Ultralytics YOLO Performance Metrics guide.

[wdcs-yashpadariya]

Hello,
We are trying to log trained yolov8 model using mlflow.pyfunc.log_model() in .pt format but mlflow does not support .pt format for logging.
We want to log the trained model and after register and deploy the model.
If we use default function of mlflow for logging .pt model it gives error that model should be in torch.nn.Module format for .pt extension.

Is there any method that we can log .pt file of yolo model in mlflow?

[glenn-jocher]

@wdcs-yashpadariya to log a YOLO model in MLflow, you can export the trained .pt model to a compatible format such as ONNX or TorchScript, which MLflow supports. Use the model.export() method in the Ultralytics library to convert your model, and then log the exported format with MLflow. For more details, explore the Export Documentation. Let us know if you need further clarification!

[wdcs-yashpadariya]

But the thing is, it is mandatory for us to use .pt format while deployment due to it's performance on gpu.
Is there any solution for logging .pt models only in mlflow?

[glenn-jocher]

Unfortunately, MLflow does not natively support logging .pt files directly. A workaround is to wrap your .pt model in a torch.nn.Module or export it to a supported format like TorchScript or ONNX using the model.export() method. This allows you to utilize MLflow's logging and deployment capabilities effectively. You can refer to the Export Documentation for guidance. Let us know if you need further assistance!

[rohith-aiunika]

Understanding YOLOv8 Coordinates in Label Files
Hi YOLO Team,

I have a question regarding the YOLOv8 annotation format:

1. How does YOLO provide coordinates in the label file after annotating an image?
2. Do these coordinates change if the resolution of the image changes?
   I'm asking to better understand how the format handles different image sizes and how annotations remain consistent.

Thank you for your help!

[glenn-jocher]

@rohith-aiunika thank you for your question! YOLOv8 annotations use normalized coordinates (class x_center y_center width height) relative to the image dimensions, ensuring annotations remain consistent across varying resolutions. If the image resolution changes, these normalized values adapt automatically to maintain proportionality. Additional details can be found in the Ultralytics dataset format guide. Let me know if you need further clarification!

[rohith-aiunika]

Hi YOLO Team,

I have a few questions regarding the YOLOv8 annotation format:

1. As per my understanding, YOLOv8 annotations in the label files for segmentation follow this format:
   <class_id> <x_center> <y_center> ...
   Can you confirm if this is correct?

2. If the image resolution changes, do the coordinates in YOLOv8 label files also change accordingly?

3. If the coordinates are resolution-dependent, is this behavior specific to YOLO formats (e.g., YOLOv8, YOLOv11, etc.), or does it apply to other formats like COCO as well?

4. Is there any annotation format where the coordinates remain unaffected by changes in image resolution?

5. If there is any format where the coordinates remain unaffected by changes in image resolution, then do we have annotation converters from that format to yolov8 or yolov11

Understanding this would greatly help in handling different formats and ensuring annotation consistency across my projects.

Thank you for your insights!

[glenn-jocher]

@rohith-aiunika 1) Yes, YOLOv8 segmentation annotations follow the format you mentioned, where <class_id> <x_center> <y_center> <width> <height> defines the bounding box, and <x1> <y1> ... <xn> <yn> lists the segmentation points.
2) The coordinates in YOLOv8 label files are normalized (0-1 range), so they scale proportionally with changes in image resolution.
3) This normalization behavior is not exclusive to YOLO formats and is common in other formats like COCO.
4) Absolute coordinate formats (e.g., pixel-based) remain unaffected by resolution changes but are less common.
5) Ultralytics tools provide converters for formats like COCO to YOLO for compatibility. For details, see the Dataset Conversion Guide.

[wdcs-fenilpatel]

Process Process-14:
Traceback (most recent call last):
File "/usr/lib/python3.10/multiprocessing/process.py", line 314, in _bootstrap
self.run()
File "/usr/lib/python3.10/multiprocessing/process.py", line 108, in run
self._target(*self._args, **self._kwargs)
File "./api/management/commands/start_process.py", line 1028, in start_sub_process_with_chunks
File "./api/management/commands/start_process.py", line 158, in wrapper
File "./api/management/commands/start_process.py", line 705, in process_frames
File "./api/process/common.py", line 149, in wrapper
File "./api/process/common.py", line 340, in get_results
File "/home/serverudh/spotem/environment/spenv/lib/python3.10/site-packages/ultralytics/engine/model.py", line 176, in call
return self.predict(source, stream, **kwargs)
File "/home/serverudh/spotem/environment/spenv/lib/python3.10/site-packages/ultralytics/engine/model.py", line 560, in predict
self.predictor.setup_model(model=self.model, verbose=is_cli)
File "/home/serverudh/spotem/environment/spenv/lib/python3.10/site-packages/ultralytics/engine/predictor.py", line 303, in setup_model
self.model = AutoBackend(
File "/home/serverudh/spotem/environment/spenv/lib/python3.10/site-packages/torch/utils/_contextlib.py", line 116, in decorate_context
return func(*args, **kwargs)
File "/home/serverudh/spotem/environment/spenv/lib/python3.10/site-packages/ultralytics/nn/autobackend.py", line 144, in init
model = model.fuse(verbose=verbose)
File "/home/serverudh/spotem/environment/spenv/lib/python3.10/site-packages/ultralytics/nn/tasks.py", line 202, in fuse
delattr(m, "bn") # remove batchnorm
File "/home/serverudh/spotem/environment/spenv/lib/python3.10/site-packages/torch/nn/modules/module.py", line 2040, in delattr
super().delattr(name)
AttributeError: bn

Facing this error when i try to run multiprocessing.

[wdcs-fenilpatel]

def load_yolo_model(model_path,task="detect"):
    """Load YOLO model, disable BN fusion, and share parameters across processes."""
    model = YOLO(model_path, task=task)  # Load YOLO model
    model.model.fuse(False)  # Disable BatchNorm fusion

    # Move parameters & buffers to shared memory
    for param in model.model.parameters():
        param.share_memory_()
    for buffer in model.model.buffers():
        buffer.share_memory_()
    
    return model

Thank you very much for ur help. The above code after applying ur suggestions seems to be working fine but getting such warnings:

W0000 00:00:1740986771.293425 3724550 inference_feedback_manager.cc:114] Feedback manager requires a model with a single signature inference. Disabling support for feedback tensors.
W0000 00:00:1740986771.298023 3724549 inference_feedback_manager.cc:114] Feedback manager requires a model with a single signature inference. Disabling support for feedback tensors.
I0000 00:00:1740986773.059318 3724734 gl_context_egl.cc:85] Successfully initialized EGL. Major : 1 Minor: 5
I0000 00:00:1740986773.070225 3724755 gl_context.cc:369] GL version: 3.2 (OpenGL ES 3.2 NVIDIA 550.120), renderer: NVIDIA GeForce RTX 4090/PCIe/SSE2
W0000 00:00:1740986773.077550 3724740 inference_feedback_manager.cc:114] Feedback manager requires a model with a single signature inference. Disabling support for feedback tensors.
W0000 00:00:1740986773.084582 3724749 inference_feedback_manager.cc:114] Feedback manager requires a model with a single signature inference. Disabling support for feedback tensors.
I0000 00:00:1740986773.688000 3724875 gl_context_egl.cc:85] Successfully initialized EGL. Major : 1 Minor: 5
I0000 00:00:1740986773.698287 3724892 gl_context.cc:369] GL version: 3.2 (OpenGL ES 3.2 NVIDIA 550.120), renderer: NVIDIA GeForce RTX 4090/PCIe/SSE2
I0000 00:00:1740986773.703063 3724862 gl_context_egl.cc:85] Successfully initialized EGL. Major : 1 Minor: 5
W0000 00:00:1740986773.704720 3724880 inference_feedback_manager.cc:114] Feedback manager requires a model with a single signature inference. Disabling support for feedback tensors.
I0000 00:00:1740986773.712858 3724909 gl_context.cc:369] GL version: 3.2 (OpenGL ES 3.2 NVIDIA 550.120), renderer: NVIDIA GeForce RTX 4090/PCIe/SSE2
W0000 00:00:1740986773.714054 3724881 inference_feedback_manager.cc:114] Feedback manager requires a model with a single signature inference. Disabling support for feedback tensors.
I0000 00:00:1740986773.717615 3724863 gl_context_egl.cc:85] Successfully initialized EGL. Major : 1 Minor: 5
I0000 00:00:1740986773.724890 3724926 gl_context.cc:369] GL version: 3.2 (OpenGL ES 3.2 NVIDIA 550.120), renderer: NVIDIA GeForce RTX 4090/PCIe/SSE2
W0000 00:00:1740986773.737482 3724910 inference_feedback_manager.cc:114] Feedback manager requires a model with a single signature inference. Disabling support for feedback tensors.
W0000 00:00:1740986773.738889 3724895 inference_feedback_manager.cc:114] Feedback manager requires a model with a single signature inference. Disabling support for feedback tensors.
W0000 00:00:1740986773.745254 3724916 inference_feedback_manager.cc:114] Feedback manager requires a model with a single signature inference. Disabling support for feedback tensors.
W0000 00:00:1740986773.745275 3724908 inference_feedback_manager.cc:114] Feedback manager requires a model with a single signature inference. Disabling support for feedback tensors.
I0000 00:00:1740986774.878841 3724969 gl_context_egl.cc:85] Successfully initialized EGL. Major : 1 Minor: 5
I0000 00:00:1740986774.888439 3724986 gl_context.cc:369] GL version: 3.2 (OpenGL ES 3.2 NVIDIA 550.120), renderer: NVIDIA GeForce RTX 4090/PCIe/SSE2
W0000 00:00:1740986774.904579 3724972 inference_feedback_manager.cc:114] Feedback manager requires a model with a single signature inference. Disabling support for feedback tensors.
W0000 00:00:1740986774.910415 3724982 inference_feedback_manager.cc:114] Feedback manager requires a model with a single signature inference. Disabling support for feedback tensors.
I0000 00:00:1740986776.286674 3725025 gl_context_egl.cc:85] Successfully initialized EGL. Major : 1 Minor: 5
I0000 00:00:1740986776.298933 3725042 gl_context.cc:369] GL version: 3.2 (OpenGL ES 3.2 NVIDIA 550.120), renderer: NVIDIA GeForce RTX 4090/PCIe/SSE2
I0000 00:00:1740986776.305809 3725024 gl_context_egl.cc:85] Successfully initialized EGL. Major : 1 Minor: 5
I0000 00:00:1740986776.315849 3725063 gl_context.cc:369] GL version: 3.2 (OpenGL ES 3.2 NVIDIA 550.120), renderer: NVIDIA GeForce RTX 4090/PCIe/SSE2
I0000 00:00:1740986776.321162 3725023 gl_context_egl.cc:85] Successfully initialized EGL. Major : 1 Minor: 5
W0000 00:00:1740986776.322326 3725028 inference_feedback_manager.cc:114] Feedback manager requires a model with a single signature inference. Disabling support for feedback tensors.
W0000 00:00:1740986776.324572 3725047 inference_feedback_manager.cc:114] Feedback manager requires a model with a single signature inference. Disabling support for feedback tensors.
I0000 00:00:1740986776.331299 3725080 gl_context.cc:369] GL version: 3.2 (OpenGL ES 3.2 NVIDIA 550.120), renderer: NVIDIA GeForce RTX 4090/PCIe/SSE2
W0000 00:00:1740986776.331835 3725054 inference_feedback_manager.cc:114] Feedback manager requires a model with a single signature inference. Disabling support for feedback tensors.
W0000 00:00:1740986776.341032 3725034 inference_feedback_manager.cc:114] Feedback manager requires a model with a single signature inference. Disabling support for feedback tensors.
W0000 00:00:1740986776.354264 3725066 inference_feedback_manager.cc:114] Feedback manager requires a model with a single signature inference. Disabling support for feedback tensors.
W0000 00:00:1740986776.360466 3725076 inference_feedback_manager.cc:114] Feedback manager requires a model with a single signature inference. Disabling support for feedback tensors.
I0000 00:00:1740986776.995503 3725100 gl_context_egl.cc:85] Successfully initialized EGL. Major : 1 Minor: 5
I0000 00:00:1740986777.005481 3725117 gl_context.cc:369] GL version: 3.2 (OpenGL ES 3.2 NVIDIA 550.120), renderer: NVIDIA GeForce RTX 4090/PCIe/SSE2
W0000 00:00:1740986777.011906 3725102 inference_feedback_manager.cc:114] Feedback manager requires a model with a single signature inference. Disabling support for feedback tensors.
W0000 00:00:1740986777.016557 3725103 inference_feedback_manager.cc:114] Feedback manager requires a model with a single signature inference. Disabling support for feedback tensors.
I0000 00:00:1740986778.740281 3725331 gl_context_egl.cc:85] Successfully initialized

[wdcs-fenilpatel]

@glenn-jocher

[glenn-jocher]

These warnings appear related to NVIDIA's inference feedback manager and OpenGL contexts, not directly to your YOLO model implementation. They're typically benign and can be safely ignored if your application is functioning correctly. To suppress them, you could try setting environment variables to reduce TensorRT/OpenGL logging verbosity before initializing your processes:

import os
os.environ["GLOG_minloglevel"] = "2"  # Suppress TensorRT INFO messages
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"  # Reduce TensorFlow logging

If performance remains unaffected, these warnings don't indicate critical issues. For further troubleshooting, see the YOLO Common Issues guide.

[wdcs-fenilpatel]

You're right, I reviewed my code and can confirm the issue isn't on the YOLO side. Everything is working fine with shared memory, just as it did before. I really appreciate your support and the time you've dedicated to helping me.

[glenn-jocher]

Great to hear everything's working now! For future questions, feel free to open a new GitHub issue or join our Ultralytics Discord community. Happy coding with YOLO!

[gauravcodes08]

could you please help me i used this for my yolov8 infrencing its works good and consume gpu but my cpu is jumped to 9 to 10 percent is it possile to make it between 2 to 5 percent cpu optimization

class YOLOVideoProcessor:

def init(self, video_path, new_model, use_tracking=True):

self.cap = cv2.VideoCapture(video_path)

self.model = YOLO(new_model).to(torch.device("cuda"))

print(self.model.names,"+++++++++")

# self.use_tracking = use_tracking # Toggle for tracking

# if self.use_tracking:

# self.tracker = Sort() # Initialize tracker if tracking is enabled

# print("Model classes:", self.model.names)

def process_video(self):

while True:

ret, frame = self.cap.read()

if not ret:

break

frame = cv2.resize(frame, (640, 480))

detections = self.model.predict(frame, iou=0.5)[0]

# dets = []

# Process detections

for row in detections.boxes.data.tolist():

a1, b1, a2, b2 = map(int, row[:4]) # Bounding box

conf = row[4] # Confidence score

cls_id = int(row[5])

print(cls_id) # Class ID

# if cls_id == 0: # Only process specific class (e.g., 0)

# dets.append([a1, b1, a2, b2, conf])

[glenn-jocher]

@gauravcodes08 to optimize CPU usage during YOLOv8 inference while maintaining GPU utilization, consider these steps:

1. Use Ultralytics native streaming instead of OpenCV for video processing. Replace your custom loop with:

model.predict(source='video.mp4', stream=True)  # Direct video input

This leverages optimized Ultralytics video pipelines shown in our Predict documentation.

2. Enable half-precision inference by adding half=True to your predict call, reducing both GPU memory and CPU overhead.

3. Minimize CPU-bound operations like manual frame resizing (YOLO auto-resizes) and remove print statements from your detection loop.

These optimizations typically reduce CPU usage while maintaining performance. For complete implementation details, see our Video Processing Guide.

[allenjones]

The "Quick Start Guide: Raspberry Pi with Ultralytics YOLO11" (https://docs.ultralytics.com/guides/raspberry-pi/) has instructions for setting up Ultralytics on the Raspberry Pi either by using Docker or without using Docker. If I follow the instructions for installing Ultralytics without using Docker, it fails the install process with a "resolution-too-deep" error when I do the "pip install ultralytics[export]" step. This problem was first reported by Dave294448 in the comments of https://core-electronics.com.au/guides/raspberry-pi/getting-started-with-yolo-object-and-animal-recognition-on-the-raspberry-pi/ back on May 3. Various people tried to help him solve the problem, but the best that anyone could offer was to do
pip install "ultralytics[export]<8.1.0". That at least installs, but there is some functionality that is missing, like the ability to use YOLO11. The comments on that page seemed to indicate that the page's author was sure that Ultralytics knew about the problem and would fix it soon, but the fact that no solution has been provided makes me wonder if anyone ever told Ultralytics about the problem. Is this a problem that Ultralytics is aware of? Any idea when we might see a solution?

[daiswe]

Hello, Ultralytics Team

Is it possible to correct the inference workflow to output binary mask instead of polygon?
Or is there any alternative still using polygon format but can represent objects with occlusions?

Thanks in advance.

[glenn-jocher]

Yes — you can use the segmentation mask tensor directly with results[0].masks.data instead of results[0].masks.xy; polygon contours are simplified outlines and won’t reliably preserve holes or heavy occlusions, so for that case a binary mask, or converting the mask to COCO-style RLE in post-processing, is the better option. Please keep docs questions here in Discussions so the Ultralytics team can see them, and the Predict mode docs and Segmentation docs show the available outputs.