Comprehensive Tutorials for Ultralytics YOLO#

@AashishThakur1321 the default location where Ultralytics models are stored depends on your operating system, but it's typically within a directory in your user's home folder; you can find more specific details by checking the "Settings" section when you run from ultralytics import settings; print(settings).

@kartmyco thank you for your message! While the auto-annotate function currently outputs polygon annotations, you can convert them to rectangular bounding boxes using tools like cvat or labelme, or you can write a custom script to approximate polygons into rectangular boxes. For details on data annotation tools, you can refer to our guide on data collection and annotation. Let us know if you have additional questions!

Hello Glenn, Thank you so much for your reply. I will try to approximate the polygons in rectangular bounding boxes.

@jdonza for detailed information on how YOLO models are created and how CNNs work in relation to YOLO, please refer to our comprehensive guides at https://docs.ultralytics.com/guides/. These resources cover various aspects of YOLO, including its architecture and image processing techniques.

@jdonza hello,

For training YOLOv8 using multiple devices, please refer to our Multi-GPU Training guide. It provides step-by-step instructions to help you set up and run training across multiple GPUs.

Thank you!

Thank you for the response! What I am still confused with is the following line of code.

results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[0, 1])

Here are a few questions I had.

1. I have one GPU on my computer currently. If I had another device that also had the same GPU, how does YOLO know which computer is 0 and which is 1? Is there a physical connection of some sort that needs to occur?
2. If you had a computer with multiple GPU's, the same questions arises. How does YOLO know which is 0 and which is 1?

Overall, I am confused with the set-up steps that need to occur before simply inputting "device=[0,1]".

Sorry if my questions appear trivial. I am a beginner and do not have much experience with network configurations like this!

Thanks!

@jdonza to address your questions:

1. YOLOv8 does not support multi-device training across different computers. Each device ID (e.g., 0, 1) refers to GPUs within the same machine.
2. For a computer with multiple GPUs, device IDs are assigned based on the order in which GPUs are detected by the system. You can verify GPU IDs using nvidia-smi.

For more details, please refer to the Multi-GPU Training guide.

Was this capability eliminated? The link you provided has a drop-down section labeled "Use Multiple Machines" which appears to provide some sort of framework to accomplish this.

@jdonza the capability for multi-machine training is not supported in YOLOv8. The "Use Multiple Machines" section in the documentation you referenced may pertain to older versions or different contexts. For multi-GPU training on a single machine, you can use the device=[0,1] argument. If you have further questions, please refer to the Multi-GPU Training guide.

Okay thank you!

@jdonza you're welcome! For training YOLOv8 on multiple GPUs within a single machine, you can use the device=[0,1] argument. Each GPU is identified by its ID, which you can check using nvidia-smi. Multi-machine training is not supported. For more details, please refer to the Multi-GPU Training guide.

While not supported in YOLOv8, I did see reference to training across multiple computers in the YOLOv5 documentation:

(I believe this is what jdonza was referring to before). Does this allow for training across multiple computers for YOLOv5, but is no longer supported in YOLOv8? If so, would using YOLOv5 instead of v8 be recommended for this use case? Thanks!

Training across multiple computers is supported in YOLOv5 using DistributedDataParallel, but this feature is not available in YOLOv8. If multi-machine training is essential for your use case, using YOLOv5 would be recommended. For more details, please refer to the YOLOv5 documentation.

Hi there! It's great to hear that your food detection project is yielding excellent results! 🎉

To address the issue of overlapping bounding boxes, you can apply Non-Maximum Suppression (NMS) to retain only the highest confidence score detections and remove the overlapping ones. YOLO models typically handle NMS internally, but you can customize the NMS settings during inference to better suit your needs.

Here's how you can do it:

Using Python

If you're running inference in a Python environment, you can set the conf (confidence threshold) and iou (IoU threshold for NMS) parameters when calling the predict method. Here's an example:

from ultralytics import YOLO

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

# Run inference with custom NMS settings
results = model.predict(source='path/to/your/image.jpg', conf=0.25, iou=0.45)

# Display results
results[0].show()

Using CLI

If you're using the command line interface, you can specify these parameters directly in your command:

yolo predict model=path/to/best.pt source='path/to/your/image.jpg' conf=0.25 iou=0.45

Explanation

• conf: This sets the minimum confidence threshold for detections. Detections with a confidence score below this value will be discarded.
• iou: This sets the IoU threshold for NMS. Detections with an IoU greater than this value will be considered overlapping, and only the one with the highest confidence score will be kept.

For more detailed information on inference and NMS settings, you can refer to the YOLO Predict Documentation.

If you encounter any issues or need further assistance, please ensure you're using the latest versions of torch and ultralytics. If the problem persists, providing a minimum reproducible example would be very helpful. You can find guidelines on creating one here: Minimum Reproducible Example.

Happy coding, and best of luck with your project! 🚀

because the goal for now is to remove overlapping, if i set the iou threshold on the high side, the image doesnt differ much from the original detected image, where there are many overlappings. if i set to a low iou threshold, more overlappings will be removed.

another thing is that for my food detection i have 5 classes/categories of food. under these 5 categories i have variety of food for each category, but i label and train the model on these 5 classes, for simplicity sake i did not go into detail about what kind of food is that, lets say meat we have fish, pork etc. the model see either of those and classify as meat. although they are from same classes, they might have different prices. now how can i use segmentation( maybe from opencv) to distinguish the image i used to run inference on my best.pt model to identify the difference in meat like fish, pork to have different prices?

Hi there! Thanks for reaching out and providing detailed feedback on your experience with overlapping bounding boxes in your food detection project. It's fantastic to hear that your detection results are generally great! 🎉

To address the issue of overlapping bounding boxes, adjusting the IoU threshold is indeed a key factor. Here’s a more refined approach to help you achieve the best balance:

Fine-Tuning IoU Threshold

• High IoU Threshold: Retains more overlapping boxes, which might be useful if you want to ensure that no potential detections are missed.
• Low IoU Threshold: Removes more overlapping boxes, which can help in reducing redundancy but might risk missing some detections.

Practical Steps

1. Experiment with Intermediate Values: Instead of setting the IoU threshold to extremes, try intermediate values (e.g., 0.3, 0.4, 0.5) to find a sweet spot that minimizes overlaps without losing important detections.
2. Confidence Threshold: Adjust the confidence threshold (conf) to filter out low-confidence detections, which can also help in reducing overlaps.

Example Code

Here’s how you can apply these settings in Python:

from ultralytics import YOLO

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

# Run inference with custom NMS settings
results = model.predict(source='path/to/your/image.jpg', conf=0.25, iou=0.45)

# Display results
results[0].show()

And using the CLI:

yolo predict model=path/to/best.pt source='path/to/your/image.jpg' conf=0.25 iou=0.45

Additional Resources

For more detailed guidance on optimizing your model and handling common issues, you might find the following guides helpful:

• YOLO Common Issues
• YOLO Performance Metrics

If you continue to experience issues, please ensure you are using the latest versions of torch and ultralytics. If the problem persists, providing a minimum reproducible example would be very helpful. You can find guidelines on creating one here: Minimum Reproducible Example.

Feel free to reach out if you have any more questions or need further assistance. Happy coding! 🚀

another thing is that for my food detection i have 5 classes/categories of food. under these 5 categories i have variety of food for each category, but i label and train the model on these 5 classes, for simplicity sake i did not go into detail about what kind of food is that, lets say meat we have fish, pork etc. the model see either of those and classify as meat. although they are from same classes, they might have different prices. now how can i use segmentation( maybe from opencv) to distinguish the image i used to run inference on my best.pt model to identify the difference in meat like fish, pork to have different prices?

Hi there! It's fantastic to hear about your progress with food detection using YOLO. 😊

To distinguish between different types of food within the same category (like fish and pork under "meat"), you can leverage segmentation techniques. Here's a step-by-step approach to achieve this:

1. Segmentation with OpenCV

You can use OpenCV to perform image segmentation, which will help you isolate different types of food within the same category. Here's a basic example of how you might use OpenCV for segmentation:

import cv2
import numpy as np

# Load the image
image = cv2.imread('path/to/your/image.jpg')

# Convert to grayscale
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Apply GaussianBlur to reduce noise and improve contour detection
blurred = cv2.GaussianBlur(gray, (5, 5), 0)

# Use Canny edge detection
edges = cv2.Canny(blurred, 50, 150)

# Find contours
contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

# Draw contours on the original image
cv2.drawContours(image, contours, -1, (0, 255, 0), 2)

# Display the result
cv2.imshow('Segmented Image', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

2. Combining YOLO Detection with Segmentation

You can combine the bounding boxes from your YOLO model with segmentation to further classify the detected objects. Here’s a conceptual approach:

1. Run YOLO Inference: Use your trained YOLO model to detect the general categories (e.g., meat).
2. Apply Segmentation: Within each detected bounding box, apply segmentation to isolate different types of food.
3. Classify Segmented Regions: Use additional classification models or heuristics to distinguish between types like fish and pork.

3. Advanced Segmentation Techniques

For more precise segmentation, consider using advanced models like Mask R-CNN or leveraging pre-trained segmentation models available in frameworks like PyTorch or TensorFlow.

Example with YOLO and Segmentation

Here’s a more integrated example combining YOLO detection with OpenCV segmentation:

from ultralytics import YOLO
import cv2

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

# Run inference
results = model.predict(source='path/to/your/image.jpg', conf=0.25, iou=0.45)

# Process each detected bounding box
for result in results:
    for box in result.boxes:
        x1, y1, x2, y2 = map(int, box.xyxy[0])
        cropped_img = result.orig_img[y1:y2, x1:x2]

        # Convert to grayscale and apply segmentation
        gray = cv2.cvtColor(cropped_img, cv2.COLOR_BGR2GRAY)
        blurred = cv2.GaussianBlur(gray, (5, 5), 0)
        edges = cv2.Canny(blurred, 50, 150)
        contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
        cv2.drawContours(cropped_img, contours, -1, (0, 255, 0), 2)

        # Display the segmented image
        cv2.imshow('Segmented Image', cropped_img)
        cv2.waitKey(0)

cv2.destroyAllWindows()

Further Reading

For more detailed guides and advanced techniques, you might find these resources helpful:

• Isolating Segmentation Objects
• YOLO Thread-Safe Inference

Feel free to experiment with these techniques and adjust the parameters to better suit your specific use case. If you have any more questions or need further assistance, don't hesitate to ask. Happy coding! 🚀

Hello! The number of epochs needed for training the YOLO base model can vary depending on your specific dataset and the complexity of the task. While 500 epochs might be necessary for some scenarios to achieve optimal results, it's not a strict requirement for all cases.

A good practice is to monitor the training process for signs of convergence, such as stable validation loss and accuracy metrics. You can start with fewer epochs, like 100 or 200, and evaluate the model's performance. If the results are not satisfactory, you can continue training for more epochs or consider adjusting other hyperparameters.

Here's a simple example to start training with a specified number of epochs:

yolo train data=coco128.yaml model=yolo26n.pt epochs=100

Adjust the epochs value as needed based on your observations. Happy training! 😊