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.

[ht22a006]

Hi!
I successfully created a dataset that contains only new data, but I don't know how to add new data to an existing dataset. Is it possible to train on the existing dataset as well?

[glenn-jocher]

The learning method in YOLOv8 does not inherently retain information from previous datasets when adding new data. To improve learning efficiency, you can merge the datasets and retrain the model on the combined data. This approach ensures the model learns from both old and new data effectively.

[ht22a006]

I see. So, is this folder structure correct for when I'm training the model?

project
|
|--images
| |--train
| |--existing_data_1.jpg
| |--existing_data_2.jpg
| |--additional_data_1.jpg
| |--additional_data_2.jpg
| |--val
| |--existing_data_3.jpg
| |--existing_data_4.jpg
| |--additional_data_3.jpg
| |--additional_data_4.jpg
|--labels
| |--train
| |--existing_data_1.txt
| |--existing_data_2.txt
| |--additional_data_1.txt
| |--additional_data_2.txt
| |--val
| |--existing_data_3.txt
| |--existing_data_4.txt
| |--additional_data_3.txt
| |--additional_data_4.txt

[glenn-jocher]

@ht22a006 yes, your folder structure looks correct for training with both existing and additional data. Ensure your dataset configuration file points to these directories for training and validation.

[ht22a006]

I was able to add new data to the dataset and train the model! Thank you!

[glenn-jocher]

You're welcome! If you have any more questions or need further assistance, feel free to ask.

[rohith-aiunika]

Hi YOLO Team,

I’ve trained a YOLO model on a custom dataset of 12k images, achieving around 60% accuracy. I recently obtained another custom dataset that contains the same classes as the original dataset which is having 4k images. I’m considering the best approach to improve the model’s performance with this new data.

Would you recommend:

Fine-tuning the existing model on the new dataset?
Merging the new dataset with the original dataset and retraining the model from scratch?
The new dataset varies in size but contains the same classes, and I’m curious about which method would yield better generalization and performance. Any guidance would be appreciated!

Thanks,
Rohith

[glenn-jocher]

@rohith-aiunika hi Rohith,

For improving your model's performance, fine-tuning the existing model on the new dataset is a good starting point. If results aren't satisfactory, consider merging both datasets and retraining from scratch. This approach can enhance generalization by leveraging the combined data.

[rohith-aiunika]

Hi YOLO Team,

I’ve trained a YOLO model on a custom dataset of 12k images, achieving around 60% accuracy. I recently obtained another custom dataset that contains the same classes as the original dataset which is having 4k images. I’m considering the best approach to improve the model’s performance with this new data.

Would you recommend:

Fine-tuning the existing model on the new dataset?
Merging the new dataset with the original dataset and retraining the model from scratch?
The new dataset varies in size but contains the same classes, and I’m curious about which method would yield better generalization and performance.
If it is fine tuning the model, how to fine tune it?
Any guidance would be appreciated!

Thanks,
Rohith

[glenn-jocher]

@rohith-aiunika hi Rohith,

For your scenario, fine-tuning the existing model on the new dataset is often a good approach, especially since the classes are the same. This can help improve performance without starting from scratch. To fine-tune, load your existing model and train it further using the new dataset. You can use the train method with your new data configuration. For more details, you might find the YOLOv8 documentation helpful: https://docs.ultralytics.com/models/yolov8/

[rohith-aiunika]

so is it similar as train?
just we need to replace model with my previous version's best.pt

[glenn-jocher]

Yes, you can fine-tune by loading your previous model's `

[AdySaputra15]

How do I train a YOLOv8 model from zero? i don't want use pre trained model yolov8-seg.pt

[glenn-jocher]

@AdySaputra15 to train a YOLOv8 model from scratch, you can start by loading a model configuration file without pre-trained weights. Use the following command to train your model:

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

This will initialize a new model and train it on your specified dataset. For more details, you can refer to the YOLOv8 documentation.

[AdySaputra15]

where i can get model yolov8n.yaml? because i only can find model yolov8n.pt

[glenn-jocher]

@AdySaputra15 you can find the yolov8n.yaml configuration file in the Ultralytics GitHub repository under the models directory. This file defines the model architecture and can be used to train from scratch.

[SahilMahey]

There are parameters in yolo which you can change to achieve that. Made the freeze = 0 ( this will unfreeze all layers) and if you also interested in not initializing your model with pretrained weights, make pretrained = False. I hope this helps.

[AdySaputra15]

where can I set this parameter?

[glenn-jocher]

@AdySaputra15 you can set the freeze and pretrained parameters in your training script or configuration file. For example, in Python, you can adjust these settings when initializing your model or during training. If you need more details, please refer to the YOLOv8 documentation: https://docs.ultralytics.com/models/yolov8/.

[SahilMahey]

Here it is

from ultralytics import YOLO

# Load the YOLOv8 segmentation model (pre-trained)
model = YOLO('yolov8n-seg.pt')  # You can use other sizes like yolov8m-seg.pt or yolov8l-seg.pt for larger models

# Train the model on your dataset
model.train(data='data.yaml', epochs=20, imgsz=256, batch=32,device = 'cuda', freeze = 0,pretrained = False)

[glenn-jocher]

You can find the yolov8n.yaml file in the Ultralytics GitHub repository under the models directory. This file defines the model architecture for training from scratch.

[AdySaputra15]

do you mean in the directory ultralytics -> cfg -> models -> v8?

[glenn-jocher]

Yes, the yolov8n.yaml file is typically located in the ultralytics/cfg/models/v8 directory. You can use this file to define the model architecture for training from scratch. If you need further assistance, feel free to ask!

[AdySaputra15]

I will try to train my dataset with yolov8n-seg.yaml model, but I see in the yolov8-seg.yaml file there are some parameters such as nc, scales, backbone and head. Do I need to change some parameters there?

[glenn-jocher]

@AdySaputra15 you can modify parameters like nc (number of classes) to match your dataset. Adjusting scales, backbone, and head is optional and depends on your specific needs. For more details, refer to the YOLOv8 documentation.

[SahilMahey]

You will be able to train from 0 with the things I have mentioned. The freeze = 0and pratrained = False ensure that you train from 0. Thus means the model will not have any weights and you will get to train from scratch. I hope this help.

[glenn-jocher]

@SahilMahey to train a YOLOv8 model from scratch, set pretrained=False and ensure freeze=0. This will initialize the model without pre-trained weights. For more details, please visit the YOLOv8 documentation.

[AdySaputra15]

Hello, I have a question. Here I have a project to detect objects with instance segmentation. I use the Yolov8-seg model. I have also created my own dataset with 5 types of classes. My question is, when I want to do training, I don't want my training to stop based on the number of epochs I put as a training parameter. I want my training to stop when my error loss is less than 0.01. How can I set the Yolov8-seg training process based on error loss and not based on epochs?

Thank you very much

[glenn-jocher]

@AdySaputra15 to stop training based on error loss rather than epochs, you can implement a custom callback to monitor the loss and terminate training when it falls below 0.01. Unfortunately, YOLOv8 doesn't natively support this feature, so you'll need to modify the training loop in the code. For more details, please refer to the YOLOv8 documentation: https://docs.ultralytics.com/models/yolov8/.

[GaviraghiElia]

How it's possible that, lowering IoU thresholds, model's Recall could increase?
I note sometimes this phenomenon on several dataset (litter, license plate, face, ecc...)
This is an examples:

metrics = model_pt.val(
    data = data_yaml,
    imgsz = 640,
    split = 'test',
    conf = 0.1
    )

With this output
Class Images Instances Box(P R mAP50 mAP50-95):
all 157 168 0.481 0.435 0.411 0.184

Lowering IoU from 0.6 to 0.2

metrics = model_pt.val(
    data = data_yaml,
    imgsz = 640,
    split = 'test',
    conf = 0.1,
    iou = 0.2
    )

I observe this
Class Images Instances Box(P R mAP50 mAP50-95):
all 157 168 0.465 0.554 0.484 0.219

an increase of Recall. How it's possible?
We are making the IoU parameter more stringent, how does the model have a higher Recall capability?
I have analyzed the results with the predict method always on the test set, and at most with a lower IoU value (and thus more stringent) we reduce the “duplicates,” but we do not “increase” the predicted positives.

[glenn-jocher]

@GaviraghiElia lowering the IoU threshold increases recall because it allows more detections to be considered true positives, even if they overlap less with the ground truth, thus capturing more potential positives.

[GaviraghiElia]

@glenn-jocher thanks, I understood this after reading the code but I think it is not so good: NMS IoU threshold and IoU threshold to consider a TP or FP prediction should be two different parameters. Because maybe I want to adjust NMS IoU threshold to eliminate more duplicate bboxes, but I want to evaluate Recall and Precision at IoU = 0.5 to understand which values in NMS work better.

[glenn-jocher]

Thank you for your feedback. The IoU threshold for NMS and evaluation can indeed be separated to fine-tune performance metrics like Recall and Precision. This flexibility allows you to optimize detection results by adjusting NMS independently from evaluation criteria.

[GaviraghiElia]

Ok, but how to do that? How can I set the IoU value for NMS separately from the IoU value used to decide whether a forecast is a TP or FP with Ultraytics library?
In case it is not possible, this is a serious bug: the IoU parameter for NMS could not be truly tuned.

[glenn-jocher]

Currently, the Ultralytics library does not support setting separate IoU values for NMS and evaluation. This is a known limitation, and we appreciate your feedback. For updates on this feature, please keep an eye on the GitHub repository for future releases.

[NegroAmigo]

Hi, I'm using YOLOv8n for training of errors in FDM 3D Priniting (in educational purposes). I wonder how training process works (or if I can check the training script from Ultralitics). The thing is that I want to compare performance on limited number of epochs with and without augmentations. I don't clearly understand the usage of albumentations at the start of training task. Does this augmentation applies on all images while training? If it does, how do I turn it off completely to compare performance?

[glenn-jocher]

@NegroAmigo to disable augmentations during training with YOLOv8, you can set the augment parameter to False in your training script or command. This will allow you to compare performance with and without augmentations effectively. If you need further assistance, please refer to the YOLOv8 documentation for detailed guidance.

[NegroAmigo]

Hi @glenn-jocher, thank you for your answer. I have disabled augment parameter, but metrcis in evaluation are pretty the same as if YOLO has been trained with default augmentation. Could this be effected by close mosaic? Or I can make conclusion that augmentations doesn't affect overall performance so much?

[glenn-jocher]

It's possible that the close mosaic augmentation is still affecting your results. To ensure all augmentations are disabled, you can set close_mosaic=0 in your training configuration. This will help you better assess the impact of augmentations on your model's performance.

[NegroAmigo]

Hello @glenn-jocher, I've downloaded source code from Ultralitics GitHub. Since You've adviced me to use augment=False, my evaluation figures changed a bit (but I was still thinking that it's due to random nature of model's weights). I've opened the default.yaml and found that parameter augment is used for Predict settings. Does this mean that augmentations were disabled only for predictions? Maybe you can give me a contact of your colleague who can provide deeper explanation on customizing YOLOv8 parameters? Thanks.

[glenn-jocher]

The augment parameter in the default.yaml file is indeed used for prediction settings. To ensure augmentations are disabled during training, you should set augment=False in your training configuration. For further customization, please refer to the YOLOv8 documentation. Unfortunately, we can't provide private support, but feel free to ask any additional questions here.

[ducanh-ho2296]

Dear Ultralytics team, I am writing thesis and there is a part regarding to Pose estimation models, which I want to introduce the YOLOv8-Pose family, I wonder if you still have the image illustrates the YOLOv8-Pose family like this image https://pyimagesearch.com/wp-content/uploads/2023/05/yolov8-model-comparison.png
, as I saw it before in your Github, but since you updated YOLO-Pose to v11, I didn't see it anymore. It would be great if you could share me again the image. Thank you very much in advance!

[glenn-jocher]

@ducanh-ho2296 thank you for your interest in the YOLOv8-Pose models. Unfortunately, we don't have the specific image you mentioned. For the latest resources and visualizations, please refer to our GitHub repository and documentation.

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