models/yolov8/

[giscus[bot]]

models/yolov8/

Explore the thrilling features of YOLOv8, the latest version of our real-time object detector! Learn how advanced architectures, pre-trained models and optimal balance between accuracy & speed make YOLOv8 the perfect choice for your object detection tasks.

https://docs.ultralytics.com/models/yolov8/

[blackCmd]

I can't find score of yolov8x6.pt...
Where is the socre?

[pderrenger]

Hey there! 😊 It looks like you're searching for the performance score of the yolov8x6.pt model. Currently, the specs for yolov8x6.pt specifically might not be listed directly in the documentation.

For detailed performance metrics like mAP (mean Average Precision), speed, and other statistics, they are generally available for models in the YOLOv8 series trained on datasets like COCO or Open Images V7, as showcased on the documentation page you've referred to. These metrics include various performance aspects such as mAP values across different image sizes and speeds on different platforms.

If yolov8x6.pt is a particular variant you're interested in and details are not directly mentioned, a good practice is to load the model using the Ultralytics Python package and evaluate it on a validation set for the specific metrics you're interested in. Here's a quick example in Python on how you might go about getting those metrics:

from ultralytics import YOLO

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

# Evaluate the model on validation data to get scores
results = model.val(data='path/to/your/validation/data.yaml')
print(results)

But, do keep diving into the Ultralytics YOLO documentation for further insights. And if you have more detailed questions or need further assistance, don't hesitate to reach out! 🌟

[WaelSalhi1]

[pderrenger]

Hey there! 🙌

I'm sorry to hear you're facing issues with accurately counting pants using your YOLOv8 segmentation model. When dealing with non-rigid objects like clothes, their altering shapes and overlaps can indeed pose challenges.

Here's a suggestion you might explore:

1. Adjust your segmentation model's training data: Make sure your training dataset is diverse, including images of pants in various positions and states of overlap. This variability helps the model learn to recognize the pants in different configurations better.

2. Post-processing to reduce overcounting: After segmentation, applying a post-processing step to merge closely located detections or detections that have significant overlap might help. For instance, you can use clustering techniques to group detections based on proximity and then count the groups rather than individual detections.

3. Fine-tune model parameters: Adjust the confidence threshold and overlap threshold (IoU) during prediction. Lowering the confidence threshold a bit might reduce false positives, and adjusting the IoU can help manage how detections are merged.

4. Experiment with model variants: If you haven't already, try using different YOLOv8 segmentation model sizes (e.g., yolov8n-seg, yolov8s-seg, yolov8m-seg) to see if a change in model capacity impacts performance.

Here's a simple code snippet to adjust the post-processing thresholds:

from ultralytics import YOLO

model = YOLO('yolov8n-seg.pt')  # Your trained model
results = model('path/to/your/image.jpg', conf=0.4, iou=0.5)

# Count the unique pants post-processing
pants_count = len(results.masks)  # Adjust according to your merging logic
print('Number of pants:', pants_count)

Hope these tips help! If you have further details or specific challenges, feel free to share! Good luck with your project. 🍀

[jamesvilho]

I used yolov8 to successfully detect objects in nuscene camera image dataset for autonomus driving. However, i am finding it dificult to extract or retrieve bounding boxes, classes/labels and confidence scores from the processed images. I will need to use these information (bounding boxes cordinates, confidence scores, labels). I tried using format [xmin, ymin, xmax, ymax] format, and using logic that relies on the 'xyxy' attribute but to no avail. @pderrenger i really need your help as I need to move on to the next task. Thanks

[pderrenger]

Hi there! 😊 I'm glad to hear that you've found success using YOLOv8 for object detection in the nuscene camera image dataset! To assist you with extracting bounding boxes, class labels, and confidence scores from your detections, here's a straightforward example that might help:

from ultralytics import YOLO

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

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

# Iterate over results to extract information
for result in results:
    # Get bounding boxes in [xmin, ymin, xmax, ymax] format
    boxes = result.boxes.xyxy.cpu().numpy()  

    # Get class labels
    labels = [model.names[int(cls)] for cls in result.boxes.cls]

    # Get confidence scores
    confidences = result.boxes.conf.cpu().numpy()

    # Example: print results for each detected object
    for box, label, confidence in zip(boxes, labels, confidences):
        print(f"Box: {box}, Label: {label}, Confidence: {confidence}")

This example assumes you're working with a single image. If you're processing multiple images, the result would iterate through the list of results corresponding to each image.

Remember, result.boxes.xyxy provides the bounding boxes in [xmin, ymin, xmax, ymax] format. The .cpu().numpy() part is ensuring that if you're using a GPU for inference, the results are moved to the CPU memory and converted to a NumPy array for easy manipulation.

Let me know if this helps or if you have any more questions! Happy coding! 🚀

[jamesvilho]

Hello, thank you for your help. Working now.

[pderrenger]

Hey! 🎉 I'm thrilled to hear things are working out for you now. If you ever need further assistance or have more questions along the way, don't hesitate to reach out. Remember, the Ultralytics team and the YOLOv8 community are here to help. Happy detecting!

[Abhisin90]

HI!
I am using Yolov8 for classification of images
I trained my model and validated it, by using these methods model.train() & model.val()
But I am finding difficulty in how to find the testing accuracy and also how to get the classification report for the model class wise for images like f1 score,precision,recall & confusion matrix

[glenn-jocher]

Hey there! 👋

To get the testing accuracy and classification reports like F1 score, precision, recall, and confusion matrix, you can first predict on your test dataset using the predict() method. After obtaining the predictions, you can utilize Python libraries such as sklearn to compute these metrics.

Here's a quick snippet on how you could approach it:

from ultralytics import YOLO
from sklearn.metrics import classification_report, confusion_matrix

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

# Predict on your test dataset. Assuming `test_images` is a list of your test image paths
predictions = model.predict(test_images)

# Assuming `true_labels` is a list of your true labels for the test set
predicted_labels = [pred[0].pred.argmax(-1).cpu().numpy() for pred in predictions]  # Get most likely class

# Now use sklearn to get the classification report and confusion matrix
print(classification_report(true_labels, predicted_labels))
print(confusion_matrix(true_labels, predicted_labels))

Make sure to adjust test_images and true_labels with your actual test data. This will get you started on evaluating your model performance class-wise.

Hope this helps! If you have further questions, feel free to ask. 😊

[BarneyEvans]

Does YOLOV8 have any inherent object tracking across images?

[pderrenger]

Hi there! YOLOv8 itself is primarily built for object detection and doesn't inherently support object tracking across images. For tracking, you'd likely need to integrate YOLOv8 with a tracking algorithm like SORT or DeepSORT.

If you're interested in exploring object tracking with YOLO models, you might consider using YOLOv8 in combination with other tracking libraries to set up the tracking pipeline. Here’s a basic example using Python:

from ultralytics import YOLO
import cv2

# Initialize YOLOv8
model = YOLO('yolov8n.pt')

# Load your video
cap = cv2.VideoCapture('path_to_video.mp4')

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

    # Detect objects in the frame
    results = model(frame)

    # Apply your tracking logic here
    # This part would typically involve integrating with a tracking algorithm
    # to track detected objects across frames

    # Display results
    results.show()

cap.release()
cv2.destroyAllWindows()

This snippet shows how you can perform detection on each frame. For tracking, you’ll have to integrate the results with a tracking algorithm. Hope this helps! 😊

[ElDestapador]

Have an issues with class loading and labels.
For some reason yolov8n can't find a labels in my dataset (labels and images stored in different folders).
Is it requires config or something else?
Im also use a second dataset for validation and idk how to make a specific path for them.

[pderrenger]

Hi there! It sounds like you're having some trouble with dataset configuration for your YOLOv8n model.

For YOLO models, you need to ensure that your dataset configuration file (yaml file) correctly specifies the paths to your images and labels. The structure typically looks something like this:

train: ./data/train/images
val: ./data/val/images
test: ./data/test/images

nc: number_of_classes  # specify the number of classes here
names: ['class1', 'class2', ...]  # list all class names here

Make sure the paths in your yaml file accurately reflect where your images and label folders are stored. If your labels are in a separate directory, you should specify that directory directly in the path.

For handling a second dataset for validation, you can specify this under the val key in your YAML configuration file. Just ensure the path points to your validation dataset images.

Here’s a quick example to modify paths if you have a separate validation dataset:

train: path/to/your/train/images
val: path/to/your/validation/images

Make sure your labels are stored in the same directory structure as your images and are correctly linked in your annotation files.

If you've configured everything correctly and the issue persists, double-check the format of your label files to ensure they match what YOLO expects. 😊

[mayurkatre18]

from ultralytics import YOLO

model = YOLO("best.pt")
model.export(format='tflite')'''

Hi, I have to export model into tflite format but the error I'm getting is as given below.

TensorFlow SavedModel: export failure ❌ 19.1s: generic_type: cannot initialize type "StatusCode": an object with that name is already defined

ImportError Traceback (most recent call last)
in <cell line: 4>()
2
3 model = YOLO("/content/runs/segment/train/weights/best.pt")
----> 4 model.export(format='tflite')

11 frames
/usr/local/lib/python3.10/dist-packages/tensorflow_lite_support/python/task/vision/core/tensor_image.py in
17
18 from tensorflow_lite_support.python.task.vision.core import color_space_type
---> 19 from tensorflow_lite_support.python.task.vision.core.pybinds import image_utils
20
21

ImportError: generic_type: cannot initialize type "StatusCode": an object with that name is already defined.

Please give suggestion on this.

[glenn-jocher]

Hi there! It looks like you're encountering an ImportError related to TensorFlow Lite's Python bindings. This issue might be due to conflicting TensorFlow versions or multiple installations.

Here are a couple of steps you can try to resolve this issue:

1. Ensure a clean environment: Sometimes, previous installations can cause conflicts. Consider creating a new virtual environment and reinstalling the necessary packages:

   python -m venv venv
   source venv/bin/activate  # On Windows use `venv\Scripts\activate`
   pip install ultralytics tensorflow

2. Check for multiple TensorFlow installations: Run pip list | grep tensorflow to see if multiple TensorFlow-related packages are installed and ensure that only the necessary TensorFlow packages are installed.

3. Reinstall TensorFlow Lite Support: If the issue persists, try reinstalling the TensorFlow Lite Support package:

   pip uninstall tensorflow-lite-support
   pip install tensorflow-lite-support

If these steps don't resolve the issue, please provide more details about your environment (OS, Python version, TensorFlow version), and I'll be happy to help further! 😊

[mayurkatre18]

from ultralytics import YOLO

model = YOLO("best.pt")
model.export(format='tflite')'''

Hi, I have to export model into tflite format but the error I'm getting is as given below.

TensorFlow SavedModel: export failure ❌ 19.1s: generic_type: cannot initialize type "StatusCode": an object with that name is already defined

ImportError Traceback (most recent call last)
in <cell line: 4>()
2
3 model = YOLO("/content/runs/segment/train/weights/best.pt")
----> 4 model.export(format='tflite')

11 frames
/usr/local/lib/python3.10/dist-packages/tensorflow_lite_support/python/task/vision/core/tensor_image.py in
17
18 from tensorflow_lite_support.python.task.vision.core import color_space_type
---> 19 from tensorflow_lite_support.python.task.vision.core.pybinds import image_utils
20
21

ImportError: generic_type: cannot initialize type "StatusCode": an object with that name is already defined.

Please give suggestion on this.

[pderrenger]

Hi there! It looks like you're encountering an ImportError related to TensorFlow Lite's Python bindings during the export process. This issue might be due to conflicting TensorFlow versions or duplicate installations.

Here are a couple of steps you can try to resolve this issue:

1. Ensure a Clean Environment: Sometimes, previous installations can cause conflicts. Consider creating a new virtual environment and reinstall the necessary packages:

   python -m venv venv
   source venv/bin/activate  # On Windows use `venv\Scripts\activate`
   pip install ultralytics

2. Reinstall TensorFlow: There might be a version conflict or a corrupted installation of TensorFlow. Try reinstalling it:

   pip uninstall tensorflow
   pip install tensorflow

3. Check for Duplicate Installations: Ensure that there are no duplicate TensorFlow installations that might be causing the issue. You can list installed packages with:

   pip list

After setting up a clean environment and ensuring the correct installations, try exporting the model again. If the problem persists, please provide more details about your setup (like TensorFlow version and system details), and I'll be happy to help further!

For more detailed guidance on exporting YOLOv8 models to TFLite, you can also check out our TFLite integration guide. 😊

[mayurkatre18]

Yes I have install necessary packages only. And I'm training this model on google collab so it is clear environment only. Help me with this.

[pderrenger]

Hello! Thanks for reaching out and providing details about your setup on Google Colab. It seems like the issue might be related to specific TensorFlow or TensorFlow Lite versions installed in your Colab environment.

Here's a quick suggestion to try:

• Ensure that your TensorFlow installation is up-to-date and compatible with TensorFlow Lite. You can update TensorFlow directly in your Colab notebook with the following commands:

!pip install --upgrade tensorflow

• After updating, try exporting your model again:

from ultralytics import YOLO

model = YOLO("best.pt")
model.export(format='tflite')

If the issue persists, it could be helpful to check for any specific TensorFlow Lite dependencies or version conflicts. Sometimes, a fresh runtime (use 'Runtime' -> 'Restart runtime' in Colab) can also help clear up environment issues.

Let me know if this helps or if you're still facing problems! 😊

[clementguerin1]

is it possible to convert a dataset for yolov8 detection into yolov8-cls ?

[pderrenger]

Yes, you can convert a dataset from YOLOv8 detection format to YOLOv8-cls (classification) format, but it requires some adjustments since these tasks handle data differently. Detection models require bounding boxes, while classification models need only class labels for the whole image.

Here’s a basic approach:

1. Simplify Labels: Convert your detection dataset labels from [class, x_center, y_center, width, height] to just [class] for each image.
2. Prepare Images: Ensure each image primarily contains the object of the class labeled, as classification models predict the dominant object class in the image.

This process involves scripting to adjust your dataset format accordingly. Here's a quick Python snippet to illustrate converting a single annotation:

# Example of converting detection annotation to classification
detection_label = [0, 0.5, 0.5, 0.4, 0.4]  # [class, x_center, y_center, width, height]
classification_label = [detection_label[0]]  # Keep only the class

# Save the new label to a file or use it as needed
print("Classification label:", classification_label)

For a full dataset conversion, you'd iterate over all annotations and adjust them similarly. If you need further assistance or a more detailed guide, feel free to ask! 😊

[Mahyar426]

Hi!
I have trained different versions of YOLOv8, and I have stored the trained models. But, when I want to use these trained models in another code to test the images, it will load pretrained model with default classes. How should I save and then call the model?
Thanks!

[pderrenger]

@Mahyar426 hi!

To ensure your trained YOLOv8 models retain their custom classes when loading them for inference, you need to save both the model weights and the associated configuration file. Here’s a step-by-step guide:

1. Save the Model: When you finish training, save the model using the save method, which will store both the weights and the configuration.

   model.save("path/to/custom_model.pt")

2. Load the Model for Inference: When loading the model for inference, ensure you load the saved model file.

   from ultralytics import YOLO
   
   # Load the custom-trained model
   model = YOLO("path/to/custom_model.pt")
   
   # Run inference
   results = model("path/to/image.jpg")

This approach ensures that the model retains the custom classes and configurations used during training. For more detailed information, you can refer to the Ultralytics documentation.

Happy coding! 🚀

[roscha10]

Hi! I am currently involved in developing a vehicle detection system, with a particular focus on determining whether vehicles are parked or in motion through pixel speed estimation. I have been experimenting with the speed_estimator function, in terms of both kilometers per hour and pixels per frame, but so far, I have not achieved satisfactory results.

Could any of you suggest advanced methodologies or configuration adjustments that could improve the accuracy of the detection? Any recommendations on libraries, algorithms, or alternative approaches would also be greatly appreciated.

I thank you in advance for any guidance or advice you can provide.

Best regards.

[glenn-jocher]

Hello,

Thank you for reaching out with your query on vehicle detection and speed estimation using the speed_estimator function. To enhance the accuracy of your system, you might consider a few advanced methodologies and adjustments:

1. Model Fine-tuning: If you haven't already, fine-tuning your YOLOv8 model on a dataset specifically annotated with vehicle speeds and states (parked or in motion) could significantly improve detection accuracy.

2. Optical Flow Techniques: For estimating pixel speed, optical flow methods can be very effective. Libraries like OpenCV offer functions like calcOpticalFlowFarneback, which might provide more precise speed estimations.

3. Data Augmentation: Incorporating variations in vehicle speeds and lighting conditions during training can help the model generalize better over different real-world scenarios.

4. Temporal Models: Consider using LSTM networks or 3D ConvNets that can leverage temporal information across frames to better estimate speeds and detect motion.

5. Ensemble Methods: Combining predictions from multiple models or different configurations of the same model can sometimes yield better results.

For libraries, aside from OpenCV, you might look into PyTorch and TensorFlow for implementing and training any deep learning models. Both frameworks support the advanced techniques mentioned above and are compatible with YOLOv8.

I hope these suggestions help you enhance your vehicle detection system. If you have further questions or need more detailed assistance, feel free to ask.

[roscha10]

Muchas gracias! def plot_box_and_track(self, track_id, box, cls, track): """Plots track and bounding box.""" speed = self.dist_data.get(track_id, 0) status_label = "Stopped" if speed < 1 else f"Moving at {speed:.2f} px/frame" # rango de confianza bbox_color = (0, 255, 0) if speed < 1 else (0, 0, 255) # Draw bounding box cv2.rectangle(self.im0, (int(box[0]), int(box[1])), (int(box[2]), int(box[3])), bbox_color, 2) cv2.putText(self.im0, status_label, (int(box[0]), int(box[1]) - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, bbox_color, 2) cv2.polylines(self.im0, [self.trk_pts], isClosed=False, color= bbox_color, thickness=1) cv2.circle(self.im0, (int(track[-1][0]), int(track[-1][1])), 5, bbox_color, -1) print(f"Plotted bounding box at ({box[0]}, {box[1]}, {box[2]}, {box[ 3]}) with label '{status_label}'") def calculate_speed(self, trk_id, track): """Calculates the speed of an object in pixels per frame.""" if len(track) < 2: self.dist_data[trk_id] = 0 return previous_point = track[-2] current_point = track[-1] distance = np.sqrt((current_point[0] - previous_point[0]) ** 2 + ( current_point[1] - previous_point[1]) ** 2) self.dist_data[trk_id] = distance This was the modification I made and it works quite well. Now I'm having problems when vehicles start moving away from the camera, then the bounding boxes get smaller and start determining that the vehicle is not moving. I'm working in it Thank you very much for taking the time and responding, I am really fascinated with everything you are doing, incredible. I like it a lot, thank you El lun, 3 jun 2024 a la(s) 4:22 p.m., Glenn Jocher ***@***.***) escribió:

…

Hello, Thank you for reaching out with your query on vehicle detection and speed estimation using the speed_estimator function. To enhance the accuracy of your system, you might consider a few advanced methodologies and adjustments: 1. *Model Fine-tuning:* If you haven't already, fine-tuning your YOLOv8 model on a dataset specifically annotated with vehicle speeds and states (parked or in motion) could significantly improve detection accuracy. 2. *Optical Flow Techniques:* For estimating pixel speed, optical flow methods can be very effective. Libraries like OpenCV offer functions like calcOpticalFlowFarneback, which might provide more precise speed estimations. 3. *Data Augmentation:* Incorporating variations in vehicle speeds and lighting conditions during training can help the model generalize better over different real-world scenarios. 4. *Temporal Models:* Consider using LSTM networks or 3D ConvNets that can leverage temporal information across frames to better estimate speeds and detect motion. 5. *Ensemble Methods:* Combining predictions from multiple models or different configurations of the same model can sometimes yield better results. For libraries, aside from OpenCV, you might look into PyTorch and TensorFlow for implementing and training any deep learning models. Both frameworks support the advanced techniques mentioned above and are compatible with YOLOv8. I hope these suggestions help you enhance your vehicle detection system. If you have further questions or need more detailed assistance, feel free to ask. — Reply to this email directly, view it on GitHub <#10285 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/A7E5FJOWIKZXFJUAIH6VF2LZFTGA3AVCNFSM6AAAAABGWINEX6VHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TMNJTHEZDA> . You are receiving this because you commented.Message ID: ***@***.*** com>

[glenn-jocher]

¡Hola! Gracias por compartir tus modificaciones y por tus amables palabras. 😊

En cuanto al problema que mencionas con los vehículos que se alejan de la cámara, una posible solución podría ser ajustar la escala de los bounding boxes en función de la profundidad estimada o la perspectiva. Esto podría ayudar a mantener la consistencia del tamaño de los bounding boxes a medida que los vehículos se mueven.

Otra opción sería implementar un filtro de seguimiento más robusto que pueda adaptarse a cambios rápidos en el tamaño y la posición de los objetos, como un filtro de Kalman, que es común en aplicaciones de seguimiento.

Espero que estas sugerencias te sean útiles. ¡Sigue experimentando y no dudes en preguntar si necesitas más ayuda! 🚀

—
Glenn Jocher

[roscha10]

Muchisimas gracias la verdad tengo un millon de dudas, si me dices que te puedo preguntar te puedo dar un listado de preguntas enorme, es broma! De verdad que estoy gratamente sorprendido por la comunidad, la atención, la documentación, muy interesante todo, y la verdad que muy agradecido, tienes un entusiasta en potencia con todo el mundo del computer vision, gracias a ustedes! En estos momentos estoy trabajando como te comente principalmente, en la detección de colisiones (aun me falta por mejorar, pero va bastante bien), vehiculos en excesos de velocidad, la detección de la senda peatonal crosswalk, esto me va a servir para detectar las infracciones, me gustaría empezar a trabajar cuando los vehículos se pasen un semáforo en rojo. bueno como te decía muchas dudas, pero esas son las principales donde estoy trabajando y donde quiero empezar a trabajar! cualquier ayuda, tips, alguna función que me pueda servir, o cualquier cosa con la que me pueda guiar, estaré muy atento y más que agradecido. Estoy abierto también a cualquier colaboración, o algo que pueda aportar, por mi experiencia pues no será mucho, pero bueno, las ganas son enormes! Saludos! __ Roberto Schaefer

…

__ El mar, 4 jun 2024 a la(s) 9:58 a.m., Glenn Jocher ***@***.***) escribió:

¡Hola! Gracias por compartir tus modificaciones y por tus amables palabras. 😊 En cuanto al problema que mencionas con los vehículos que se alejan de la cámara, una posible solución podría ser ajustar la escala de los bounding boxes en función de la profundidad estimada o la perspectiva. Esto podría ayudar a mantener la consistencia del tamaño de los bounding boxes a medida que los vehículos se mueven. Otra opción sería implementar un filtro de seguimiento más robusto que pueda adaptarse a cambios rápidos en el tamaño y la posición de los objetos, como un filtro de Kalman, que es común en aplicaciones de seguimiento. Espero que estas sugerencias te sean útiles. ¡Sigue experimentando y no dudes en preguntar si necesitas más ayuda! 🚀 — Glenn Jocher — Reply to this email directly, view it on GitHub <#10285 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/A7E5FJLN5VEELLOELI445RLZFXBYFAVCNFSM6AAAAABGWINEX6VHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TMNRVGM2TG> . You are receiving this because you commented.Message ID: ***@***.*** com>

[glenn-jocher]

@roscha10 ¡Hola Roberto!

Muchas gracias por tus amables palabras y por compartir tu entusiasmo por la visión por computadora. Es genial escuchar sobre tus proyectos en detección de colisiones y otras aplicaciones de tráfico. 🚗💡

Para tus proyectos actuales y futuros, te recomendaría explorar las capacidades de seguimiento y detección de YOLOv8, que pueden ser muy útiles para detectar infracciones como el paso de semáforos en rojo. Además, el uso de filtros como Kalman, mencionado por Glenn, puede mejorar la precisión en la detección de objetos en movimiento.

Si tienes preguntas específicas o necesitas consejos sobre funciones específicas, no dudes en preguntar. La comunidad está aquí para ayudarte. También, cualquier contribución o idea que quieras compartir será bienvenida; las ganas y el entusiasmo son tan importantes como la experiencia.

¡Saludos y éxito en tus proyectos!

[roscha10]

¡Muy interesante lo que dices! Si tienes algo que me puedas compartir en cuanto a la detección de semáforos en rojo, sería genial, y he estado estudiando Kalman para mejorar la precisión en cuanto a la detección! cualquier documentacion especifica puede ser muy util para mi! estoy buscando seguir aprendiendo El mié, 5 jun 2024 a la(s) 12:49 a.m., Glenn Jocher ( ***@***.***) escribió:

…

@roscha10 <https://github.com/roscha10> ¡Hola Roberto! Muchas gracias por tus amables palabras y por compartir tu entusiasmo por la visión por computadora. Es genial escuchar sobre tus proyectos en detección de colisiones y otras aplicaciones de tráfico. 🚗💡 Para tus proyectos actuales y futuros, te recomendaría explorar las capacidades de seguimiento y detección de YOLOv8, que pueden ser muy útiles para detectar infracciones como el paso de semáforos en rojo. Además, el uso de filtros como Kalman, mencionado por Glenn, puede mejorar la precisión en la detección de objetos en movimiento. Si tienes preguntas específicas o necesitas consejos sobre funciones específicas, no dudes en preguntar. La comunidad está aquí para ayudarte. También, cualquier contribución o idea que quieras compartir será bienvenida; las ganas y el entusiasmo son tan importantes como la experiencia. ¡Saludos y éxito en tus proyectos! — Reply to this email directly, view it on GitHub <#10285 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/A7E5FJJFIANACWM4GE6MMZDZF2KG5AVCNFSM6AAAAABGWINEX6VHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TMNZSHEYTI> . You are receiving this because you were mentioned.Message ID: ***@***.*** com>

[pderrenger]

@roscha10 ¡Hola Roberto!

Para la detección de semáforos en rojo, te recomiendo utilizar YOLOv8 con entrenamiento específico para reconocer semáforos en diferentes estados. Puedes entrenar un modelo personalizado con imágenes de semáforos en rojo para mejorar la precisión en este tipo de detección.

En cuanto al filtro de Kalman, es excelente para mejorar la precisión en la detección de objetos en movimiento, especialmente en aplicaciones de seguimiento en tiempo real. Aunque no tenemos documentación específica sobre la integración de Kalman con YOLOv8, puedes encontrar recursos generales sobre filtros de Kalman y su aplicación en sistemas de visión por computadora que podrían ser útiles.

Si tienes más preguntas o necesitas ayuda con tu proyecto, no dudes en preguntar. ¡Éxito en tus estudios y proyectos!

Saludos,
[Su Nombre]

[songucci1]

Hello, I use the yolov8n, yolov8s, yolov8m models to identify thermal people, but when I train, when the results of the above 3 models come out, the yolov8n model has Precision=0.8645568 while yolov8s only has 0.8404626 and yolov8m only has there are 0.7639084.
And YOLOv8n's F1-score = 0.813847314 but yolov8m is only 0.749772217 lower. I don't understand why yolov8m's index is lower than the other two?
The results of the survey are as below:
Model Precision Recall mAP@50 mAP@50-95 F1-score
YOLOv8n 0.8645568 0.8087432 0.846453 0.5225582 0.813847314
YOLOv8s 0.8404626 0.8252416 0.8580878 0.5202562 0.829314605
YOLOv8m 0.7639084 0.7513488 0.7557938 0.4387772 0.749772217

[songucci1]

hi, do you have architectural images of the 3 YOLOv8 models n, s, m? I need some pictures of the architecture of these 3 models, do you have them? Thanks

[pderrenger]

@songucci1 hello! Thank you for your interest in the YOLOv8 models. Currently, we don't have specific architectural images for the YOLOv8n, YOLOv8s, and YOLOv8m models directly available. However, you can explore the detailed architecture and layer configurations by loading the models and inspecting them using the model.info() method in the Ultralytics library.

Here's a quick example of how you can do this in Python:

from ultralytics import YOLO

# Load the YOLOv8n model
model_n = YOLO("yolov8n.pt")
model_n.info()

# Load the YOLOv8s model
model_s = YOLO("yolov8s.pt")
model_s.info()

# Load the YOLOv8m model
model_m = YOLO("yolov8m.pt")
model_m.info()

This will provide you with a detailed summary of each model's architecture, including the layers and parameters.

For more information on the YOLOv8 models and their capabilities, you can refer to the YOLOv8 documentation.

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

[songucci1]

hello, can you tell me the difference when training 30 images, 300 images and 3000 images. If there is a difference, what is that difference? Thanks

[GaviraghiElia]

hello, can you tell me the difference when training 30 images, 300 images and 3000 images. If there is a difference, what is that difference? Thanks

It depends on the task and the dataset, but in general a larger data set can help you generalize better: the more (quality) images you have relative to the number of classes, better performance you get from your model.

[pderrenger]

Hello! The number of images used for training can significantly impact the performance of your model. Here's a brief overview of the differences you might observe when training with 30, 300, and 3000 images:

Training with 30 Images

• Limited Data: With only 30 images, the model may struggle to generalize well. It might learn to recognize patterns specific to the training set but fail to perform accurately on new, unseen data.
• Overfitting: There's a high risk of overfitting, where the model performs well on the training data but poorly on validation and test data.
• Performance: Precision, recall, and F1-score are likely to be lower due to the lack of diverse examples.

Training with 300 Images

• Improved Generalization: With 300 images, the model has more examples to learn from, which can help improve its ability to generalize to new data.
• Better Performance: You can expect better precision, recall, and F1-score compared to training with only 30 images. However, the model might still benefit from more data.
• Reduced Overfitting: The risk of overfitting decreases as the model has more varied examples to learn from.

Training with 3000 Images

• Significant Improvement: With 3000 images, the model has a substantial amount of data to learn from, leading to better generalization and higher performance metrics.
• High Accuracy: Precision, recall, and F1-score are likely to be significantly higher, as the model can learn from a wide variety of examples.
• Robust Model: The model becomes more robust and capable of handling diverse scenarios, reducing the likelihood of overfitting.

Summary

In general, the more (quality) images you have relative to the number of classes, the better performance you can expect from your model. Larger datasets help the model generalize better and improve its accuracy and robustness.

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

For more detailed information, you can refer to the YOLOv8 documentation.

[YeapChweap]

Hello! I'm using yolov8 and I just can't use it from CLI.

I have installed ultralytics as below

ultralytics.checks()
Ultralytics YOLOv8.2.28 🚀 Python-3.11.9 torch-2.2.1+cu118 CUDA:0 (NVIDIA GeForce RTX 3060 Laptop GPU, 6144MiB)
Setup complete ✅ (16 CPUs, 15.3 GB RAM, 210.1/237.3 GB disk)

but everytime when I want to use the yolo command, it appears like this.

'yolo' is not recognized as an internal or external command operable program or batch file

[glenn-jocher]

Hello! 👋

Thank you for reaching out. It looks like you're encountering an issue with the yolo command not being recognized in your CLI. Let's troubleshoot this together.

Steps to Resolve:

1. Verify Installation Path:
   Ensure that the ultralytics package is installed in your environment and that the yolo command is accessible from your system's PATH. You can check this by running:

   pip show ultralytics

   This should display the installation path of the ultralytics package.

2. Add to PATH:
   If the yolo command is not recognized, it might be due to the PATH not being updated. You can add the installation directory to your PATH. For example, if you're using Windows, you can add the Scripts directory of your Python installation to the PATH environment variable.

3. Reinstall Ultralytics:
   Sometimes, a fresh installation can resolve path issues. Try reinstalling the package:

   pip uninstall ultralytics
   pip install ultralytics

4. Check Python Version:
   Ensure that the Python version you're using is compatible. YOLOv8 supports Python 3.7 to 3.11. You can check your Python version by running:

   python --version

5. Use Full Path:
   As a temporary workaround, you can use the full path to the yolo script. For example:

   python -m ultralytics.yolo

Example Commands:

Here are some example commands you can try once the yolo command is recognized:

• Training:

  yolo train model=yolov8n.pt data=coco128.yaml epochs=100 imgsz=640

• Prediction:

  yolo predict model=yolov8n.pt source='https://ultralytics.com/images/bus.jpg'

If the issue persists, please provide more details or any error messages you encounter. This will help us better understand the problem and provide a more accurate solution.

Feel free to check out our documentation for more information on using YOLOv8.

[Swarnava256]

Hi,

I wanted to know if I can perform an object detection and segmentation (of a specific class)and make inferences in the same video.
I have a set of classes which are all object detection type except for one (this ones a segmentation dataset). I have already trained all the classes even the segmentation one (since I had moved all of them in single train, test and valid folders and modified the '.yaml' file accordingly) using 'yolov8n.yaml' forgetting the fact that 'yolov8n-seg.yaml' would be needed for the segmentation class.
Do I have to re-train all the classes again using the 'yolov8n-seg' model and will that cover the missing segmentation part?

[glenn-jocher]

To perform both object detection and segmentation in the same video, you'll need to re-train using the 'yolov8n-seg' model to cover the segmentation task. This will ensure that your model can handle both tasks effectively.

[dagongge]

Hi,

If I train a model, it can recognize a variety of targets, just like the trained model you provided, which can recognize 80 types of targets. Now I only want to recognize a few targets in a photo instead of all targets. , so how do I write the code?
In addition, there is no target I need among the 80 targets, so I trained a separate model. So how can I write code to use these two models to predict a picture at the same time and display those what goals do I need in one picture at the same time?
Thank you very much!

[glenn-jocher]

@dagongge to address your questions about selective detection and using multiple models:

1. To detect only specific classes from a pre-trained model, you can filter predictions using the classes parameter:

from ultralytics import YOLO

model = YOLO('yolov8n.pt')
results = model(source='image.jpg', classes=[0, 2])  # Only detect person (0) and car (2)

2. To run predictions with two different models on the same image:

model1 = YOLO('yolov8n.pt')  # Pre-trained model
model2 = YOLO('path/to/custom.pt')  # Your custom model

# Run both models
results1 = model1('image.jpg')
results2 = model2('image.jpg')

# Process and visualize results from both models on the same image
for r in results1 + results2:
    r.plot()

For more details on customizing predictions, please see our Predict documentation page.

[dagongge]

ok,thank you very much!

[glenn-jocher]

@dagongge you're welcome! If you have any more questions or need further assistance with Ultralytics YOLO models, feel free to reach out. The community and the Ultralytics team are always here to help!

[johnlockejrr]

If the model performs well and you are happy with it, you can filter by class:

detections = detections[detections.class_id == 0]

or multiple classes you want:

selected_classes = [0, 2, 3]
detections = detections[np.isin(detections.class_id, selected_classes)]

or like this:

from ultralytics import YOLO

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

# Run inference on, filtering to only detect class 1 (parcels)
results = model.predict(classes=[1]) 

[glenn-jocher]

@johnlockejrr thanks for sharing your code example. For better performance and readability, you can also filter detections directly during prediction using the conf parameter to set a confidence threshold:

results = model.predict(source='path/to/image.jpg', conf=0.25, classes=[0, 2, 3])

This filters low-confidence detections and specific classes in a single step, which is more efficient than post-processing the results. For more details on prediction options, see https://docs.ultralytics.com/modes/predict/.

[dagongge]

great!thank you!

[glenn-jocher]

Thank you for your feedback! If you have any more questions or need further assistance, feel free to reach out. The YOLO community and Ultralytics team are always here to help!

[rohith-aiunika]

How does YOLO object tracking identify the same object across different frames?

[glenn-jocher]

@rohith-aiunika yOLO object tracking links detections across frames by combining motion-based techniques (e.g., Kalman filtering), object appearance features, and associating consecutive detections using algorithms like Hungarian matching. This ensures consistent tracking IDs for objects over time. For more details, refer to the Track Mode documentation.

[rohith-aiunika]

The same object in the sequence is being assigned different IDs across frames. For instance, in frame 266, the object has an ID of 208, but in frame 270, it is assigned a different ID.

[glenn-jocher]

Consistency in IDs across frames is typically handled by tracking algorithms, such as DeepSORT, which combine object detections with appearance and motion information. In this case, inconsistent IDs may occur due to lost detections or occlusions. Ensuring robust detections and tuning tracker parameters (e.g., IoU threshold or motion model configurations) should help resolve this. Refer to the Track mode documentation for further guidance.

[rohith-aiunika]

can i use my yolo custom segmentation model to inference and use deepsort algorithm to track my objects?

[glenn-jocher]

@rohith-aiunika yes, you can use your YOLO custom segmentation model for inference and integrate it with DeepSORT to track objects across frames. Load your model for predictions and feed the detections (bounding boxes, confidence, and class) to DeepSORT for tracking. Refer to the Track mode documentation for additional guidance.

[JackEdoubleS]

Hi, I can see the GFLOPs of yolov8 series and yolo11 series. Is that the GFLOPs during training? If it is true, so what is the GFLOPs of these models during inference?

[glenn-jocher]

@JackEdoubleS the GFLOPs listed for the models are typically for inference, not training, as inference metrics are more relevant for real-world deployments. You can refer to the Performance Metrics in the documentation for detailed values, including FLOPs during inference. Let me know if you need further clarification!

[JackEdoubleS]

I would like to know what the GFLOPs of each model is. How can I do it?

[glenn-jocher]

@JackEdoubleS to determine the GFLOPs of a model, you can run model.info() in Python using the Ultralytics framework. This provides details including GFLOPs relevant for inference. For detailed performance metrics, refer to the documentation here: https://docs.ultralytics.com/models/yolov8/. Let me know if you need further assistance!

[ge1mina023]

What is the unit of number of model parameters? Byte? Word?

[glenn-jocher]

@ge1mina023 the unit for the number of model parameters is typically counted as individual parameters (or weights), which are scalars (floating-point numbers). It does not directly translate to bytes or words, but the total memory depends on the data type used (e.g., 4 bytes per float32). Let me know if you need further clarification!

[ge1mina023]

@ge1mina023 the unit for the number of model parameters is typically counted as individual parameters (or weights), which are scalars (floating-point numbers). It does not directly translate to bytes or words, but the total memory depends on the data type used (e.g., 4 bytes per float32). Let me know if you need further clarification!

For example, YOLOv8n-seg has 3.4M parameters. How many floating point numbers does this represent? How many digits are there in the floating point number here?

[glenn-jocher]

@ge1mina023 thank you for your question! YOLOv8n-seg, with 3.4M parameters, represents 3.4 million floating-point numbers. The precision used in typical implementations is 32-bit (float32), meaning each number consists of approximately 7-9 significant digits. Let me know if you have further questions!

[ge1mina023]

Can you roughly explain how the segmentation task trains the bounding box of the target?

[glenn-jocher]

@ge1mina023 in YOLO's segmentation task, bounding boxes are trained alongside segmentation masks. These boxes are generated to tightly enclose the object identified by the segmentation mask. The training process uses labeled data where each object's mask, class, and bounding box are input into the model to predict and refine these outputs. For more details, refer to our segmentation documentation: https://docs.ultralytics.com/tasks/segment/.

[maribalke]

Hi! I have used Yolov8 for my thesis, and I was hoping to include the figure with metric comparisons at the top of this page in my report. I can't find any copyright information, and was wondering if it is sufficient with citations for using the illustration?

[glenn-jocher]

@maribalke thank you for your interest in using Ultralytics YOLOv8! You are welcome to include the figure in your thesis as long as you provide proper attribution. Please cite it using the format provided in our documentation. Let us know if you need further clarification.

[roscha10]

Hola equipo de Ultralytics, Antes que nada, quiero agradecerles por el enorme trabajo que han realizado y continúan realizando. Sus herramientas, modelos y actualizaciones han sido de gran ayuda para la comunidad de visión por computadora, y realmente admiro la dedicación y calidad que ponen en cada aspecto del proyecto. En estos momentos, estoy buscando un proyecto que utilice Ultralytics y que funcione con CUDA, además de integrar PyTorch y Tensor. ¿Conocen algún proyecto, ejemplo o repositorio que cumpla con estas características y pueda servir como referencia para mi propio desarrollo? Cualquier sugerencia o guía que puedan brindarme sería enormemente apreciada. ¡Muchas gracias de antemano por su tiempo y esfuerzo, y felicitaciones nuevamente por su excelente trabajo! Quedo atento a cualquier información que puedan compartir.

[glenn-jocher]

@roscha10 gracias por tus amables palabras. Puedes revisar el repositorio oficial de Ultralytics en GitHub y nuestra documentación de YOLOv8, donde encontrarás ejemplos detallados para integraciones con PyTorch, CUDA y TensorRT. Si necesitas más orientación, no dudes en explorar estos recursos. ¡Buena suerte con tu proyecto!

[roscha10]

Hello Ultralytics team, First of all, I’d like to thank you for the incredible work you’ve been doing. Your tools, models, and updates have greatly benefited the computer vision community, and I truly appreciate the dedication and quality you invest into every part of the project. At the moment, I’m searching for a project that uses Ultralytics and runs with CUDA, as well as integrates PyTorch and Tensor. Could you please let me know if you’re aware of any project, example, or repository that meets these criteria and could serve as a reference for my own development? Any guidance or suggestions you can provide would be greatly appreciated. Thanks in advance for your time and effort, and congratulations once again on your outstanding work! I look forward to any information you might share. El jue, 12 dic 2024 a la(s) 6:36 p.m., Glenn Jocher ( ***@***.***) escribió:

…

@maribalke <https://github.com/maribalke> thank you for your interest in using Ultralytics YOLOv8! You are welcome to include the figure in your thesis as long as you provide proper attribution. Please cite it using the format provided in our documentation <https://docs.ultralytics.com/models/yolov8/#citations-and-acknowledgements>. Let us know if you need further clarification. — Reply to this email directly, view it on GitHub <#10285 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/A7E5FJKD4V56TILX7H2TPFT2FIFV3AVCNFSM6AAAAABGWINEX6VHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTCNJVGAYTONY> . You are receiving this because you were mentioned.Message ID: ***@***.*** com>

[dao027]

Hi,
where can i download previous files like yolov8s-cls.pt? i can only find v11.pt model files on github now

[johnlockejrr]

https://github.com/ultralytics/assets/releases/

[glenn-jocher]

@johnlockejrr the YOLOv8 model files, such as yolov8s-cls.pt, are no longer maintained or hosted directly due to the release of YOLO11. However, you can find archived YOLOv8 files on the Ultralytics Assets Releases page. If you don’t find the specific file you need, consider upgrading to YOLO11 for improved performance and support. Let me know if you have further questions!

[Stark6666]

yolov8 will adjust the size of the image to be detected to 640640, then how do I call the yolo built-in method to achieve an image size of 640640

[glenn-jocher]

To resize input images to 640x640 using YOLOv8's built-in functionality, you can set the imgsz=640 parameter when running the model, either during training or inference. For example:

from ultralytics import YOLO

model = YOLO("yolov8n.pt")
results = model.predict(source="image.jpg", imgsz=640)

For CLI, use the imgsz=640 argument:

yolo predict model=yolov8n.pt source=image.jpg imgsz=640

This ensures YOLOv8 processes images at the desired size. For further details, see the YOLOv8 Docs.

[rajhlinux]

Are there any documentation for Yolo v8 pre-processing & post-processing best practices and how to go about it? Thanks.

[glenn-jocher]

@rajhlinux thank you for your question! For YOLOv8 pre-processing and post-processing best practices, you can refer to the YOLOv8 documentation, which provides detailed guidance on tasks such as detection, segmentation, and pose estimation. For specific examples or further insights, let us know, and we'd be happy to assist!

[johnlockejrr]

Never happened to me untill today to crash my YOLO training:

(yolo-py3.11) incognito@DESKTOP-H1BS9PO:~/yolov8$ yolo task=segment mode=train model=yolo11n-seg.pt data=datasets/sam_40_mss/config.yml epochs=200 imgsz=640 batch=16
Ultralytics 8.3.59 🚀 Python-3.11.0rc1 torch-2.4.1+cu121 CUDA:0 (NVIDIA GeForce RTX 3060, 12288MiB)
engine/trainer: task=segment, mode=train, model=yolo11n-seg.pt, data=datasets/sam_40_mss/config.yml, epochs=200, time=None, patience=100, batch=16, imgsz=640, save=True, save_period=-1, cache=False, device=None, workers=8, project=None, name=train20, exist_ok=False, pretrained=True, optimizer=auto, verbose=True, seed=0, deterministic=True, single_cls=False, rect=False, cos_lr=False, close_mosaic=10, resume=False, amp=True, fraction=1.0, profile=False, freeze=None, multi_scale=False, overlap_mask=True, mask_ratio=4, dropout=0.0, val=True, split=val, save_json=False, save_hybrid=False, conf=None, iou=0.7, max_det=300, half=False, dnn=False, plots=True, source=None, vid_stride=1, stream_buffer=False, visualize=False, augment=False, agnostic_nms=False, classes=None, retina_masks=False, embed=None, show=False, save_frames=False, save_txt=False, save_conf=False, save_crop=False, show_labels=True, show_conf=True, show_boxes=True, line_width=None, format=torchscript, keras=False, optimize=False, int8=False, dynamic=False, simplify=True, opset=None, workspace=None, nms=False, lr0=0.01, lrf=0.01, momentum=0.937, weight_decay=0.0005, warmup_epochs=3.0, warmup_momentum=0.8, warmup_bias_lr=0.1, box=7.5, cls=0.5, dfl=1.5, pose=12.0, kobj=1.0, nbs=64, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, degrees=0.0, translate=0.1, scale=0.5, shear=0.0, perspective=0.0, flipud=0.0, fliplr=0.5, bgr=0.0, mosaic=1.0, mixup=0.0, copy_paste=0.0, copy_paste_mode=flip, auto_augment=randaugment, erasing=0.4, crop_fraction=1.0, cfg=None, tracker=botsort.yaml, save_dir=runs/segment/train20
Overriding model.yaml nc=80 with nc=2

                   from  n    params  module                                       arguments
  0                  -1  1       464  ultralytics.nn.modules.conv.Conv             [3, 16, 3, 2]
  1                  -1  1      4672  ultralytics.nn.modules.conv.Conv             [16, 32, 3, 2]
  2                  -1  1      6640  ultralytics.nn.modules.block.C3k2            [32, 64, 1, False, 0.25]
  3                  -1  1     36992  ultralytics.nn.modules.conv.Conv             [64, 64, 3, 2]
  4                  -1  1     26080  ultralytics.nn.modules.block.C3k2            [64, 128, 1, False, 0.25]
  5                  -1  1    147712  ultralytics.nn.modules.conv.Conv             [128, 128, 3, 2]
  6                  -1  1     87040  ultralytics.nn.modules.block.C3k2            [128, 128, 1, True]
  7                  -1  1    295424  ultralytics.nn.modules.conv.Conv             [128, 256, 3, 2]
  8                  -1  1    346112  ultralytics.nn.modules.block.C3k2            [256, 256, 1, True]
  9                  -1  1    164608  ultralytics.nn.modules.block.SPPF            [256, 256, 5]
 10                  -1  1    249728  ultralytics.nn.modules.block.C2PSA           [256, 256, 1]
 11                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']
 12             [-1, 6]  1         0  ultralytics.nn.modules.conv.Concat           [1]
 13                  -1  1    111296  ultralytics.nn.modules.block.C3k2            [384, 128, 1, False]
 14                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']
 15             [-1, 4]  1         0  ultralytics.nn.modules.conv.Concat           [1]
 16                  -1  1     32096  ultralytics.nn.modules.block.C3k2            [256, 64, 1, False]
 17                  -1  1     36992  ultralytics.nn.modules.conv.Conv             [64, 64, 3, 2]
 18            [-1, 13]  1         0  ultralytics.nn.modules.conv.Concat           [1]
 19                  -1  1     86720  ultralytics.nn.modules.block.C3k2            [192, 128, 1, False]
 20                  -1  1    147712  ultralytics.nn.modules.conv.Conv             [128, 128, 3, 2]
 21            [-1, 10]  1         0  ultralytics.nn.modules.conv.Concat           [1]
 22                  -1  1    378880  ultralytics.nn.modules.block.C3k2            [384, 256, 1, True]
 23        [16, 19, 22]  1    683830  ultralytics.nn.modules.head.Segment          [2, 32, 64, [64, 128, 256]]
YOLO11n-seg summary: 355 layers, 2,842,998 parameters, 2,842,982 gradients, 10.4 GFLOPs

Transferred 510/561 items from pretrained weights
Freezing layer 'model.23.dfl.conv.weight'
AMP: running Automatic Mixed Precision (AMP) checks...
AMP: checks passed ✅
train: Scanning /home/incognito/yolov8/datasets/sam_40_mss/train/labels.cache... 627 images, 1 backgrounds, 0 corrupt: 100%|██████████| 627/627 [00:00<?, ?it/s]
val: Scanning /home/incognito/yolov8/datasets/sam_40_mss/val/labels.cache... 209 images, 0 backgrounds, 0 corrupt: 100%|██████████| 209/209 [00:00<?, ?it/s]
Plotting labels to runs/segment/train20/labels.jpg...
optimizer: 'optimizer=auto' found, ignoring 'lr0=0.01' and 'momentum=0.937' and determining best 'optimizer', 'lr0' and 'momentum' automatically...
optimizer: AdamW(lr=0.001667, momentum=0.9) with parameter groups 90 weight(decay=0.0), 101 weight(decay=0.0005), 100 bias(decay=0.0)
Image sizes 640 train, 640 val
Using 8 dataloader workers
Logging results to runs/segment/train20
Starting training for 200 epochs...

      Epoch    GPU_mem   box_loss   seg_loss   cls_loss   dfl_loss  Instances       Size
      1/200      6.05G      3.473      5.374      3.357      2.547       1076        640:  45%|████▌     | 18/40 [00:09<00:11,  1.86it/s]
Traceback (most recent call last):
  File "/home/incognito/yolov8/yolo-py3.11/bin/yolo", line 8, in <module>
    sys.exit(entrypoint())
             ^^^^^^^^^^^^
  File "/home/incognito/yolov8/yolo-py3.11/lib/python3.11/site-packages/ultralytics/cfg/__init__.py", line 973, in entrypoint
    getattr(model, mode)(**overrides)  # default args from model
    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/incognito/yolov8/yolo-py3.11/lib/python3.11/site-packages/ultralytics/engine/model.py", line 806, in train
    self.trainer.train()
  File "/home/incognito/yolov8/yolo-py3.11/lib/python3.11/site-packages/ultralytics/engine/trainer.py", line 207, in train
    self._do_train(world_size)
  File "/home/incognito/yolov8/yolo-py3.11/lib/python3.11/site-packages/ultralytics/engine/trainer.py", line 362, in _do_train
    for i, batch in pbar:
  File "/home/incognito/yolov8/yolo-py3.11/lib/python3.11/site-packages/tqdm/std.py", line 1181, in __iter__
    for obj in iterable:
  File "/home/incognito/yolov8/yolo-py3.11/lib/python3.11/site-packages/ultralytics/data/build.py", line 48, in __iter__
    yield next(self.iterator)
          ^^^^^^^^^^^^^^^^^^^
  File "/home/incognito/yolov8/yolo-py3.11/lib/python3.11/site-packages/torch/utils/data/dataloader.py", line 630, in __next__
    data = self._next_data()
           ^^^^^^^^^^^^^^^^^
  File "/home/incognito/yolov8/yolo-py3.11/lib/python3.11/site-packages/torch/utils/data/dataloader.py", line 1344, in _next_data
    return self._process_data(data)
           ^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/incognito/yolov8/yolo-py3.11/lib/python3.11/site-packages/torch/utils/data/dataloader.py", line 1370, in _process_data
    data.reraise()
  File "/home/incognito/yolov8/yolo-py3.11/lib/python3.11/site-packages/torch/_utils.py", line 706, in reraise
    raise exception
RuntimeError: Caught RuntimeError in pin memory thread for device 0.
Original Traceback (most recent call last):
  File "/home/incognito/yolov8/yolo-py3.11/lib/python3.11/site-packages/torch/utils/data/_utils/pin_memory.py", line 38, in do_one_step
    data = pin_memory(data, device)
           ^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/incognito/yolov8/yolo-py3.11/lib/python3.11/site-packages/torch/utils/data/_utils/pin_memory.py", line 69, in pin_memory
    clone.update({k: pin_memory(sample, device) for k, sample in data.items()})
                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/incognito/yolov8/yolo-py3.11/lib/python3.11/site-packages/torch/utils/data/_utils/pin_memory.py", line 69, in <dictcomp>
    clone.update({k: pin_memory(sample, device) for k, sample in data.items()})
                     ^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/home/incognito/yolov8/yolo-py3.11/lib/python3.11/site-packages/torch/utils/data/_utils/pin_memory.py", line 59, in pin_memory
    return data.pin_memory(device)
           ^^^^^^^^^^^^^^^^^^^^^^^
RuntimeError: CUDA error: out of memory
CUDA kernel errors might be asynchronously reported at some other API call, so the stacktrace below might be incorrect.
For debugging consider passing CUDA_LAUNCH_BLOCKING=1
Compile with `TORCH_USE_CUDA_DSA` to enable device-side assertions.

The RAM, GPU RAM seem ok. The dataset is not that large, about 836 pages of some manuscripts with labels.

[glenn-jocher]

@johnlockejrr the error indicates a RuntimeError: CUDA error: out of memory, which suggests your GPU memory is insufficient for the batch size or model size during training. Try reducing the batch=16 parameter to a smaller value, such as batch=8 or batch=4, and ensure no other processes are using the GPU by checking with nvidia-smi. If the issue persists, you may need to use a smaller model variant or enable mixed precision training (amp=True). For further guidance, refer to the YOLOv8 training documentation.

[johnlockejrr]

I'll try that. Never happened before. I know the n fits very well in a GPU of 4GB RAM and I have on this one 12Gb so it should fit.

[glenn-jocher]

@johnlockejrr it sounds like a GPU memory issue might not be the root cause here, given your 12GB GPU should handle YOLOv8n comfortably. I recommend verifying your CUDA and PyTorch versions are compatible and ensuring the environment is correctly configured. If the issue persists, please share the exact error message or logs for further guidance.