tasks/detect/

[giscus[bot]]

tasks/detect/

Official documentation for YOLOv8 by Ultralytics. Learn how to train, validate, predict and export models in various formats. Including detailed performance stats.

https://docs.ultralytics.com/tasks/detect/

[Cheterizzin]

Will color differences in similar objects have an effect? For example, I created a model using black horse data and I will use it for white horses detection

[pderrenger]

Hey there! 🌟

Color differences can indeed affect the performance of your model, especially if it was trained on data that significantly differs in color from the data it's being used to detect. In your case, training on black horses and detecting white horses might pose some challenges due to the color contrast.

However, YOLO models are quite robust and can generalize well if trained with a diverse dataset. If you're seeing issues, consider augmenting your training dataset with images of horses in various colors, lighting conditions, and backgrounds. This can help improve the model's ability to detect horses regardless of their color.

Here's a quick example of how you might augment your data using Python:

from torchvision.transforms import ColorJitter
from PIL import Image

# Load your image
image = Image.open('path/to/your/horse/image.jpg')

# Apply color jitter augmentation
augmented_image = ColorJitter(brightness=0.5, contrast=0.5, saturation=0.5, hue=0.5)(image)

augmented_image.save('path/to/save/augmented_image.jpg')

This code snippet randomly changes the brightness, contrast, saturation, and hue of the image, which could help your model generalize better to different horse colors.

Hope this helps! Let us know if you have any more questions. Happy detecting! 🐎

[sh3mmy]

I've finished trained my v8 detection model and i wanted to used a 3d camera (intel Realsense d435) to do inference on live data and then find the XYZ of the the centroid of the object boundary box in reference to the camera origin. How would i do this?

[pderrenger]

Hey, thanks for reaching out and experimenting with the code! 🌟 It looks like there's some confusion regarding accessing the detection confidence. The error you encountered is due to trying to access an index that doesn’t exist in the detection tensor.

In YOLOv8, the confidence score is actually at det[4], not det[3]. The correct line of code to get xmin, ymin, xmax, ymax, and confidence is:

xmin, ymin, xmax, ymax, conf = map(int, det[:4].tolist() + [det[4]])

The structure for each detection det typically is [xmin, ymin, xmax, ymax, confidence, ...]. Make sure that when accessing elements, the correct indices are used according to the structure returned by your model's prediction.

If you're using a custom structure or have further processed the detection output, make sure to adjust the indices accordingly. Feel free to share more details if you keep running into issues, and we'd be happy to dive deeper into this. Keep up the great work! 💪

[shy0625]

but did you ran it by yourself? actually, I just copied and ran it and got that error : )

[shy0625]

@tomershukhman shared the same error ('det[4] is out of bounds') on Mar 14

[tiffanytgr]

if we want to use a live camera, will converting the images to grayscale, then labelling them and training them in grayscale help to reduce inference time?

[pderrenger]

Hi there! 👋

Thank you for your question. Converting images to grayscale and training a YOLO model on grayscale images can indeed reduce the computational load, potentially speeding up inference time. However, this approach comes with trade-offs:

Pros:

1. Reduced Computational Load: Grayscale images have only one channel compared to three in RGB, which can reduce the amount of data the model needs to process.
2. Faster Inference: With less data to process, the model can run faster, which is beneficial for real-time applications.

Cons:

1. Loss of Information: Grayscale images lack color information, which can be crucial for distinguishing between certain objects. This might lead to a decrease in detection accuracy.
2. Model Training: The model might need to be retrained on grayscale images to adapt to the new input format, which can be time-consuming.

Implementation:

If you decide to proceed with grayscale images, you can convert your images to grayscale before feeding them into the model. Here’s a quick example of how you can do this in Python:

import cv2
from ultralytics import YOLO

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

# Capture video from the camera
cap = cv2.VideoCapture(0)

while True:
    ret, frame = cap.read()
    if not ret:
        break

    # Convert the frame to grayscale
    gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # Run YOLOv8 inference
    results = model(gray_frame)

    # Display the results
    cv2.imshow('YOLOv8 Inference', results[0].plot())

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

cap.release()
cv2.destroyAllWindows()

Conclusion:

While converting to grayscale can speed up inference, it's essential to weigh the potential loss in detection accuracy. If color information is not critical for your application, this approach might be beneficial. Otherwise, consider optimizing other aspects of your pipeline for better performance.

Feel free to experiment and see what works best for your specific use case. If you encounter any issues or have further questions, don't hesitate to ask! 😊

[tumitoto007]

So is there a way to 'lock on' one particular detected object? Say I have the yolov8 detected 10 objects, my program then go through these objects and determine one particular object I want to do a 'lock' on it. Is there a way I can use yolov8 from that point to ignore the rest of the detected objects and just keep tracking/locking on the particular object I want? Thanks in advance.

[glenn-jocher]

@tumitoto007 hey there! 👋

Absolutely, you can focus on a specific detected object with YOLOv8. After detecting objects, you can filter out the one you're interested in based on its class, confidence score, or any custom criteria you define. Once identified, you can track this object across frames.

Here's a quick example on how you might do this:

from ultralytics import YOLO

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

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

# Assuming you've identified your object of interest as the first detected object
object_of_interest = results.boxes[0]

# Now, you can track this object in subsequent frames
# For tracking, you might need to implement or use a tracking algorithm

For continuous tracking, you'd typically integrate a tracking algorithm that takes the initial detection as input and follows the object in subsequent video frames. YOLOv8 can detect objects in each frame, and your tracker can help maintain the identity of the object of interest.

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

[tumitoto007]

It looks like I can not tell Yolov8 to stop other detections and just focus/locking on a particular detected object in real-time. Yes, it seems that a different tracking/locking algorithm needs to be in place for locking before I am done with it. I sure wish Yolov could have this ability to do so, I guess I can put this in a wish list.... Thanks for your reply.

[pderrenger]

Hey there! 😊

I understand you're looking for a way to focus or lock on a specific detected object in real-time with YOLOv8. Currently, YOLOv8 excels in detecting multiple objects simultaneously but doesn't natively support locking onto a single object through its detection phase.

For your use case, integrating a tracking algorithm post-detection could be a viable solution. You might consider using the tracking capabilities provided by YOLOv8, such as with the track mode, which can help maintain the identity of objects across frames. Here's a quick example on how you might set it up:

yolo track model=yolov8n.pt source='path/to/video.mp4'

This approach allows you to keep track of specific objects once they're detected. Adding a feature to lock onto a single object directly within YOLOv8 is indeed an interesting idea for our wishlist! 🌟

Thanks for your suggestion, and we always appreciate feedback that can help improve YOLOv8. Let us know if you have any more questions or ideas!

[tumitoto007]

Yes, thank you for your suggestion. I realized the tracking option in Yolov8 is there but still, it tracks multiple instead of just one. My program still needs filter logic to catch what I wanted. I am not sure how Yolov internal works but I presume excluding object by tracking ID will be much more faster than my python filtering logic...anyway, there will be a ton of applications can use the locking facility if provided, I sincerely wish you all can put this into you upcoming enhancements. Thanks for the reply.

[pderrenger]

Hello! Thank you for sharing your thoughts and suggestions regarding the tracking feature in YOLOv8. 🌟

Indeed, the current tracking implementation provides multiple object tracking capabilities. However, I understand your requirement for a more focused tracking approach, possibly tracking a single object or filtering based on specific criteria.

While we continuously work on enhancing YOLOv8's features, including tracking, your suggestion for a "locking" mechanism to track specific objects is quite interesting and could indeed be beneficial for various applications. I'll make sure to relay your feedback to our development team for consideration in our roadmap of upcoming enhancements. 🚀

In the meantime, for a more immediate solution, you might consider using the tracking IDs returned by the tracker to filter out the desired object in your Python code. Here's a quick example of how you might implement such filtering:

from ultralytics import YOLO

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

# Run tracking on your video/source
results = model.track('path/to/your/video.mp4')

# Assuming you want to track the object with ID = 1
desired_track_id = 1

# Filter results for your desired object
filtered_results = [res for res in results if res.boxes.id == desired_track_id]

# Now, `filtered_results` will only contain the frames and data for your desired object

This approach allows you to leverage the existing tracking IDs to focus on specific objects, albeit through post-processing.

Thank you again for your valuable feedback, and please stay tuned for future updates! If you have any more questions or suggestions, feel free to reach out. Happy coding! 😊

[Abhinav-Singh-Bisht]

Hey I am very much confused with the overall working of the YOLO model . I mean like when we say each cell is responsible for predicting an image what it actually means in terms of workflow and like what is the concept of anchor boxes like what do you mean by predefined anchor boxes.

What i understand is that we have a image like (480,480,3) we finally convert it to like (7,7,30) by passing through convolutional layers / activation layers / pooiling layers . Assuming we divided it into 7 * 7 grid and for each cell we have a structure like lets say one anchor box x,y,w,h,conf,classess) but it is all prediction right ? we didnt defined anything so what does predefined anchor boxes mean?

Also want to know one thing how are we suppossed to do transfer learning in object detection i dont get it .
Transfer learning what i know is lets say for image classification there is a feature extractor + classifier so in transfer learning we use pre -trained feature extractor like vgg16 and then create our own classifier and in case of fine tuning we even train few layers of feature extractor.

But how do we use transfer-learning in object detection i still don get it ? how is it divided into different stages ? Also in this doc for training yolov8 on custom dataset we are training all the layers which isnt transfer learning right and training all layers on a very small dataset wouldnt make sense right ?

Can you please please please clear my confusion and share some updated/latest resources which could help me with this . I really need help in this.

[glenn-jocher]

Hey there! 😊 Let's try to clear up some of the confusion around YOLO and transfer learning in object detection.

1. YOLO Cells & Anchor Boxes:

   • In YOLO, the image is divided into a grid (e.g., 7x7). Each cell in the grid predicts bounding boxes and their corresponding class probabilities. The idea is that each cell is responsible for predicting objects whose center falls within it.
   • Anchor boxes are predefined bounding boxes of certain heights and widths that are designed to capture the scale and aspect ratio of specific object classes. During training, each cell learns to adjust these anchor boxes to fit the actual objects in the image.

2. Transfer Learning in Object Detection:

   • Similar to image classification, transfer learning in object detection involves using a pre-trained model (like YOLO) and fine-tuning it on your custom dataset. The pre-trained model has learned features from a large dataset that can be useful across many tasks.
   • In YOLO, the feature extractor part (backbone) is pre-trained, and you can fine-tune the entire model or parts of it on your dataset. This is beneficial because the model has already learned a good representation of various features, which can be a great starting point for detecting objects in a new dataset.

3. Training on a Small Dataset:

   • When training on a small dataset, it's crucial to leverage transfer learning to avoid overfitting. By starting with a model pre-trained on a large dataset (like COCO), you're not starting from scratch. Instead, you're adapting a model that already understands a lot about images to work on your specific task.
   • Fine-tuning a few layers or even the entire model (depending on your dataset size and similarity to the original dataset) can be very effective. The key is to use a lower learning rate and potentially freeze some of the earlier layers.

For training YOLOv8 on a custom dataset, you're indeed leveraging transfer learning by starting with a model pre-trained on COCO and then training it further on your dataset. This approach is beneficial even for small datasets because the model has already learned a significant amount of information about various objects, which helps in better generalization.

For more detailed guidance, the Ultralytics YOLO documentation is a great resource. It covers everything from training to exporting models, and it's constantly updated with the latest information.

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

[Abhinav-Singh-Bisht]

Hey, thanks a lot for this explanation but like i still have doubts so

1. What does pre-defined anchor boxes mean is it like we already have ax,ay,aw,ah i.e points and widht , height hard-coded values for each cell ? and then in the network that 7730 contains just the tx,ty,tw,th using which calculate the bx,by,bw,bh by a formula something like bx = ax + etx something likw this and then we use mean squarred error to calculate loss for bounding box regression and also for classes we have another loss function and then we combine these loss function and using a optimizer we then optimize the weights of our model ?

2. Transfer learning what i assume is difference from fine-tuning as we just change the last layers in classification it is last connected layers after feature extraction and maybe for object detection it would be connected layers for bbox + classification in yolo while in faster-rcnn there are 2 different netowrks .

While fine-tuning would to even train some of the feature -extraction layers too ?

3. Also like how do i improve model for my custom dataset ? and like how am i doing transfer learning here in this case ? because what as per the doc we are doing is training the whole pre-trained model with a low -learning rate i suppose but what if i have very very small data wouldnt it be better just to train the last layers just like classification i.e just training the bbox+classification layers with a low learning rate ? and like how do i do that can i check the model.summary() and where can i see these pre-defined anchor boxes and i suppose these are even created using k-means clustering ig based on the ground-truth boxes i suppose ?

How can i freeze the feature -extraction layers lets say Darknet-53 and then train rest of the layers and like how are anchor boxes being pre-defined how do i get that and also how do i know the functioning of these bbox + classification layers are these fully -connected nn or convolutional layers or something else ?

[glenn-jocher]

Hey there! 🌟 Let's dive into your questions:

1. Pre-defined Anchor Boxes:

   • Yes, pre-defined anchor boxes are essentially preset width and height values that help the model predict bounding boxes more accurately. During training, the model learns to adjust these pre-defined boxes to match the actual objects. The formula you mentioned is on the right track, where bx = ax + etx adjusts the anchor box based on the model's predictions.

2. Transfer Learning vs. Fine-Tuning:

   • You've got it! Transfer learning often involves using the pre-trained weights of a model and modifying the last few layers for your specific task. Fine-tuning goes a step further by also adjusting weights in earlier layers. In object detection, this could mean adjusting both the feature extraction layers and the layers responsible for predicting bounding boxes and classes.

3. Improving Model Performance on Custom Dataset:

   • For a very small dataset, focusing on training the last layers (bounding box regression and classification layers) can indeed be beneficial. You can achieve this by freezing the earlier layers (feature extraction) and only training the later ones. This approach helps prevent overfitting.
   • To see the model architecture, including pre-defined anchor boxes, you might use tools like Netron for visualizing ONNX models or TensorFlow's model.summary() for TF models. Pre-defined anchor boxes are usually determined based on common object sizes in the training dataset and can be adjusted for custom datasets.

For freezing layers and focusing on the last layers, you can modify the training script to set the requires_grad attribute of the parameters in the feature extraction layers to False. This prevents them from being updated during training. Here's a quick example for a PyTorch model:

for param in model.backbone.parameters():
    param.requires_grad = False

This code snippet freezes the backbone (feature extractor) of the model, allowing you to focus on training the rest.

Anchor boxes are indeed often determined using clustering techniques like k-means on the ground truth bounding boxes to capture the most common shapes and sizes.

For more detailed guidance and the latest resources, the Ultralytics YOLO documentation is a fantastic place to start. It's packed with tutorials, examples, and explanations that can help clarify these concepts further. Happy modeling! 🚀

[Abhinav-Singh-Bisht]

hey @glenn-jocher thanks you very much for spending so much time on clearing my doubts it really means a lot. And yes most of my confusion is clear thanks to you. Have also joined the discord community so will try to ask doubts there to .
Just one last question sorry.
Like if i want to do this transfer learning for YOLOv8 than can it be done rather than fine-tuning ? If yes can you share resources for the same ?

[glenn-jocher]

Hey! 🤗 I'm super glad to hear that your doubts are clearing up and it's awesome you've joined our Discord community. Always feel free to drop your questions there too!

Regarding your question on transfer learning for YOLOv8 as opposed to fine-tuning: Yes, it's entirely possible and often a great approach, especially when working with a small dataset or aiming to adapt the model to a new domain. Transfer learning in this context means taking a pre-trained YOLOv8 model (like yolov8n.pt) and further training it on your specific dataset, which can involve adjusting the final layers and possibly some mid-level features depending on your requirements and dataset similarity.

For resources, our docs include training YOLOv8 on a custom dataset, which inherently leverages the concept of transfer learning by utilizing pre-trained weights. You might particularly focus on the sections about adjusting the learning rate and fine-tuning the model to fit your data better.

For a more targeted approach on just the last layers (like you might see in classification tasks), the workflow slightly differs in object detection due to the complex output structure (bounding box + classification). But, starting with yolo detect train using a pre-trained model and a custom dataset is straight on the path of transfer learning. To focus more on the concept of fine-tuning only specific parts, you might consider manually adjusting the model architecture in code to freeze early layers or look into advanced tutorials within the community, like those found in our Discord or GitHub discussions.

Hope this helps! And remember, there's no such thing as too many questions; we're all learning together! 😊

[tomershukhman]

Hi,
I would like to know what is the best way to access a box coordinates,
I saw this snippent in the comments here but I don't see how that works (and it failes why i tested it)

for det in results[0].boxes.xyxy:
    xmin, ymin, xmax, ymax, conf = map(int, det[:4].tolist() + [det[4]])

xyxy in 1,4 dimensional and therefor det[4] is out of bounds.

what i did manage to get working but it feels convoluted since I am using [0] so many times for such a short code is

from ultralytics import YOLO
import cv2

model = YOLO('./runs/detect/train/weights/best.pt')
result = model('tennis.jpg')
for result in result[0].boxes.numpy():
    xyxy = result.xyxy[0]
    x1, y1, x2, y2 = map(float, xyxy)
    cls = int(result.cls[0])
    conf = float(result.conf[0])
    print("x1: ", x1, "y1: ", y1, "x2: ", x2, "y2: ", y2, "cls: ", cls, "conf: ", conf)

[glenn-jocher]

Hey there! 👋

It looks like there's a bit of confusion regarding accessing box coordinates from the results. Your approach is almost there, but let me clarify a bit to help you out.

When you're working with the results from a YOLO model prediction, you can access the bounding box coordinates directly from the results object. Here's a simplified way to do it:

from ultralytics import YOLO

# Load your model
model = YOLO('path/to/your/model.pt')  # For example, 'yolov8n.pt'
# Run prediction
results = model('path/to/your/image.jpg')

# Now, iterate over detected objects
for det in results[0].boxes:
    # det is now a single detection with attributes you can directly access
    xmin, ymin, xmax, ymax = det.xyxy[0]  # Coordinates
    conf = det.conf  # Confidence
    cls = det.cls  # Class ID
    print(f"Box coordinates: {xmin}, {ymin}, {xmax}, {ymax}, Confidence: {conf}, Class ID: {cls}")

This way, you're directly accessing the attributes of each detection without needing to index [0] multiple times or manually map the values. The results[0].boxes gives you a structured way to iterate over each detection and access its properties like xyxy (for coordinates), conf (for confidence), and cls (for class ID).

Hope this helps clear things up! If you have any more questions, feel free to ask. Happy coding! 😊

[tomershukhman]

Alrighty, we are almost there.
The output for the code you provided (modifying the relavent vars) is
Box coordinates: 317.3462829589844, 242.7781982421875, 356.83758544921875, 282.7698669433594, Confidence: tensor([0.9921]), Class ID: tensor([13.])
Notice that the cls and id are tensor objects
so I modified the code to be as below and now it prints as I wanted.

`from ultralytics import YOLO
import cv2

model = YOLO('./runs/detect/train/weights/best.pt')
results = model('tennis.jpg')
for det in results[0].boxes:
# det is now a single detection with attributes you can directly access
xmin, ymin, xmax, ymax = det.xyxy[0] # Coordinates
conf = det.conf[0] # Confidence
cls = det.cls[0] # Class ID
print(f"Box coordinates: {xmin}, {ymin}, {xmax}, {ymax}, Confidence: {conf}, Class ID: {cls}")
`

I do still have a question which bother me (sorry if it's a complete nobby question)
If det represent a single box detaction and a box geometrically has 4 uniqe coordinates then why are we accessing those coordinates with [0], that would indicat that det.xyxy has a list of coordinates sets.
same goes for conf, we should have a single confidence score for a box

[glenn-jocher]

@tomershukhman hey there! 😊 It looks like you've made great progress and have a keen eye for detail. Regarding your question about why det.xyxy and other attributes like det.conf seem to be accessed with [0], it's because these attributes are returned as tensors, often with an extra dimension to support batch processing. Even for a single detection, the output maintains this structure for consistency.

In your case, when you access det.xyxy[0], you're effectively unpacking the tensor to get the coordinates of the bounding box. Similarly, for det.conf[0] and det.cls[0], you're accessing the first (and in this context, only) element of the tensor, which holds the confidence score and class ID, respectively.

Your modified code snippet correctly accesses these values for a single detection. Here's a slightly refined version for clarity:

from ultralytics import YOLO

model = YOLO('./runs/detect/train/weights/best.pt')
results = model('tennis.jpg')
for det in results[0].boxes:
    xmin, ymin, xmax, ymax = det.xyxy[0].tolist()  # Convert tensor to list for easier handling
    conf = det.conf.item()  # Get Python number from tensor
    cls = det.cls.item()  # Get Python number from tensor
    print(f"Box coordinates: {xmin}, {ymin}, {xmax}, {ymax}, Confidence: {conf}, Class ID: {cls}")

This version uses .tolist() for the coordinates and .item() for confidence and class ID, making it clear that you're working with individual values, not tensors. This should make the code a bit more intuitive and maintain the efficiency of your approach.

And no worries about asking questions, no matter how basic they might seem! We're all here to learn and help each other out. Keep up the great work! 🚀

[tomershukhman]

Great tnx.
Then let me ask an additional more intreseting question.

I want to identify complex processes, like tracking the entire events leading to the crash. It's not just about recognizing a crashed the car. I know the basic approach involves gathering crash images, labeling them, and training the model. However, I'm looking for insights on how to capture the dynamics of a crash effectively.

[glenn-jocher]

Hey there! 🌟

For capturing the dynamics of a crash effectively, beyond just recognizing a crashed car, you're venturing into the realm of action recognition and event prediction. This is indeed a more complex task than static object detection. Here are a couple of insights:

1. Temporal Aspect: Consider incorporating video data that captures the sequence leading up to a crash. This allows your model to learn not just from static frames but from the progression of events.

2. Model Choice: Look into models that are designed for action recognition or temporal sequence learning. While YOLO is excellent for object detection, models like RNNs, LSTMs, or 3D CNNs might be more suited for understanding sequences and predicting events over time.

3. Data Annotation: Annotate your video data to include not just the crash itself but also the events leading up to it. This might involve labeling frames or sequences that precede the crash, indicating risky behaviors or conditions that typically lead to a crash.

4. Feature Engineering: Consider extracting features that are indicative of a crash happening, such as sudden changes in speed, erratic movements, or proximity to other objects. These features can be crucial for your model to predict a crash before it happens.

5. Simulation and Synthetic Data: Generating synthetic data through simulations can help model various crash scenarios and conditions that might be hard to capture through real-world data alone.

Here's a simple example of how you might start to approach this with YOLO for detecting potential precursors to a crash:

from ultralytics import YOLO

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

# Predict on a video
results = model.track('path/to/crash_video.mp4')

# Analyze the results for potential crash precursors
# This is a simplified example. In practice, you'd need a more complex analysis.
for frame_results in results:
    for det in frame_results.boxes:
        if det.cls == 'car' and det.conf > 0.5:
            # Check for conditions indicative of a crash risk
            print(f"Potential risk detected at frame {frame_results.frame_id}")

Remember, this is a complex task that might require combining multiple models and approaches. Good luck, and feel free to reach out if you have more questions! 🚀

[tryprncp]

hi, im implementing yolov8 in my android gallery's search algorithm. the yolov8's purpose is to scan media files and return images that has a box label that matches the search query. i can make it work using yolov5s.torchscript.ptl with org.pytorch:pytorch_android_lite:1.10.0 and org.pytorch:pytorch_android_torchvision_lite:1.10.0 but i cant make it work with yolov8s.torchscript

[glenn-jocher]

@tryprncp hey there! 😊 It sounds like you're making great strides with implementing YOLOv5 on Android and looking to upgrade to YOLOv8. Awesome choice!

If you're experiencing troubles moving from YOLOv5s to YOLOv8s TorchScript, here are a couple of things you might want to check:

1. Ensure you're using the latest PyTorch Android dependencies, as updates might have been released that better support the newer YOLOv8 models.
2. Try exporting the YOLOv8 model again with the optimize flag set to True, as this might help with compatibility:

   from ultralytics import YOLO
   model = YOLO('yolov8s.pt')
   model.export(format='torchscript', optimize=True)

3. Check for any TorchScript export or loading error messages. They can often point towards what might be going wrong.

If these steps don't solve the issue, could you provide more details on the error message or behavior you're encountering when trying to use the YOLOv8s TorchScript model?

Keep on exploring and building, and don't hesitate to reach out if you have more questions or need further assistance!

[MeqdadDev]

Can you provide me with the best configurations for human-detection example using YOLOv8?

[pderrenger]

@MeqdadDev absolutely, happy to help with setting up your human detection configuration using YOLOv8! 🚀

For a human detection task, I'd suggest starting with one of the pretrained YOLOv8 Detect models, like yolov8n.pt for efficiency or yolov8l.pt and yolov8x.pt for higher accuracy. These models are pretrained on the COCO dataset, which includes human class among others.

Here's a concise example of how to load a pretrained model and train it on your specific dataset tailored for human detection:

from ultralytics import YOLO

# Assuming you have a custom dataset in YOLO format with human annotations
# Load a pretrained model
model = YOLO('yolov8n.pt')  # or 'yolov8l.pt'/'yolov8x.pt' for better accuracy

# Train the model on your dataset for human detection
results = model.train(data='your_dataset.yaml', epochs=100, imgsz=640)

Make sure your dataset is annotated properly and the your_dataset.yaml is configured correctly to point to your training and validation data paths. For fine-tuning parameters like epochs or imgsz, adjust them according to your computational resources and desired accuracy-speed trade-off.

Feel free to reach out if you need further assistance. Best of luck with your human detection project! 🙌

[mudassir659]

how to reduce predicted bounding box line width in yolov8

[glenn-jocher]

Hello there! 😊 To reduce the line width of the predicted bounding boxes in YOLOv8, you can use the line_thickness argument when you plot or show your results. Here's how you can adjust it in your Python code:

from ultralytics import YOLO

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

# Run predictions
results = model('https://ultralytics.com/images/bus.jpg')

# Plot results with a custom bounding box line thickness
results[0].plot(line_thickness=1)  # Adjust line_thickness as needed
results[0].show()

For CLI, the line thickness is automatically adjusted for optimal viewing experience and currently, there isn't a direct CLI argument to alter it. However, modifying the source code or using the Python API as illustrated above are good alternatives. 🛠️

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

[arifan-instrumentasi-UB]

Hi, can yolov8 detect color sequence?. i create color sequence of rainbow (red, yellow, green) as a real rainbow. if i change the yellow to orange, can yolov8 detect it as a wrong rainbow?

[glenn-jocher]

@arifan-instrumentasi-UB hi there! 🌈

YOLOv8 is primarily designed for detecting objects and their categories, rather than the sequence or color composition of objects. It can recognize objects (like a rainbow) based on the training data it has been exposed to, but it doesn't inherently understand the "correct" color sequence of a natural rainbow.

However, you could approach the problem creatively by training your model on labeled data specifying "correct" and "incorrect" rainbows. Here’s a simplified example of how your training annotations might look:

• Image 1 (correct rainbow): Class label “rainbow_correct”
• Image 2 (rainbow with yellow replaced by orange): Class label “rainbow_incorrect”

This way, YOLOv8 could potentially learn to distinguish between the different types of rainbows based on your specific definitions of "correct" and "incorrect."

Remember, accurate detection relies heavily on the diversity and quality of the training dataset. 📊

Hope that helps!

[Vinrub]

i need a object detection code using yolov8 for detect the two images

[glenn-jocher]

@Vinrub hey there! For object detection with YOLOv8, here's a simple script to help you detect objects in two images. Assuming you have YOLOv8 installed and set up:

from ultralytics import YOLO

# Load YOLOv8 model
model = YOLO('yolov8n.pt')  # Here we're using the YOLOv8n model

# Run detection on images
results1 = model('path/to/your/first/image.jpg')
results2 = model('path/to/your/second/image.jpg')

# You can view or save the results
results1.show()  # View the first image with detections
results2.show()  # View the second image with detections

# Or save them to files
results1.save('path/to/save/first/image')  
results2.save('path/to/save/second/image')  

This script loads the YOLOv8 model, runs it on two images, and then displays and saves the results. Don't forget to replace 'path/to/your/first/image.jpg' and 'path/to/your/second/image.jpg' with your actual image paths. Hope this helps! 🚀

[Vinrub]

here is my code import cv2
from ultralytics import YOLO

Load the YOLO model

model = YOLO('yolov8n.pt') # Assuming 'yolov8n.pt' is the YOLO model you want to use

Specify the path to your image

image_path = '/media/XavierSSD250/22_08_23/ui.png'

Perform object detection

results = model(image_path)

Convert image to OpenCV format

image = cv2.imread(image_path)

Extract bounding boxes, labels, and confidence scores from results

bboxes = results.pred[0][:, :4] # Extract bounding boxes
labels = results.names # Extract labels
confidences = results.pred[0][:, 4] # Extract confidence scores

Draw bounding boxes and labels on the image

for bbox, label, confidence in zip(bboxes, labels, confidences):
bbox = bbox.astype(int)
cv2.rectangle(image, (bbox[0], bbox[1]), (bbox[2], bbox[3]), (0, 255, 0), 2)
cv2.putText(image, f'{label}: {confidence:.2f}', (bbox[0], bbox[1] - 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

Show the image with bounding boxes

cv2.imshow('Object Detection', image)
cv2.waitKey(0)
cv2.destroyAllWindows()
the error is Traceback (most recent call last):
File "frames5.py", line 17, in
bboxes = results.pred[0][:, :4] # Extract bounding boxes
AttributeError: 'list' object has no attribute 'pred'

[glenn-jocher]

Hi there! It looks like you're encountering an issue while trying to extract bounding boxes, labels, and confidence scores from your results. The results object has been updated, so you'll want to access these attributes a bit differently.

To extract bounding boxes, labels, and confidences from your object detection results, you can use the .xyxy[0] for bounding boxes, .names for label names, and index into .pred[0] for confidence scores, like so:

# Corrected way to extract information
bboxes = results.xyxy[0]  # xyxy format bounding boxes
labels = [results.names[int(cls)] for cls in results.pred[0][:, 5]]
confidences = results.pred[0][:, 4]  # Extract confidence scores

# Now, you iterate like this to draw your bounding boxes and put text
for *xyxy, conf, cls in results.xyxy[0]:
    label = results.names[int(cls)]
    xyxy = [int(x) for x in xyxy]  # Convert tensor to int
    cv2.rectangle(image, (xyxy[0], xyxy[1]), (xyxy[2], xyxy[3]), (0, 255, 0), 2)
    cv2.putText(image, f'{label}: {conf:.2f}', (xyxy[0], xyxy[1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

cv2.imshow('Object Detection', image)
cv2.waitKey(0)
cv2.destroyAllWindows()

This should resolve the AttributeError you're experiencing. 😊 Let us know if you need more help!

[Vinrub]

i got the same kind of error only

[glenn-jocher]

@Vinrub hey there! 🙌 If you're seeing an AttributeError similar to this when trying to extract bounding boxes or other details from your detections, it seems there might be a slight mix-up in the way you're accessing the results object.

Make sure you're using the updated way to access the bounding boxes and other properties. Here's a quick snippet to guide you:

# Assuming 'results' is your detection result
bboxes = results.xyxy[0]  # Get bounding boxes in xyxy format
# Loop through detections and print out details
for det in bboxes:
    bbox = det[:4].numpy().astype(int)  # Convert bbox to numpy array and then to integer
    conf = det[4].item()  # Get the confidence
    label = results.names[int(det[5])]  # Get the label

    print(f"BBox: {bbox}, Confidence: {conf}, Label: {label}")

If you need more detailed assistance or are looking for something specific, don't hesitate to check out the Object Detection section in the Ultralytics docs. It's packed with useful tips! 😊

[dolfMo]

I am a beginner and have trained an object detection model using my own dataset. If I want to display the results of detection inference in real-time on the web, which method would be better if you recommend?

[pderrenger]

Hey there! 😃 Thanks for reaching out with your questions. I'm here to help clarify things for you!

1. Model choice with modified YAML: The choice between n, s, l, etc., versions of pretraining weights largely depends on the balance you seek between speed and accuracy for your project. If your modified YAML is similar in complexity to the original yolov8n.yaml, starting with yolov8n.pt might make sense. For more complex modifications, l or x versions could provide a better starting point. It's often a good idea to experiment with a couple of versions to see which performs best for your specific dataset and task.

2. Getting detected category names: After running a prediction, you can access the names of detected categories using the names attribute of the Results object in conjunction with the detected class IDs. For example:

   results = model('your_image.jpg')
   for det in results.boxes:  # assuming detection result is stored in results
       print(results.names[det.cls])  # Print detected class name

3. Loading pretrained weights for a custom model: You're on the right track with specifying the pretrained model file along with your custom YAML. This approach leverages the pretrained weights effectively while customizing other aspects of the model. Your code snippet for training is spot-on for this:

   model = YOLO('./models/yolov8l.pt')
   model.train(data='./custom.yaml', epochs=300)

   This code loads the yolov8l.pt pretrained weights and applies them for training with settings and dataset specified in custom.yaml.

And no need to apologize for asking questions—that's what we're here for! If anything remains unclear or you have further inquiries, feel free to reach out. Wishing you success on your project! 🌟

[dolfMo]

Hello😊! I would like to know the information on data processing for the input training image data in YOLOv8's detection task, including preprocessing, feature extraction, etc., or where can I obtain it? And what are the corresponding codes?

[pderrenger]

Hello! 😊 It's great to hear you're diving into YOLOv8's detection tasks! For the preprocessing and feature extraction used in YOLOv8's detection, these processes are inherently part of the model's design, optimizing input images for the best detection performance.

When you load a YOLOv8 model like yolov8n.pt, yolov8s.pt, yolov8l.pt, etc., preprocessing steps such as resizing images to the model size, normalization, and potentially augmentations are executed. Feature extraction is handled by the model's architecture, leveraging layers optimized for detecting objects within various scenes.

To use pretrained weights with your modified YAML, select a version (n, s, l, etc.) that aligns with your performance and complexity requirements. Typically, n (nano) is fastest but least accurate, while x (extra large) is most accurate but slowest. If your modifications are minor, starting with a version closest in size to your alterations might work best.

To get the currently detected categories from prediction results, you can access the names attribute alongside detected class IDs. Here's a quick example:

results = model('your_image.jpg')
detected_names = [model.names[i] for i in results.boxes.cls]
print(detected_names)

To load pretrained weights for training on your custom dataset with YOLOv8-custom.yaml, you've got the right approach. You specify your dataset in the YAML and load the pretrained weights as the starting point:

from ultralytics import YOLO

# Assuming you are using YOLOv8 large model as pretrained weights
model = YOLO('yolov8l.pt')
model.train(data='YOLOv8-custom.yaml', epochs=300)

Ensuring you're correctly specifying your custom dataset and chosen pretrained model will streamline the training process, leveraging the power of YOLOv8 effectively. Thanks for your interest, and don't hesitate to reach out with more questions!

[dolfMo]

apologize for my poor English🥹,I am using translation software to talk you,what I want to express is what data preprocessing process will be carried out after training the image data input network to enhance the model's ability. and then where can I find the corresponding function for the operation?

[pderrenger]

Hello! 😊 No worries at all about your English; you're doing just fine. And yes, YOLOv8 does incorporate several preprocessing steps to enhance model performance during training. These typically include:

• Resizing: Images are resized to the model's input dimensions (e.g., 640x640 for YOLOv8n).
• Normalization: Pixel values might be normalized to aid in the training process.
• Data Augmentation: Techniques like flipping, scaling, or cropping are applied to increase dataset diversity.

To locate the specific functions for these operations in the YOLOv8 GitHub repository, you might want to look into the datasets module, where data loading and preprocessing are handled.

For obtaining the name of the detected category, after you've run your prediction like so:

results = model('your_image.jpg')

You can access the names using:

for det in results.boxes:
    print(results.names[det.cls])  # This prints the detected class names

When looking to use pretrained weights (yolov8n.pt, yolov8s.pt, yolov8l.pt, etc.) for training a model defined in a custom YAML, you do this right at the model creation step. The code snippet you've mentioned already does that effectively:

from ultralytics import YOLO

model = YOLO('yolov8l.pt')  # Using YOLOv8l pretrained weights
model.train(data='./custom.yaml', epochs=300)  # Assuming custom.yaml is your dataset and model configuration

Here, custom.yaml should contain the model configuration tailored for your specific needs along with the dataset information.

Hope these details help streamline your YOLOv8 journey! Feel free to explore further and reach out if you've got more questions. Happy coding! 🚀

[LizBeansprout]

Hi, at the moment I'm trying to used .onnx exported from yolov8n.pt in Unity, using C#, to demonstrate real-time object detection in 3D scene, I got output in the shape of (1,84,8400). I would like to ask how to post process this output to draw bounding box, extracting the information of the output or the output format. Sorry for my english, and if there are any better method please suggest right away. thank you in advance.

[pderrenger]

Hello! Great to hear you're integrating the YOLOv8n model into Unity for 3D object detection. 🚀 The output shape (1, 84, 8400) you mentioned typically contains the detected bounding boxes, object class probabilities, and confidence scores.

To draw bounding boxes, you need to process this output. Generally, the steps involve:

1. Reshaping: The output tensor usually needs reshaping to separate out each attribute (x, y coordinates, width, height, confidence, class scores).

2. Applying a threshold: Filter out detections based on a confidence threshold.

3. Non-maximum suppression (NMS): This removes overlapping bounding boxes, keeping the one with the highest confidence.

Here's a basic guideline in C# (assuming you can translate the logic):

float confThreshold = 0.5f; // Set your confidence threshold
foreach (var detection in detections) {
    float score = detection[4]; // Assuming the 5th element is confidence
    if (score > confThreshold) {
        float x = detection[0];
        float y = detection[1];
        float width = detection[2];
        float height = detection[3];
        // Draw bounding box: Use Unity's drawing utilities or custom rendering
    }
}

Note: Implementation specifics might vary based on how you're processing the output in Unity and the exact output format of your ONNX model.

Also, consider diving into the ONNX Runtime C# documentation for more insights on handling ONNX models in C# environments.

Keep experimenting, and don't hesitate to ask if you have more questions. Your English is just fine, and your pioneering effort in Unity is impressive! 🌟

[dov84d]

Hi there,
May I ask why the default detection conf is 0.25?
In case of Yolov5 it make sense since we have objectness and 0.5*0.5=0.25, but in Yolov8 we don't have objectness, so a reasonable threshold won't be 0.5?

Thanks!

[pderrenger]

@dov84d hi there,

Thank you for your insightful question! The default confidence threshold of 0.25 in YOLOv8 is indeed a carefully chosen value to balance precision and recall. While YOLOv8 does not use an explicit objectness score like YOLOv5, the confidence threshold still plays a crucial role in filtering out low-confidence detections, ensuring that the model outputs are both accurate and reliable.

Setting the threshold to 0.25 helps in capturing more potential objects, which can be particularly useful in scenarios where missing an object is more critical than having a few false positives. However, this value is not set in stone and can be adjusted based on your specific use case and the desired trade-off between precision and recall.

If you find that a higher threshold, such as 0.5, works better for your application, you can easily modify it in your inference settings. Here's an example of how you can adjust the confidence threshold in Python:

from ultralytics import YOLO

# Load a model
model = YOLO("yolov8n.pt")

# Predict with a custom confidence threshold
results = model.predict(source="path/to/your/image.jpg", conf=0.5)

Or via the CLI:

yolo detect predict model=yolov8n.pt source='path/to/your/image.jpg' conf=0.5

Feel free to experiment with different values to find the optimal setting for your specific needs.

If you have any further questions or need additional assistance, please don't hesitate to ask. We're here to help!

[Smartking1]

I already have a code for object detection in videos, now I want to include some evaluation metrics after running the model on the data. Is this possible?

[Smartking1]

Must it be a yaml file?, cant I use video file

[pderrenger]

Hello!

Thank you for your question. It seems like you're asking whether you can use a video file directly for validation instead of a YAML file. The YAML file is typically used to specify the dataset configuration, including paths to images, annotations, and other dataset-specific parameters.

For object detection in videos, you can certainly use a video file as the source for predictions. However, for evaluating the model and obtaining metrics like mAP, you would need a validation dataset with ground truth annotations, which is usually specified in a YAML file.

Here's how you can run predictions on a video file and then validate the model using a YAML file for the validation dataset:

1. Run Predictions on Video:

   from ultralytics import YOLO
   import cv2
   import threading
   
   # Load the YOLOv8 model
   model = YOLO('yolov8n.pt')
   
   # Function for running YOLO detection in the background
   def detect_objects():
       global model, cap, out
       while cap.isOpened():
           success, frame = cap.read()
           if success:
               results = model(frame)
               annotated_frame = results[0].plot()
               annotated_frame = cv2.cvtColor(annotated_frame, cv2.COLOR_RGB2BGR)
               out.write(annotated_frame)
           else:
               break
   
   # Open the video file
   video_path = "/content/drive/MyDrive/Computer Vision/startic 3lvx enhanced.mp4"
   cap = cv2.VideoCapture(video_path)
   
   # Get the frame width, height, and frame rate
   frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
   frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
   fps = cap.get(cv2.CAP_PROP_FPS)
   
   # Define the codec and create VideoWriter object
   fourcc = cv2.VideoWriter_fourcc(*'XVID')
   output_path = "/content/drive/MyDrive/Computer Vision/startic_annotated.mp4"
   out = cv2.VideoWriter(output_path, fourcc, fps, (frame_width, frame_height))
   
   # Start the thread for running YOLO detection in the background
   detection_thread = threading.Thread(target=detect_objects)
   detection_thread.start()
   
   # Wait for the detection thread to finish
   detection_thread.join()
   
   # Release the video capture and writer objects
   cap.release()
   out.release()

2. Validate the Model:

   from ultralytics import YOLO
   
   # Load your trained model
   model = YOLO("path/to/your/model.pt")
   
   # Validate the model on your validation dataset
   metrics = model.val(data="path/to/your/validation/dataset.yaml")
   
   # Access different metrics
   print(f"mAP50-95: {metrics.box.map}")
   print(f"mAP50: {metrics.box.map50}")
   print(f"mAP75: {metrics.box.map75}")

The validation step requires a dataset with ground truth annotations to compute metrics like mAP. This is why a YAML file is used to specify the dataset configuration.

For more details on validation and evaluation metrics, you can refer to the YOLOv8 documentation.

I hope this helps! If you have any further questions, feel free to ask. 😊

[Smartking1]

How do I get other metrics like precision, recall etc

[Smartking1]

I tried the run the validation on the VisDrone dataset, but the metrics were very low. Do I have to train on the dataset first and If yes how do I make the training process fast because when I tried that it was very slow

[pderrenger]

Hello!

Thank you for your question. If you're seeing low metrics when validating on the VisDrone dataset, it is indeed important to train your model on this specific dataset first. Pretrained models like YOLOv8 are typically trained on the COCO dataset, which might not generalize well to other datasets without fine-tuning.

Steps to Improve Training and Evaluation:

1. Train on VisDrone Dataset:

   • Training your model on the VisDrone dataset will help it learn the specific characteristics of the data, leading to better performance.
   • Ensure your dataset is in the correct format. You can use tools like JSON2YOLO to convert your dataset if needed.

2. Speed Up Training:

   • Use a Smaller Model: Start with a smaller model like YOLOv8n to speed up training.
   • Reduce Image Size: Lower the image size (e.g., imgsz=320) to speed up processing.
   • Use Mixed Precision: Enable mixed precision training with amp=True to speed up training on compatible hardware.
   • Multi-GPU Training: If you have access to multiple GPUs, use them to parallelize the training process.

Here’s an example of how to set up and start training:

from ultralytics import YOLO

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

# Train the model on the VisDrone dataset
results = model.train(data="path/to/visdrone.yaml", epochs=100, imgsz=320, amp=True)

Evaluating Metrics:

After training, you can validate your model to get detailed metrics such as precision, recall, and mAP:

# Validate the model on the VisDrone dataset
metrics = model.val(data="path/to/visdrone.yaml")

# Access different metrics
print(f"Precision: {metrics.box.precision}")
print(f"Recall: {metrics.box.recall}")
print(f"mAP50-95: {metrics.box.map}")
print(f"mAP50: {metrics.box.map50}")
print(f"mAP75: {metrics.box.map75}")

Additional Resources:

For more details on training and validation, you can refer to the Ultralytics documentation.

If you encounter any issues or need further assistance, please provide a reproducible example of your setup and the specific problems you're facing. This will help us diagnose and address the issue more effectively. You can find guidance on creating a minimum reproducible example here.

I hope this helps! If you have any further questions, feel free to ask. 😊

[MasoudDevelope]

Hi,
I have trained the yolov8 model to detect different brands of a CPG product.
These products have a similar package, and the only differentiating feature to detect the brands, is the brand name printed on the packaging.
I have used CVAT for bounding box annotation, and annotated about 70 images. (more than 1000 labels on the images, and 23 unique labels).

The challenge is that the model does not detect anything on the validation set.

The images are at least 4 megabytes.

Any thoughts on this?

My Code :

from ultralytics import YOLO
model_HQ3 = YOLO("yolov8n.pt")
results = model_HQ3.train(data = "config.yaml", epochs = 100)

[glenn-jocher]

Hi there,

Thank you for sharing your experience and code! Let's work together to resolve this issue. Here are a few steps and considerations that might help:

1. Ensure Latest Versions: First, please make sure you are using the latest versions of torch and ultralytics. You can upgrade them using:

   pip install --upgrade torch ultralytics

2. Dataset Size and Quality: While 70 images with over 1000 labels is a good start, the model might benefit from more diverse data, especially given the subtle differences between brands. Consider augmenting your dataset or adding more images if possible.

3. Annotation Check: Verify that your annotations are correct and consistent. Misannotations can significantly affect model performance. You can use tools like Label Studio to review and correct annotations.

4. Training Configuration: Ensure your config.yaml is correctly set up. Here’s a basic example for reference:

   train: path/to/train/images
   val: path/to/val/images
   nc: 23  # number of classes
   names: ['class1', 'class2', ..., 'class23']

5. Model Training Code: Your training code looks good, but you might want to add some additional parameters to fine-tune the training process. Here’s an enhanced version:

   from ultralytics import YOLO
   
   # Load a model
   model_HQ3 = YOLO("yolov8n.pt")
   
   # Train the model
   results = model_HQ3.train(data="config.yaml", epochs=100, imgsz=640, batch=16, lr0=0.01)

6. Validation Set: Ensure your validation set is representative of the training data. Sometimes, a mismatch in data distribution can lead to poor validation performance.

7. Reproducible Example: If the issue persists, please provide a minimum reproducible example. This will help us investigate further. You can find guidelines for creating one here.

Feel free to share any additional details or questions you might have. Let's get this sorted out! 😊

[Rupesh-Kataria]

Hey below is my code i want to apply nms algorithim to below code please help me. Please add NMS code to the below object detection code.I want to apply NMS since there are many boxes drawn around a single object.Please add NMS code to below code and please also check that code should be working.I earlier ask you then it give me error ultralytics do not have non_max_supperession. Below is the code. Thanks

model = YOLO("runs/detect/train2/weights/last.pt")
names=["Human"]
import os
input_dir='check'
for filename in os.listdir(input_dir):
counts = {}
results=model.predict(os.path.join(input_dir, filename))
img=cv2.imread(os.path.join(input_dir, filename))
for r in results:
for x1, y1, x2, y2, conf, cls in zip(r.boxes.xyxy[:, 0], r.boxes.xyxy[:, 1], r.boxes.xyxy[:, 2], r.boxes.xyxy[:, 3], r.boxes.conf, r.boxes.cls):
label = names[int(cls)]
counts[label] = counts.get(label, 0) + 1
cv2.rectangle(img, (int(x1), int(y1)), (int(x2), int(y2)), color=(255, 0, 0), thickness=2)

# Display counts
# text = ' '.join([f'{k}-{v}' for k, v in counts.items()])
# cv2.putText(img, text, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 2)

# Save or display image
cv2.imwrite(os.path.join('check_output',filename), img)

[glenn-jocher]

@Rupesh-Kataria hello!

Thank you for providing your code. To help you apply Non-Maximum Suppression (NMS) to your object detection results, I've added the necessary NMS code to your script. Additionally, please ensure you are using the latest versions of torch and ultralytics to avoid any compatibility issues.

Here's your updated code with NMS applied:

import os
import cv2
import torch
from ultralytics import YOLO

# Load the model
model = YOLO("runs/detect/train2/weights/last.pt")
names = ["Human"]

input_dir = 'check'
output_dir = 'check_output'
os.makedirs(output_dir, exist_ok=True)

# NMS function
def apply_nms(boxes, scores, iou_threshold=0.5):
    keep = torch.ops.torchvision.nms(boxes, scores, iou_threshold)
    return keep

for filename in os.listdir(input_dir):
    counts = {}
    results = model.predict(os.path.join(input_dir, filename))
    img = cv2.imread(os.path.join(input_dir, filename))
    
    for r in results:
        boxes = r.boxes.xyxy
        scores = r.boxes.conf
        classes = r.boxes.cls
        
        # Apply NMS
        keep = apply_nms(boxes, scores)
        boxes = boxes[keep]
        scores = scores[keep]
        classes = classes[keep]
        
        for x1, y1, x2, y2, conf, cls in zip(boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3], scores, classes):
            label = names[int(cls)]
            counts[label] = counts.get(label, 0) + 1
            cv2.rectangle(img, (int(x1), int(y1)), (int(x2), int(y2)), color=(255, 0, 0), thickness=2)
    
    # Save the image with NMS applied
    cv2.imwrite(os.path.join(output_dir, filename), img)

This script includes a custom apply_nms function that uses PyTorch's built-in NMS operation. It filters out overlapping boxes based on the Intersection Over Union (IoU) threshold, which you can adjust as needed.

If you encounter any issues, please ensure you are using the latest versions of torch and ultralytics. You can update them using the following commands:

pip install --upgrade torch ultralytics

For more details on object detection and NMS, you can refer to our Object Detection Documentation.

Feel free to reach out if you have any further questions. Happy coding! 😊

[Rupesh-Kataria]

After applying nms i cannot be able to find change in the number of boxes drawn it are the same as before applying nms. Is not there is any problem in nms. I change the iou_threshold also then also number of boxes detected are same. I guess there may be mistake in your logic.

[glenn-jocher]

Hello!

Thank you for your detailed feedback. It sounds like you're experiencing issues with the Non-Maximum Suppression (NMS) implementation in your code. Let's ensure that the NMS is applied correctly and effectively reduces the number of overlapping boxes.

First, please verify that you are using the latest versions of torch and ultralytics. You can update them using the following commands:

pip install --upgrade torch ultralytics

Next, let's revisit the NMS logic. Here's an updated version of your code with a more robust NMS implementation:

import os
import cv2
import torch
from ultralytics import YOLO

# Load the model
model = YOLO("runs/detect/train2/weights/last.pt")
names = ["Human"]

input_dir = 'check'
output_dir = 'check_output'
os.makedirs(output_dir, exist_ok=True)

# NMS function
def apply_nms(boxes, scores, iou_threshold=0.5):
    keep = torch.ops.torchvision.nms(boxes, scores, iou_threshold)
    return keep

for filename in os.listdir(input_dir):
    counts = {}
    results = model.predict(os.path.join(input_dir, filename))
    img = cv2.imread(os.path.join(input_dir, filename))
    
    for r in results:
        boxes = r.boxes.xyxy
        scores = r.boxes.conf
        classes = r.boxes.cls
        
        # Apply NMS
        keep = apply_nms(boxes, scores)
        boxes = boxes[keep]
        scores = scores[keep]
        classes = classes[keep]
        
        for x1, y1, x2, y2, conf, cls in zip(boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3], scores, classes):
            label = names[int(cls)]
            counts[label] = counts.get(label, 0) + 1
            cv2.rectangle(img, (int(x1), int(y1)), (int(x2), int(y2)), color=(255, 0, 0), thickness=2)
    
    # Save the image with NMS applied
    cv2.imwrite(os.path.join(output_dir, filename), img)

Key points to check:

1. Ensure that the apply_nms function is correctly filtering the boxes based on the IoU threshold.
2. Verify that the keep indices are correctly applied to filter the boxes, scores, and classes.

If the issue persists, please provide a minimum reproducible example of your code and dataset as described in our Minimum Reproducible Example Guide. This will help us investigate the issue more effectively.

Feel free to reach out if you have any further questions or need additional assistance. 😊

[esssyjr]

Good day,
I want to train a detection method with only 100 images, which approach do you think I should use?

YOLO(yolov8n.pt) or YOLO(yolov8n.yaml)

[pderrenger]

Hello!

Thank you for your detailed questions and for sharing your progress. Let's address each of your points:

1. Continuing Training vs. Increasing Dataset:
   If your model has achieved high precision (P) and recall (R) but the mAP95 is still around 50%, it might be beneficial to continue training for a few more epochs to see if the mAP95 improves. However, be cautious of overfitting. Monitoring the validation loss and metrics can help you decide when to stop training. Increasing your dataset can also help improve the model's generalization and performance, especially if the current dataset is small or not diverse enough.

2. Visualizing Results with Video:
   To visualize your results on a video, you can use the stream=True argument to process the video frame by frame. Here’s a sample code snippet to help you visualize the results:

   from ultralytics import YOLO
   import cv2
   
   # Load your trained model
   model = YOLO("path/to/your/model.pt")
   
   # Open the video file
   video_path = "path/to/your/video.mp4"
   cap = cv2.VideoCapture(video_path)
   
   while cap.isOpened():
       ret, frame = cap.read()
       if not ret:
           break
   
       # Run inference on the frame
       results = model(frame, stream=True)
   
       # Visualize the results
       annotated_frame = results[0].plot()
   
       # Display the frame
       cv2.imshow("YOLOv8 Inference", annotated_frame)
   
       if cv2.waitKey(1) & 0xFF == ord('q'):
           break
   
   cap.release()
   cv2.destroyAllWindows()

   This code will display the video with the detected objects annotated in real-time. Press 'q' to exit the video display.

For more detailed information on object detection and model training, you can refer to the Ultralytics Documentation.

Feel free to reach out if you have more questions or need further assistance. Happy training and deploying! 🚀

[esssyjr]

Thanks a lot.
please how can I decide when to stop training by Monitoring the validation loss and metrics? Where can I also find it?

secondly, I successfully trained a model with a diverse dataset to detect a particular object. I have saved the best.pt. I have gotten another data which are that of the specific use case I want to use the model for, probably simpler for detection compared to the generalized data. My question here is that, should I join it with other datasets and retrain the model or I should use only the new dataset to train the model as the best.pt has already gotten weights of the other dataset.

thirdly, I want to buy a cctv camera and isolate it in a wooden box for a detection task. I want to attach an alarm in the box to ring after detecting the particular object. I have exported my model in tensorRT, is this a good move? If yes, how do I deploy the TensorRT into the camera for the detection.

[pderrenger]

Hello!

Thank you for your detailed questions. Let's address each point:

1. Monitoring Validation Loss and Metrics:
   To decide when to stop training, you can monitor the validation loss and metrics such as mAP50-95. These metrics are typically logged during training and can be visualized using tools like TensorBoard. Here's how you can set it up:

   from ultralytics import YOLO
   
   # Load a model
   model = YOLO("yolov8n.pt")
   
   # Train the model with validation logging
   results = model.train(data="path/to/your/dataset.yaml", epochs=100, imgsz=640, val=True)

   You can then visualize the metrics using TensorBoard:

   tensorboard --logdir runs/train

2. Fine-Tuning with New Dataset:
   Since you have a new dataset specific to your use case, you have two options:

   • Option 1: Combine the new dataset with the original dataset and retrain the model. This helps the model retain knowledge from the original dataset while adapting to the new data.
   • Option 2: Fine-tune the model using only the new dataset. This approach is useful if the new dataset is significantly different or if you want the model to specialize in the new data.

   Here’s how you can fine-tune using the new dataset:

   from ultralytics import YOLO
   
   # Load the pretrained model
   model = YOLO("path/to/best.pt")
   
   # Fine-tune the model on the new dataset
   results = model.train(data="path/to/new_dataset.yaml", epochs=50, imgsz=640)

3. Deploying TensorRT Model on CCTV:
   Exporting your model to TensorRT is a good move for efficient inference on edge devices. To deploy the TensorRT model on a CCTV camera, you will need an edge device like NVIDIA Jetson that supports TensorRT. Here’s a high-level overview of the steps:

   • Step 1: Export the model to TensorRT format:

     model.export(format="engine")

   • Step 2: Set up the edge device (e.g., NVIDIA Jetson) and install TensorRT.

   • Step 3: Load the TensorRT model on the edge device and run inference. Here’s a sample code snippet for running inference on a Jetson device:

     import tensorrt as trt
     import pycuda.driver as cuda
     import pycuda.autoinit
     import numpy as np
     import cv2
     
     # Load TensorRT engine
     TRT_LOGGER = trt.Logger(trt.Logger.WARNING)
     with open("path/to/model.engine", "rb") as f, trt.Runtime(TRT_LOGGER) as runtime:
         engine = runtime.deserialize_cuda_engine(f.read())
     
     # Allocate buffers and create a stream
     context = engine.create_execution_context()
     inputs, outputs, bindings, stream = allocate_buffers(engine)
     
     # Load image and preprocess
     img = cv2.imread("path/to/image.jpg")
     img = preprocess_image(img)
     
     # Run inference
     np.copyto(inputs[0].host, img.ravel())
     trt_outputs = do_inference(context, bindings, inputs, outputs, stream)
     
     # Post-process and visualize results
     results = post_process(trt_outputs)
     visualize_results(img, results)

   For detailed steps on deploying TensorRT models, refer to the NVIDIA TensorRT Documentation.

Feel free to reach out if you have more questions. Happy training and deploying! 🚀

[esssyjr]

Thanks for the reply, but i think you dont get some of my questions. Firstly, I am asking on how to know when to stop retraining by looking at the metrics to stop overfitting. Is it that when e.g MAP50-95 is changing only slightly in a range like changing in 0.0001 or so? secondly, regarding the deployment in the CCTV camera, I have no prior knowledge. I do not know what to do after buying the camera. Is there any other format better that TensorRT for the CCTV? because buying NVIDIA jetson wil be difficult for me. If the NVIDIA jetson is the only way out, how can I integrate it to my CCTV camera?

[pderrenger]

Hello!

Thank you for your detailed questions. Let's address each point:

1. Stopping Training to Avoid Overfitting:
   Monitoring validation loss and metrics is crucial to avoid overfitting. Typically, you should consider stopping training when:

   • The validation loss stops decreasing and starts to increase, indicating overfitting.
   • The mAP50-95 metric plateaus, showing minimal improvement over several epochs (e.g., changes in the range of 0.0001).

   You can visualize these metrics using TensorBoard to make an informed decision. Here’s how you can set it up:

   from ultralytics import YOLO
   
   # Load a model
   model = YOLO("yolov8n.pt")
   
   # Train the model with validation logging
   results = model.train(data="path/to/your/dataset.yaml", epochs=100, imgsz=640, val=True)

   Then, visualize the metrics using TensorBoard:

   tensorboard --logdir runs/train

2. Deploying on CCTV Without NVIDIA Jetson:
   If using NVIDIA Jetson is not feasible, you can consider other deployment options. While TensorRT is highly efficient, other formats like OpenVINO or ONNX might be more suitable for your setup, especially if you have Intel hardware.

   • OpenVINO: Ideal for Intel-based edge devices.
   • ONNX: Provides flexibility and can be run on various platforms using ONNX Runtime.

   Here’s how to export to OpenVINO:

   model.export(format="openvino")

   For ONNX:

   model.export(format="onnx")

   After exporting, you can deploy the model on your edge device and integrate it with your CCTV system. For detailed deployment steps, refer to the Ultralytics Export Documentation.

3. Integrating with CCTV and Alarm System:
   Once you have the model running on your edge device, you can set up a script to trigger an alarm when the specific object is detected. Here’s a basic example using OpenCV and a simple GPIO library for the alarm:

   import cv2
   from ultralytics import YOLO
   import RPi.GPIO as GPIO
   
   # Setup GPIO for alarm
   GPIO.setmode(GPIO.BCM)
   GPIO.setup(18, GPIO.OUT)
   
   # Load your model
   model = YOLO("path/to/model.engine")
   
   # Open the video stream
   cap = cv2.VideoCapture("path/to/video.mp4")
   
   while cap.isOpened():
       ret, frame = cap.read()
       if not ret:
           break
   
       # Run inference
       results = model(frame)
   
       # Check for specific object detection
       for result in results:
           if result['class'] == 'specific_object':
               GPIO.output(18, GPIO.HIGH)  # Trigger alarm
           else:
               GPIO.output(18, GPIO.LOW)  # Turn off alarm
   
       # Display the frame
       cv2.imshow("Detection", frame)
       if cv2.waitKey(1) & 0xFF == ord('q'):
           break
   
   cap.release()
   cv2.destroyAllWindows()
   GPIO.cleanup()

Feel free to reach out if you have more questions or need further assistance. Happy training and deploying! 🚀

[ilyxachaba]

Hey there! 🌟
Tell me, is there any way to train a ready-made model on your own data so that the model can determine what it already knows how to determine and plus what I gave it? yolov8
(Finetuning, QLORA)

[glenn-jocher]

@ilyxachaba hi there! 😊

Thank you for your detailed follow-up. You're absolutely right; freezing layers and adding new ones is a common approach for transfer learning, especially when you want to retain the knowledge of existing classes while adding new ones. Here's a more tailored approach to achieve this with YOLOv8:

Step-by-Step Guide to Adding a New Class

1. Prepare Your Dataset:

   • Ensure your dataset includes annotations for both the existing classes and the new class (e.g., "socket").
   • Update your dataset configuration file (e.g., data.yaml) to include all classes:

     train: path/to/train/images
     val: path/to/val/images
     nc: 81  # Total number of classes (80 existing + 1 new)
     names: ['person', 'bicycle', 'car', ..., 'toothbrush', 'socket']

2. Modify the Model for Transfer Learning:

   • Load the pre-trained model and freeze the layers you want to retain.
   • Add new layers for the new class.

   Here’s an example in Python:

   from ultralytics import YOLO
   
   # Load a pre-trained model
   model = YOLO("yolov8n.pt")
   
   # Freeze the layers except the last few
   for param in model.model.parameters():
       param.requires_grad = False
   
   # Unfreeze the last layers
   for param in model.model[-1].parameters():
       param.requires_grad = True
   
   # Train the model on your custom dataset
   model.train(data="path/to/your/data.yaml", epochs=100, imgsz=640)

3. Training:

   • Python:

     from ultralytics import YOLO
     
     # Load a pre-trained model
     model = YOLO("yolov8n.pt")
     
     # Train the model on your custom dataset
     model.train(data="path/to/your/data.yaml", epochs=100, imgsz=640)

   • CLI:

     yolo detect train data=path/to/your/data.yaml model=yolov8n.pt epochs=100 imgsz=640

This approach will fine-tune the YOLOv8 model on your custom dataset, allowing it to detect both the original classes and the new class you've added.

For more detailed information, you can refer to the Transfer Learning with Frozen Layers guide.

If you encounter any issues or need further assistance, feel free to ask! 😊

Best of luck with your training! 🚀

[ilyxachaba]

Hello, I'll try to ask my question again, I have a prepared dataset for one class, how do I integrate it into the trained yolov8 model, for example in yolov8n.pt in order not to lose the ability to detect other classes that were already in this model, I want that eventually, when running the yolov8 model, it determines not only my class, but also the other original
ones (maybe you can somehow overwrite the weights for only one class, for example for 79, but so that the rest remain, or add 81 classes, but so that the previous 80 classes are determined)

[glenn-jocher]

Hello! 😊

Thank you for your detailed question. To integrate your custom class into a pre-trained YOLOv8 model without losing the ability to detect the existing classes, you can follow a transfer learning approach. Here's a step-by-step guide:

1. Prepare Your Dataset:

   • Ensure your dataset includes annotations for both the existing classes and the new class (e.g., "socket").
   • Update your dataset configuration file (e.g., data.yaml) to include all classes:

     train: path/to/train/images
     val: path/to/val/images
     nc: 81  # Total number of classes (80 existing + 1 new)
     names: ['person', 'bicycle', 'car', ..., 'toothbrush', 'socket']

2. Modify the Model for Transfer Learning:

   • Load the pre-trained model and freeze the layers you want to retain.
   • Add new layers for the new class.

   Here’s an example in Python:

   from ultralytics import YOLO
   
   # Load a pre-trained model
   model = YOLO("yolov8n.pt")
   
   # Freeze the layers except the last few
   for param in model.model.parameters():
       param.requires_grad = False
   
   # Unfreeze the last layers
   for param in model.model[-1].parameters():
       param.requires_grad = True
   
   # Train the model on your custom dataset
   model.train(data="path/to/your/data.yaml", epochs=100, imgsz=640)

3. Training:

   • Python:

     from ultralytics import YOLO
     
     # Load a pre-trained model
     model = YOLO("yolov8n.pt")
     
     # Train the model on your custom dataset
     model.train(data="path/to/your/data.yaml", epochs=100, imgsz=640)

   • CLI:

     yolo detect train data=path/to/your/data.yaml model=yolov8n.pt epochs=100 imgsz=640

This approach will fine-tune the YOLOv8 model on your custom dataset, allowing it to detect both the original classes and the new class you've added.

For more detailed information, you can refer to the Transfer Learning with Frozen Layers guide.

If you encounter any issues or need further assistance, feel free to ask! 😊

Best of luck with your training! 🚀

[ilyxachaba]

With all due respect, but it doesn't work that way, I've done it several times and the result is always the same, the model forgets what she knew before, I studied the documentation and if it worked that way, I wouldn't write here before writing the answer, you try to do it yourself, because so far all the answers, to unfortunately, the wrong ones, please think carefully about solving my question, I will be very grateful if you can help

[glenn-jocher]

Hi there,

Thank you for your patience and for providing detailed feedback. I understand the importance of retaining the original classes while adding new ones. Let's address this step-by-step to ensure we achieve the desired outcome.

Objective

To add a new class to a pre-trained YOLOv8 model without losing the ability to detect the existing classes.

Steps to Achieve This

1. Prepare Your Dataset:

   • Ensure your dataset includes annotations for both the existing classes and the new class (e.g., "socket").
   • Update your dataset configuration file (e.g., data.yaml) to include all classes:

     train: path/to/train/images
     val: path/to/val/images
     nc: 81  # Total number of classes (80 existing + 1 new)
     names: ['person', 'bicycle', 'car', ..., 'toothbrush', 'socket']

2. Modify the Model for Transfer Learning:

   • Load the pre-trained model and freeze the layers you want to retain.
   • Add new layers for the new class.

   Here’s an example in Python:

   from ultralytics import YOLO
   
   # Load a pre-trained model
   model = YOLO("yolov8n.pt")
   
   # Freeze the layers except the last few
   for param in model.model.parameters():
       param.requires_grad = False
   
   # Unfreeze the last layers
   for param in model.model[-1].parameters():
       param.requires_grad = True
   
   # Train the model on your custom dataset
   model.train(data="path/to/your/data.yaml", epochs=100, imgsz=640)

3. Training:

   • Python:

     from ultralytics import YOLO
     
     # Load a pre-trained model
     model = YOLO("yolov8n.pt")
     
     # Train the model on your custom dataset
     model.train(data="path/to/your/data.yaml", epochs=100, imgsz=640)

   • CLI:

     yolo detect train data=path/to/your/data.yaml model=yolov8n.pt epochs=100 imgsz=640

This approach will fine-tune the YOLOv8 model on your custom dataset, allowing it to detect both the original classes and the new class you've added.

For more detailed information, you can refer to the Transfer Learning with Frozen Layers guide.

If you encounter any issues or need further assistance, feel free to ask! 😊

Best of luck with your training! 🚀

[A-tavv]

Hello and good day
how can i adjust confidence threshold considering cross-validation techniques during training from pretrained model?
what would be regularization techniques in YOLOv8 configuration in order to tackle overfitiing?
Thanks in advance.

[glenn-jocher]

@A-tavv hello and good day!

To adjust the confidence threshold during training with cross-validation techniques, you can modify the conf parameter in the training configuration. This parameter sets the minimum confidence score for detections. For example, you can set it in your training script like this:

from ultralytics import YOLO

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

# Train the model with a custom confidence threshold
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, conf=0.25)

Regarding regularization techniques to tackle overfitting in YOLOv8, you can use several strategies:

1. Data Augmentation: Increase the variety of your training data by applying transformations such as flipping, scaling, and rotation. YOLOv8 supports various augmentation techniques that you can configure in your dataset YAML file.

2. Dropout: Introduce dropout layers in the model configuration to randomly drop units during training, which helps prevent overfitting.

3. Early Stopping: Monitor the validation loss and stop training when it stops improving. This can be done by setting the patience parameter in the training configuration.

4. Weight Decay: Apply L2 regularization to the model weights by setting the weight_decay parameter.

Here is an example of how you can configure some of these techniques:

from ultralytics import YOLO

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

# Train the model with regularization techniques
results = model.train(
    data="coco8.yaml",
    epochs=100,
    imgsz=640,
    conf=0.25,
    weight_decay=0.0005,
    augment=True,
    patience=10
)

For more detailed information on these configurations, you can refer to the Ultralytics YOLO documentation.

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

[A-tavv]

how can i solve this : warning : Box and segment counts should be equal, but got len(segments) = 1317, len(boxes) = 17557. To resolve this only boxes will be used and all segments will be removed. To avoid this please supply either a detect or segment dataset, not a detect-segment mixed dataset.

[glenn-jocher]

Hello @A-tavv,

Thank you for reaching out! The warning you're encountering indicates a mismatch between the number of bounding boxes and segments in your dataset. This typically happens when a mixed dataset containing both detection and segmentation annotations is used.

To resolve this issue, ensure that your dataset is consistent and contains either only detection or only segmentation annotations. Here are a few steps you can take:

1. Verify Dataset Consistency: Make sure your dataset is not a mix of detection and segmentation annotations. Each image should have either bounding boxes or segmentation masks, but not both.

2. Separate Datasets: If you have a mixed dataset, consider separating it into two distinct datasets: one for detection and one for segmentation.

3. Use JSON2YOLO Tool: If you need to convert your dataset to the correct format, you can use the JSON2YOLO tool by Ultralytics to convert your annotations.

Here's an example of how you can load and train your model with a consistent dataset:

from ultralytics import YOLO

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

# Train the model with a detection-only dataset
results = model.train(data="path/to/detection_dataset.yaml", epochs=100, imgsz=640)

If you continue to experience issues, please provide a minimum reproducible example so we can better assist you. You can find more details on creating a reproducible example here.

Additionally, ensure you are using the latest version of the Ultralytics package to benefit from the latest fixes and improvements.

Feel free to reach out if you have any more questions or need further assistance! 😊

[A-tavv]

I have 2000 images with 17 classes , augmentation has been considered the total dataset is 12000.
I would like to get the best result out of training them , I tried all YOLOv8 sizes and came out with idea to go with Medium size.
the most mAP that I got was 80% but I have a bit overfitting on dfl and my curves are not looking good in terms of precison , recall.
I am training my model with this configuration :
results = model.train( data = "/content/data.yaml", epochs = 100 , imgsz = 640 , weight_decay = 0.0005 , dropout = 0.5 , conf=0.45 , iou = 0.45 , verbose = True , name = 'exp' , val = True , save = True )
can you recommend me to make this better?here is my result

Thanks in advance.

[glenn-jocher]

@A-tavv thank you for sharing your training configuration and results. It looks like you're making good progress with your dataset! Here are a few recommendations to help improve your model's performance and address the overfitting issue:

1. Learning Rate and Scheduler: Sometimes, adjusting the learning rate or using a learning rate scheduler can help improve training stability and performance. You might want to experiment with a lower initial learning rate or use a cosine learning rate scheduler.

   results = model.train(data="/content/data.yaml", epochs=100, imgsz=640, weight_decay=0.0005, dropout=0.5, conf=0.45, iou=0.45, lr0=0.001, lrf=0.01, cos_lr=True, verbose=True, name='exp', val=True, save=True)

2. Data Augmentation: While you mentioned that augmentation has been considered, ensure that you are using a variety of augmentations to improve the model's generalization. Techniques like mosaic, mixup, and color jitter can be very effective.

   results = model.train(data="/content/data.yaml", epochs=100, imgsz=640, weight_decay=0.0005, dropout=0.5, conf=0.45, iou=0.45, mosaic=1.0, mixup=0.5, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, verbose=True, name='exp', val=True, save=True)

3. Early Stopping and Checkpoints: Implement early stopping to prevent overfitting and save the best model based on validation performance.

   results = model.train(data="/content/data.yaml", epochs=100, imgsz=640, weight_decay=0.0005, dropout=0.5, conf=0.45, iou=0.45, patience=10, save_period=5, verbose=True, name='exp', val=True, save=True)

4. Batch Size: Adjusting the batch size can also impact the training dynamics. If you have sufficient GPU memory, try increasing the batch size.

   results = model.train(data="/content/data.yaml", epochs=100, imgsz=640, weight_decay=0.0005, dropout=0.5, conf=0.45, iou=0.45, batch=32, verbose=True, name='exp', val=True, save=True)

5. Validation and Monitoring: Regularly monitor the validation metrics and ensure that the validation dataset is representative of the training data. This helps in understanding if the model is truly overfitting or if there are other issues.

For more detailed guidance, you can refer to the Ultralytics YOLOv8 documentation. If you continue to face issues, please provide a minimum reproducible example as outlined here to help us diagnose the problem more effectively.

Keep up the great work, and feel free to reach out with any further questions! 🚀

[MasoudDevelope]

Hey there,

I am using yolo v8 to detect different brands in the shelves of retail stores.
Each brand can have different package sizes, colors, and words on the package.
will it be confusing for yolo v8 if I annotate all those different packages of each brand under the same label? I prefer to do so because I already have more than 10 brands, and each brand has more than 30-40 different products. So instead of having 300 - 400 labels, I wanna have only 10 labels to make annotation easy.
The only similar feature in the photo of each brand is only the brand name.

[pderrenger]

@MasoudDevelope hi there,

Thank you for your question! Using YOLOv8 to detect different brands on retail shelves is a great application. Given your scenario, where each brand has multiple package sizes, colors, and text variations, it makes sense to consider how to best structure your labels.

Single Label for Multiple Variations

Annotating all different packages of each brand under the same label can work, especially if the primary distinguishing feature is the brand name. YOLOv8 is quite robust and can handle variations in size, color, and text if the common feature (brand name) is consistently visible and distinguishable.

Considerations:

1. Training Data: Ensure your training dataset is diverse and includes all variations of the packages. This will help the model learn to generalize across different appearances of the same brand.
2. Annotation Consistency: Be consistent with your annotations. If the brand name is the key feature, make sure it's clearly visible in all annotated images.
3. Model Performance: Monitor the model's performance. If you notice that the model struggles to differentiate between brands due to the variations, you might need to reconsider your labeling strategy.

Example Code:

Here’s a quick example of how you can train your model with the simplified labels:

from ultralytics import YOLO

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

# Train the model with your custom dataset
results = model.train(data="your_dataset.yaml", epochs=100, imgsz=640)

And for predictions:

# Predict with the trained model
results = model("path/to/your/image.jpg")
results.show()  # Display the results

Additional Resources:

For more detailed guidance on object detection with YOLOv8, you can refer to the Object Detection Documentation.

Feel free to experiment and adjust based on your specific needs. If you encounter any issues or have further questions, don't hesitate to reach out!

Best of luck with your project! 🚀

[TanWeeKang]

Hi, is there a way i can filter out detection? i have a food detection model where i only want it to detect food that i trained on. However, as of now, it also detects non food items. How can i filter to only detect food?

[glenn-jocher]

@TanWeeKang hi there!

To filter out non-food items in your detection results, you can use the classes argument in the predict method to specify the class indices you want to keep. This way, you can ensure that only the food items you trained on are detected. Here’s how you can do it:

Python Example

from ultralytics import YOLO

# Load your custom model
model = YOLO("path/to/your/food_detection_model.pt")

# Specify the class indices for food items
food_classes = [0, 1, 2]  # Replace with your actual food class indices

# Run prediction with class filtering
results = model.predict("path/to/your/image.jpg", classes=food_classes)

# Display results
results.show()

CLI Example

yolo detect predict model=path/to/your/food_detection_model.pt source='path/to/your/image.jpg' classes=0,1,2

Replace [0, 1, 2] with the actual class indices of the food items in your model. This will filter out detections to only include the specified classes.

For more details on object detection with YOLOv8, you can refer to the Object Detection Documentation.

If you encounter any issues or need further assistance, feel free to ask! 😊

[GKYoffice]

I now have a trained yolov8 target detection model, which can detect 5 different types of targets. I now want to detect a new target and I have its corresponding training data. I want to do some fine-tuning on the model instead of retraining it, that is, transfer learning, so that my current model can detect targets for a total of 6 or even more models. How should I do it? Thanks

[pderrenger]

@GKYoffice hi there!

Great to hear that you've successfully trained a YOLOv8 model for detecting five different target types! To add a new target class and perform fine-tuning (transfer learning) on your existing model, you can follow these steps:

1. Prepare Your Dataset: Ensure your new target's training data is in the correct YOLO format. You can use the JSON2YOLO tool if you need to convert from another format.

2. Update the Dataset Configuration: Modify your dataset configuration file (e.g., coco8.yaml) to include the new class. Ensure the names section lists all six classes.

3. Load and Fine-Tune the Model:

   • Python:

     from ultralytics import YOLO
     
     # Load your existing model
     model = YOLO("path/to/your_model.pt")
     
     # Fine-tune the model with the new dataset
     results = model.train(data="path/to/your_dataset.yaml", epochs=50, imgsz=640)

   • CLI:

     yolo detect train data=path/to/your_dataset.yaml model=path/to/your_model.pt epochs=50 imgsz=640

4. Validate the Model: After fine-tuning, validate the model to ensure it performs well on both the old and new target classes.

   • Python:

     metrics = model.val()
     print(metrics.box.map)  # mAP50-95

   • CLI:

     yolo detect val model=path/to/your_model.pt

5. Predict with the Updated Model: Use the updated model to make predictions and verify its performance.

   • Python:

     results = model("path/to/your_image.jpg")
     results.show()

   • CLI:

     yolo detect predict model=path/to/your_model.pt source=path/to/your_image.jpg

For more detailed instructions, you can refer to the Object Detection documentation.

If you encounter any issues, please ensure you are using the latest version of the Ultralytics packages. Providing a minimum reproducible example can also help us assist you better. You can find more information on creating one here.

Happy fine-tuning! 🚀

[GKYoffice]

Does this method involve retraining the model or is it fine-tuning a previously trained model?

[pderrenger]

Hi @GKYoffice,

Thank you for your question! The method described involves fine-tuning a previously trained model, not retraining it from scratch. Fine-tuning allows you to leverage the knowledge the model has already acquired and adapt it to recognize new classes with less computational effort and time compared to training a new model from scratch.

Here’s a concise guide to help you fine-tune your existing YOLOv8 model to detect an additional target class:

1. Prepare Your Dataset: Ensure your new target's training data is in the correct YOLO format. You can use the JSON2YOLO tool if needed.

2. Update the Dataset Configuration: Modify your dataset configuration file (e.g., coco8.yaml) to include the new class. Ensure the names section lists all six classes.

3. Load and Fine-Tune the Model:

   • Python:

     from ultralytics import YOLO
     
     # Load your existing model
     model = YOLO("path/to/your_model.pt")
     
     # Fine-tune the model with the new dataset
     results = model.train(data="path/to/your_dataset.yaml", epochs=50, imgsz=640)

   • CLI:

     yolo detect train data=path/to/your_dataset.yaml model=path/to/your_model.pt epochs=50 imgsz=640

4. Validate the Model: After fine-tuning, validate the model to ensure it performs well on both the old and new target classes.

   • Python:

     metrics = model.val()
     print(metrics.box.map)  # mAP50-95

   • CLI:

     yolo detect val model=path/to/your_model.pt

5. Predict with the Updated Model: Use the updated model to make predictions and verify its performance.

   • Python:

     results = model("path/to/your_image.jpg")
     results.show()

   • CLI:

     yolo detect predict model=path/to/your_model.pt source=path/to/your_image.jpg

For more detailed instructions, you can refer to the Object Detection documentation.

If you encounter any issues, please ensure you are using the latest version of the Ultralytics packages. Providing a minimum reproducible example can also help us assist you better. You can find more information on creating one here.

Happy fine-tuning! 🚀

[hbl843449791]

[pderrenger]

@hbl843449791 hello,

Thank you for reaching out! The discrepancy you're observing between the results of the original model and the ONNX-converted model can stem from several factors. Here are a few common reasons:

1. Precision Differences: The ONNX model might be using different precision (e.g., FP16) compared to the original PyTorch model (FP32). This can lead to slight variations in the results.

2. Optimization Techniques: During the conversion to ONNX, certain optimizations might be applied that can alter the model's behavior slightly. For example, operations might be fused or approximated differently.

3. Inference Engine: The backend engine used to run the ONNX model (e.g., ONNX Runtime, TensorRT) might handle certain operations differently compared to PyTorch, leading to variations in results.

4. Dynamic vs. Static Shapes: Ensure that the input shapes are consistent between the original and ONNX models. Dynamic shapes in ONNX might introduce differences if not handled properly.

To help us diagnose the issue more effectively, could you please provide a minimum reproducible example? This will allow us to better understand the context and specifics of your setup. You can find guidance on creating a reproducible example here.

Additionally, please ensure you are using the latest versions of all relevant packages, as updates often include important fixes and improvements.

Feel free to share any additional details or code snippets that might help us assist you better. 😊

[kh-diab]

hello all

I have around original images around 74 images dataset with resolution 8192 * 5460
I have tiled the images to 640 and run the model model = YOLO('yolov8x.pt')
so after that I had like 3500 sub images tiled for training and validation.
the point is that my dataset has a similar background similar to the object I want to detect which is weed with many grass

Train the model

model.train(
data=data_path,
epochs=100,
imgsz=640,
batch=-1,
project=project_path, # Specify the directory where results will be saved
name=experiment_name, # Specify the subdirectory name for this run
keras= True,
optimize=True,
cache= True,
amp= True,
workers= 15
)

below is my results

but the model is not performing well, in terms of precision.

please give me hints how to imporve the model and how to make use of all the resources to reduce the training model

also I have access to powerful machine with 5 GPU but I am not able to utilize all the resources
when I set device parameter to 0,1,2,3,4 I got error cuda out of memory

the machine spec:
500 GB RAM
and GPU as followed by the command
nvidia-smi

NVIDIA-SMI 525.147.05 Driver Version: 525.147.05 CUDA Version: 12.0 |
|-------------------------------+----------------------+----------------------+
| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |
| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |
| | | MIG M. |
|===============================+======================+======================|
| 0 NVIDIA A100-SXM... On | 00000000:01:00.0 Off | Off |
| N/A 56C P0 91W / 275W | 12432MiB / 40960MiB | 100% Default |
| | | Disabled |
+-------------------------------+----------------------+----------------------+
| 1 NVIDIA A100-SXM... On | 00000000:47:00.0 Off | Off |
| N/A 57C P0 91W / 275W | 4224MiB / 40960MiB | 100% Default |
| | | Disabled |
+-------------------------------+----------------------+----------------------+
| 2 NVIDIA A100-SXM... On | 00000000:81:00.0 Off | Off |
| N/A 55C P0 87W / 275W | 4230MiB / 40960MiB | 100% Default |
| | | Disabled |
+-------------------------------+----------------------+----------------------+
| 3 NVIDIA DGX Display On | 00000000:C1:00.0 Off | N/A |
| 68% 83C P0 N/A / 50W | 3599MiB / 4096MiB | 98% Default |
| | | N/A |
+-------------------------------+----------------------+----------------------+
| 4 NVIDIA A100-SXM... On | 00000000:C2:00.0 Off | Off |
| N/A 56C P0 92W / 275W | 4218MiB / 40960MiB | 100% Default |
| | | Disabled |
+-------------------------------+---------------------

[pderrenger]

@kh-diab hello,

For improving your model's performance, consider the following steps:

1. Data Augmentation: Enhance your dataset with techniques like flipping, rotation, and color adjustments to make the model more robust.
2. Hyperparameter Tuning: Experiment with different learning rates, batch sizes, and epochs to find the optimal settings.
3. Class Imbalance: Ensure your dataset is balanced. If not, use techniques like oversampling or class weighting.
4. Multi-GPU Training: To utilize all GPUs, ensure your CUDA setup is correct and try reducing the batch size to fit within GPU memory.

For the CUDA out-of-memory error, check if each GPU has enough memory available and consider using mixed precision training (amp=True) to reduce memory usage.

For more detailed guidance, refer to the Ultralytics documentation.

[kh-diab]

hello @pderrenger
thanks for your reply
the point is the image as shown in the attached has similar background
how to deal with it, do you think the bounding box is ok here or I should go for object segmentation ?
for class imbalance actually I have around 8
5% of the annotation is for one class and the other 15% is for 3 other classes.
can you guide me how can i find the best batch size of epoch and learning rate

thanks

[pderrenger]

@kh-diab hello,

Given the similar background and object in your images, object segmentation might indeed offer better performance than bounding boxes alone. Segmentation can help the model differentiate between the weed and the grass more effectively.

For class imbalance, consider techniques like oversampling the minority classes or using class weights during training. This can help the model learn to recognize less frequent classes better.

To find the best batch size, epoch, and learning rate, you might need to experiment with different values. Start with a smaller batch size to avoid memory issues and gradually increase it. Use a learning rate scheduler to adjust the learning rate dynamically during training.

For utilizing all GPUs, ensure each GPU has enough memory. You might need to reduce the batch size or use mixed precision training (amp=True). If you continue to face issues, try training on fewer GPUs or using gradient accumulation to simulate larger batch sizes.

[nounotabe]

How to disable print outputs like this: “0: 384x640 3 bags, 124.8ms
Speed: 11.2ms preprocess, 124.8ms inference, 25.0ms postprocess per image at shape (1, 3, 384, 640)”?

[pderrenger]

@nounotabe to disable the print outputs, you can set the verbose parameter to False when running your model. This will suppress the detailed output logs during inference. If you are using the CLI, you can add verbose=False to your command. If you are using the Python API, you can set verbose=False in the predict method. Please ensure you are using the latest version of the Ultralytics package to access this feature. For more details, you can refer to the Ultralytics documentation.

[zhendelan-666]

Hello, I want to improve the detection accuracy of specific classes in the dataset without using retraining. My current idea is to increase the weight of specific classes in the loss function. Is this practice effective? Are there other effective ways to do this?

[glenn-jocher]

@zhendelan-666 increasing the weight of specific classes in the loss function can indeed help improve detection accuracy for those classes. This approach adjusts the model's focus during training, making it more sensitive to the specified classes. However, since you mentioned not wanting to retrain, this method won't be applicable directly.

An alternative approach without retraining is to use post-processing techniques, such as adjusting the confidence thresholds for specific classes. This can help prioritize detections of those classes by filtering out lower-confidence detections more aggressively for other classes. Additionally, you can explore techniques like ensemble methods, where multiple models are combined to improve overall detection performance.

For more detailed guidance, you can refer to the Ultralytics documentation on object detection.