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]

shall i keep pretrained = false or true while training model?
which is better way to train a segmentation model using custom dataset

[glenn-jocher]

@rohith-aiunika for training a segmentation model on a custom dataset, it's generally recommended to start with pretrained=True to leverage existing weights, which can improve convergence and performance.

[btwitsayush]

"I need to determine the length, breadth, and height of an object from an image using YOLO. I'm also allowed to use a LiDAR sensor for depth estimation. Can anyone provide guidance on how to achieve this?

[glenn-jocher]

@btwitsayush to determine the dimensions of an object using YOLO and a LiDAR sensor, you can use YOLO for object detection to get the object's bounding box and the LiDAR sensor for depth estimation. This combination will allow you to calculate the object's length, breadth, and height. For more detailed guidance, consider exploring resources on integrating LiDAR data with computer vision models.

[dulmaaa]

hello, I am using ubuntu 18.04 on jetson nano and i have install ultralytics many2 time ( it returned successful )but i am running the code this "no module found" error. so i use ubuntu 20.04 and my code not running no error please help me

[glenn-jocher]

It seems like there might be an issue with your Python environment or the installation path. Please ensure that the ultralytics package is installed in the same environment where you're running your code. You can verify the installation by running pip show ultralytics to check if it's correctly installed. If the issue persists, consider creating a new virtual environment and reinstalling the package.

[Ranjith3436]

I want where the image really process in inference. torch model(frame). where is that exact line of code. in your import libraries.

[glenn-jocher]

@Ranjith3436 the image processing during inference in the Ultralytics YOLO library occurs in the forward method of the model class. You can explore the source code in the Ultralytics GitHub repository for more details.

[z3lz]

In YOLO's brief history module, after jumping to YOLOV8, it is still YOLOV11. This is an incorrect link. Where is the link to YOLOV8?

[glenn-jocher]

@z3lz thank you for pointing out the incorrect link. You can find the correct link to YOLOv8 in the Ultralytics GitHub repository under the releases section. If you have further questions, feel free to ask here.

[JackEdoubleS]

hi. I would like to integrate yolo into my application which will be for sale. Can I use yolo directly or I need to get any licenses?

[glenn-jocher]

@JackEdoubleS to integrate YOLO into a commercial application, you'll need an Enterprise License. Please visit our Licensing page for more details and to apply.

[maoxiuyuan]

Hello,
Thank you for your excellent contributions to the YOLO series.
I am a student who has benefited from the YOLO model, and I have a question that might be easy for you to answer. Thank you in advance for your help.
I want to download the YOLOv8 model, but I can't find it in your GitHub repository, Ultralytics.
Has YOLOv8 been merged into the YOLOv11 files, which were recently released?

[glenn-jocher]

@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.

[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 bringing this to our attention. It seems there is a link misdirection issue. You can find the YOLOv8 documentation directly at this link. We apologize for any inconvenience and appreciate your patience.

[zlelik]

@glenn-jocher Thanks for a quick reply. I use this link you shared indeed. but this link is generic information and does not contain detailed model output description. Let me describe the problem.

1. I click link you shared: https://docs.ultralytics.com/models/yolov8/. It is YOLOv8 overview page.
2. In this page I found this sentence "See Detection Docs for usage examples". Text "Detection Docs" is a link, which I need.
3. When I click link called "Detection Docs" (https://docs.ultralytics.com/tasks/detect/) then I am redirected to YOLO11 documentation, but not YOLOv8. So, YOLOv8 overview page contains link to YOLO11 detailed documentation, although I would expect YOLOv8 overview page would have a link to YOLOv8 detailed documentation, not to YOLO11 detailed documentation.

[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!

[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!

[FeresJerbi1]

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.