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]

Hi !
I have a problem counting an object, the object I want to count is not a solid object.
the project is to count pants in a dryer.
you know that pants can move and change shape.
I already have a model that I made with yolov8 segmentation.
but the result is not good, for example when I put on 33 pants, the counting result is 245 or 95....
can you help me or do you have an idea?
Thanks in advance

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

[GaviraghiElia]

With Yolo v8 (or the other versions) can I access .pt model weights after training on a custom dataset? Thank u :)

[pderrenger]

@GaviraghiElia hello!

Yes, you can absolutely access the .pt model weights after training a YOLOv8 model on a custom dataset. When you train a model using the Ultralytics YOLO framework, the trained model weights are saved in the specified project directory. By default, these weights are saved in a runs/train/exp directory, where exp is the experiment name.

Here's a quick example of how you can load and use these weights in Python:

from ultralytics import YOLO

# Load the trained model
model = YOLO('path/to/best.pt')  # Replace with the path to your trained model

# Run inference with the trained model
results = model('path/to/image.jpg')  # Replace with the path to your image

# Display results
results.show()

And if you prefer using the Command Line Interface (CLI), you can do so as follows:

# Predict using the trained model
yolo predict model=path/to/best.pt source=path/to/image.jpg

For more detailed information on how to train, validate, and use the YOLOv8 models, you can refer to the YOLOv8 documentation.

If you encounter any issues or have further questions, feel free to ask. Happy training! 😊

[GaviraghiElia]

I thank you for your answer, but we don't understand each other: I would like to see, for example, the updated weights of a specific layer of the architecture, not the .pt model.
Currently I think I have been able to see this thanks to state_dict() available in torch.

[pderrenger]

Hello @GaviraghiElia,

Thank you for the clarification! To access and inspect the updated weights of a specific layer in your YOLO model, you can indeed use the state_dict() method provided by PyTorch. This method allows you to retrieve the state dictionary of the model, which contains all the parameters (weights and biases) of the model layers.

Here's a concise example of how you can access and print the weights of a specific layer:

from ultralytics import YOLO

# Load your trained model
model = YOLO('path/to/best.pt')  # Replace with the path to your trained model

# Get the state dictionary
state_dict = model.model.state_dict()

# Print the weights of a specific layer, for example, the first convolutional layer
layer_name = 'model.0.conv.weight'  # Replace with the actual layer name you are interested in
print(state_dict[layer_name])

To find the exact layer names, you can print the keys of the state_dict:

for name, param in state_dict.items():
    print(name)

This will list all the layers in the model, and you can then select the specific layer you are interested in.

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

[GaviraghiElia]

Perfect, that confirms my code! Thank you very much for the confirmation ;)

[pderrenger]

You're welcome! I'm glad to hear that the information was helpful and confirmed your code. If you have any more questions or need further assistance, feel free to ask. The YOLO community and the Ultralytics team are always here to help! 😊

For more detailed information and advanced usage, you can always refer to the Ultralytics YOLOv8 documentation.

Happy coding! 🚀

[Perezz11]

Hi,

Im having a problem when training a detection NN. I have done a classification DNN and it works very good, now i want to do a detection NN but i get the next error:

RuntimeError: Dataset '/home/perez/Desktop/Master_particulas/Segundo_cuatrimestre/TFM/Neural_Network/dataset' error ❌ [Errno 21] Is a directory: '/home/perez/Desktop/Master_particulas/Segundo_cuatrimestre/TFM/Neural_Network/dataset/'

The code I have is the next:

DETECTION

    model_n = YOLO("yolov8n.pt")

    patience = 30
    epochs = 300
    # Train the model
    results_n = model_n.train(
        data="/home/perez/Desktop/Master_particulas/Segundo_cuatrimestre/TFM/Neural_Network/dataset/", epochs=epochs, imgsz=640, task='detect', patience=patience, plots=True)

Do i have to do something in the dataset?

Thanks

[GaviraghiElia]

With: "data" parameter you have to specify the path of YAML file about your dataset in YOLO format, not the entire dataset ;)

[glenn-jocher]

@GaviraghiElia hello,

Thank you for reaching out! It looks like you're encountering an issue with specifying the dataset path for training your detection model. The error you're seeing is because the data parameter expects a path to a YAML file that describes your dataset, not the directory containing the dataset itself.

Here's how you can resolve this:

1. Create a Dataset YAML File: This file should contain paths to your training and validation datasets, along with other necessary information like class names. Below is an example of what this YAML file might look like:

   train: /path/to/your/train/images
   val: /path/to/your/val/images
   
   nc: 1  # number of classes
   names: ['class_name']  # list of class names

2. Update Your Training Script: Point the data parameter to this YAML file instead of the dataset directory.

Here's an updated version of your script:

from ultralytics import YOLO

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

# Define training parameters
patience = 30
epochs = 300

# Train the model
results_n = model_n.train(
    data="/home/perez/Desktop/Master_particulas/Segundo_cuatrimestre/TFM/Neural_Network/dataset.yaml", 
    epochs=epochs, 
    imgsz=640, 
    task='detect', 
    patience=patience, 
    plots=True
)

Make sure to replace /home/perez/Desktop/Master_particulas/Segundo_cuatrimestre/TFM/Neural_Network/dataset.yaml with the actual path to your dataset YAML file.

For more details on how to structure your dataset and YAML file, you can refer to the Ultralytics documentation.

If you continue to experience issues, please ensure you have the latest versions of torch and ultralytics installed. You can update them using:

pip install --upgrade torch ultralytics

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

[SanketPotdar02]

I encountered the error "Courrupt JPEG data: 608 extraneous bytes before marker 0xfe" for several images during training on custom dataset. The images are all in .jpg format. I could open all these photos and they does not seem to be corrupted. Is there any fix for this?

[pderrenger]

@SanketPotdar02 hi there!

Thank you for reaching out. The error message "Corrupt JPEG data: 608 extraneous bytes before marker 0xfe" typically indicates that there are some non-standard bytes in your JPEG files, which might not affect their display but can cause issues during processing.

Here are a few steps to help resolve this:

1. Verify the Issue with the Latest Versions: Ensure you are using the latest versions of torch and ultralytics. You can update them using:

   pip install --upgrade torch ultralytics

2. Re-save the JPEG Files: Sometimes, simply re-saving the images can fix the issue. You can use an image processing library like PIL to re-save the images:

   from PIL import Image
   import os
   
   def resave_images(directory):
       for filename in os.listdir(directory):
           if filename.endswith(".jpg"):
               img_path = os.path.join(directory, filename)
               img = Image.open(img_path)
               img.save(img_path)
   
   resave_images('path/to/your/images')

3. Check for Corrupt Images: You can use a script to identify and possibly fix corrupt images:

   from PIL import Image
   import os
   
   def check_images(directory):
       for filename in os.listdir(directory):
           if filename.endswith(".jpg"):
               img_path = os.path.join(directory, filename)
               try:
                   img = Image.open(img_path)
                   img.verify()  # Verify that it is, in fact, an image
               except (IOError, SyntaxError) as e:
                   print(f"Bad file: {img_path}")
   
   check_images('path/to/your/images')

4. Minimum Reproducible Example: If the issue persists, please provide a minimum reproducible example so we can investigate further. You can find guidelines for creating a minimum reproducible example here.

By following these steps, you should be able to identify and resolve the issue with your JPEG files. If you continue to experience problems, please share more details or the code snippet you're using, and we'll be happy to assist you further.

[roscha10]

I would like if you could provide a little guidance, regarding the counting of people entering a supermarket. I would like to know how I can define the line or how to create a band that determines if they are entering or leaving the supermarket in order to count the people who are inside El jue, 20 jun 2024 a la(s) 9:54 a.m., GaviraghiElia ( ***@***.***) escribió:

…

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. — Reply to this email directly, view it on GitHub <#10285 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/A7E5FJPBKSFDWOWGOHU6B63ZILNIBAVCNFSM6AAAAABGWINEX6VHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TQMRZGQ3TC> . You are receiving this because you were mentioned.Message ID: ***@***.*** com>

[glenn-jocher]

Hello @roscha10,

Thank you for your question! To count people entering and exiting a supermarket, you can use a combination of object detection and tracking. Here's a step-by-step guide to help you set this up:

1. Define the Entry/Exit Line: You can define a virtual line or region in your video frame that people must cross to be counted as entering or exiting. This can be done using simple coordinates.

2. Object Detection: Use YOLOv8 to detect people in each frame of your video. YOLOv8 is highly efficient and accurate for real-time object detection tasks.

3. Object Tracking: Track the detected people across frames to determine their movement direction. You can use trackers like BoT-SORT or ByteTrack, which are supported by YOLOv8.

4. Count Logic: Implement logic to count people based on their movement across the defined line. If a person crosses the line from one side to the other, increment the count for entering or exiting accordingly.

Here’s a basic example in Python to get you started:

import cv2
from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO("yolov8n.pt")

# Define the entry/exit line coordinates
line_coords = [(100, 200), (400, 200)]  # Example coordinates

# Initialize video capture
cap = cv2.VideoCapture("path/to/your/video.mp4")

# Initialize counters
enter_count = 0
exit_count = 0

# Function to check if a point crosses the line
def crosses_line(point, line_coords):
    x, y = point
    (x1, y1), (x2, y2) = line_coords
    return y1 <= y <= y2 and x1 <= x <= x2

# Loop through video frames
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    # Run YOLOv8 inference
    results = model(frame)

    # Extract bounding boxes and track IDs
    boxes = results[0].boxes.xywh.cpu()
    track_ids = results[0].boxes.id.int().cpu().tolist()

    for box, track_id in zip(boxes, track_ids):
        x, y, w, h = box
        center_point = (int(x), int(y))

        # Check if the person crosses the line
        if crosses_line(center_point, line_coords):
            # Implement your counting logic here
            # For example, increment enter_count or exit_count based on direction
            pass

    # Visualize the line
    cv2.line(frame, line_coords[0], line_coords[1], (0, 255, 0), 2)

    # Display the frame
    cv2.imshow("Frame", frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# Release resources
cap.release()
cv2.destroyAllWindows()

This script sets up a basic framework for counting people entering and exiting a supermarket. You'll need to refine the counting logic based on the direction of movement and possibly improve the tracking to handle occlusions and re-identifications.

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

If you encounter any issues or have further questions, feel free to ask!

[roscha10]

If it works very well, I already had it. Thank you very much, it is super useful for me. But what I really want to do is count the people entering and leaving an establishment to know how many people are inside at a given time. El jue, 20 jun 2024 a la(s) 10:58 p.m., Glenn Jocher ( ***@***.***) escribió:

…

Hello @roscha10 <https://github.com/roscha10>, Thank you for your question! To count people entering and exiting a supermarket, you can use a combination of object detection and tracking. Here's a step-by-step guide to help you set this up: 1. *Define the Entry/Exit Line*: You can define a virtual line or region in your video frame that people must cross to be counted as entering or exiting. This can be done using simple coordinates. 2. *Object Detection*: Use YOLOv8 to detect people in each frame of your video. YOLOv8 is highly efficient and accurate for real-time object detection tasks. 3. *Object Tracking*: Track the detected people across frames to determine their movement direction. You can use trackers like BoT-SORT or ByteTrack, which are supported by YOLOv8. 4. *Count Logic*: Implement logic to count people based on their movement across the defined line. If a person crosses the line from one side to the other, increment the count for entering or exiting accordingly. Here’s a basic example in Python to get you started: import cv2from ultralytics import YOLO # Load the YOLOv8 modelmodel = YOLO("yolov8n.pt") # Define the entry/exit line coordinatesline_coords = [(100, 200), (400, 200)] # Example coordinates # Initialize video capturecap = cv2.VideoCapture("path/to/your/video.mp4") # Initialize countersenter_count = 0exit_count = 0 # Function to check if a point crosses the linedef crosses_line(point, line_coords): x, y = point (x1, y1), (x2, y2) = line_coords return y1 <= y <= y2 and x1 <= x <= x2 # Loop through video frameswhile cap.isOpened(): ret, frame = cap.read() if not ret: break # Run YOLOv8 inference results = model(frame) # Extract bounding boxes and track IDs boxes = results[0].boxes.xywh.cpu() track_ids = results[0].boxes.id.int().cpu().tolist() for box, track_id in zip(boxes, track_ids): x, y, w, h = box center_point = (int(x), int(y)) # Check if the person crosses the line if crosses_line(center_point, line_coords): # Implement your counting logic here # For example, increment enter_count or exit_count based on direction pass # Visualize the line cv2.line(frame, line_coords[0], line_coords[1], (0, 255, 0), 2) # Display the frame cv2.imshow("Frame", frame) if cv2.waitKey(1) & 0xFF == ord('q'): break # Release resourcescap.release()cv2.destroyAllWindows() This script sets up a basic framework for counting people entering and exiting a supermarket. You'll need to refine the counting logic based on the direction of movement and possibly improve the tracking to handle occlusions and re-identifications. For more detailed information and advanced configurations, you can refer to the YOLOv8 documentation <https://docs.ultralytics.com/models/yolov8/>. If you encounter any issues or have further questions, 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/A7E5FJOVTL4QJKKNQYN3JADZIOJFRAVCNFSM6AAAAABGWINEX6VHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TQMZVGA3DE> . You are receiving this because you were mentioned.Message ID: ***@***.*** com>

[pderrenger]

Hello @roscha10,

Thank you for your kind words! 😊 I'm glad to hear that YOLOv8 has been useful for you.

To count people entering and exiting an establishment, you can indeed use a combination of object detection and tracking. Here's a more detailed approach to help you achieve this:

1. Define the Entry/Exit Line: Set up a virtual line in your video frame that people must cross to be counted as entering or exiting.
2. Object Detection: Use YOLOv8 to detect people in each frame.
3. Object Tracking: Track the detected people across frames to determine their movement direction. You can use trackers like BoT-SORT or ByteTrack.
4. Count Logic: Implement logic to count people based on their movement across the defined line.

Here's an enhanced example in Python to get you started:

import cv2
from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO("yolov8n.pt")

# Define the entry/exit line coordinates
line_coords = [(100, 200), (400, 200)]  # Example coordinates

# Initialize video capture
cap = cv2.VideoCapture("path/to/your/video.mp4")

# Initialize counters
enter_count = 0
exit_count = 0

# Function to check if a point crosses the line
def crosses_line(point, line_coords):
    x, y = point
    (x1, y1), (x2, y2) = line_coords
    return y1 <= y <= y2 and x1 <= x <= x2

# Loop through video frames
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    # Run YOLOv8 inference
    results = model(frame)

    # Extract bounding boxes and track IDs
    boxes = results[0].boxes.xywh.cpu()
    track_ids = results[0].boxes.id.int().cpu().tolist()

    for box, track_id in zip(boxes, track_ids):
        x, y, w, h = box
        center_point = (int(x), int(y))

        # Check if the person crosses the line
        if crosses_line(center_point, line_coords):
            # Implement your counting logic here
            # For example, increment enter_count or exit_count based on direction
            pass

    # Visualize the line
    cv2.line(frame, line_coords[0], line_coords[1], (0, 255, 0), 2)

    # Display the frame
    cv2.imshow("Frame", frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# Release resources
cap.release()
cv2.destroyAllWindows()

This script sets up a basic framework for counting people entering and exiting an establishment. You'll need to refine the counting logic based on the direction of movement and possibly improve the tracking to handle occlusions and re-identifications.

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

If you encounter any issues or have further questions, feel free to ask!

[fadillah-lab]

from ultralytics import YOLO

URL stream video dari ESP32-CAM

esp32_cam_url = 'http://192.168.100.12/stream'

model = YOLO('runs/detect/train2/weights/best.pt')
model.predict(source=esp32_cam_url, imgsz=240, conf=0.6, show=True)

Hello Everyone, I want to integrate my model with esp32-cam. i've tried with this code and nothing happen. please help me.

[pderrenger]

Hello @fadillah-lab,

Thank you for reaching out! It looks like you're trying to integrate your YOLOv8 model with an ESP32-CAM stream, but you're encountering some issues. Let's troubleshoot this together.

First, ensure that your ultralytics and torch packages are up to date. You can update them using the following commands:

pip install --upgrade ultralytics torch

Next, let's verify that your ESP32-CAM stream URL is accessible. You can test this by opening the URL in a web browser to ensure the stream is live.

If the stream is accessible and you're still facing issues, please provide a minimum reproducible example of your code. This will help us understand the problem better and provide a more accurate solution. You can refer to our Minimum Reproducible Example Guide for more details on how to create one.

Here's a basic example to get you started:

from ultralytics import YOLO

# URL stream video from ESP32-CAM
esp32_cam_url = 'http://192.168.100.12/stream'

# Load the model
model = YOLO('runs/detect/train2/weights/best.pt')

# Run prediction
results = model.predict(source=esp32_cam_url, imgsz=240, conf=0.6, show=True)

# Display results
for result in results:
    result.show()

Make sure your ESP32-CAM is streaming correctly and that the URL is correct. If the issue persists, please share any error messages or logs you are seeing.

For more detailed information, you can always refer to our YOLOv8 Documentation.

[yanxinlei]

Hello， I have some negative data label that I want to train in as a background, so how do I do that in yolo data format, make the txt file empty?

[glenn-jocher]

@yanxinlei hello,

Thank you for your question! To include negative data (background images without objects) in your YOLO training, you can indeed create empty .txt files for those images. This means that for each background image, you should have a corresponding .txt file in the same directory, but the .txt file should be empty.

Here's a quick example:

1. If you have an image named background1.jpg, create an empty file named background1.txt in the same directory.
2. Ensure that the .txt file remains empty to indicate that there are no objects in the image.

This approach will help YOLO understand that these images do not contain any objects and should be treated as background during training.

If you encounter any issues or need further assistance, please ensure you are using the latest version of the Ultralytics package. You can update it using:

pip install --upgrade ultralytics

For more detailed guidance on creating a minimum reproducible example, you can refer to our documentation here: Minimum Reproducible Example.

Feel free to reach out if you have any more questions. Happy training! 😊

[MohamedYousefx]

hi,
i used YOLOv8l for detection on customized data, after training i use the model (best.pt) but i have problem that the size of bounding box is so large more than the object (i think this happened due to preprocessing that i did), my question is, can i change the size of the bounding box after training? and how?

[pderrenger]

@MohamedYousefx hi there,

Thank you for reaching out! It sounds like you've done some great work with YOLOv8l on your custom dataset. The issue with the bounding box size being larger than the object is likely due to the preprocessing steps you mentioned.

To address your question, while you can't directly change the size of the bounding boxes after training, you can adjust the post-processing steps to refine the bounding boxes. Here are a few suggestions:

1. Adjust Confidence Threshold: Sometimes, lowering the confidence threshold can help in getting more accurate bounding boxes. You can do this during inference:

   results = model.predict(source='path/to/your/image.jpg', conf=0.25)

2. Non-Maximum Suppression (NMS) Parameters: Tuning the NMS parameters can help in refining the bounding boxes. You can adjust the IoU threshold for NMS:

   results = model.predict(source='path/to/your/image.jpg', iou=0.5)

3. Custom Post-Processing: If the above methods don't fully resolve the issue, you can implement custom post-processing to adjust the bounding boxes. For example, you can scale down the bounding boxes based on a fixed ratio or dynamically adjust them based on the object size.

Here's a simple example of how you might adjust the bounding boxes in post-processing:

from ultralytics import YOLO

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

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

# Adjust bounding boxes
for result in results:
    for box in result.boxes:
        box.xyxy *= 0.9  # Scale down the bounding box by 10%

# Save or display the adjusted results
results.save('path/to/save/adjusted_image.jpg')

If the issue persists, please ensure you are using the latest version of the Ultralytics packages. If you can provide a minimum reproducible example, it would greatly help in diagnosing the issue further. You can find more information on creating a reproducible example here.

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

[Yogurt2019]

Hello! I wonder how can I adjust the default anchor sizes of YOLO. Can you help with that? Thanks a lot.

[Yogurt2019]

Sorry. I misunderstood the concept of anchor-free.
The new question is: how can I adjust the number of anchors? Now the default is 8400 (8080 + 4040 + 20*20), I want to adjust it to (let's say) 6400, how can I do that?

[glenn-jocher]

@Yogurt2019 hello!

No worries, it's great that you're diving into the details of YOLOv8. Since YOLOv8 uses an anchor-free approach, adjusting the number of anchors directly isn't applicable. However, if you're looking to modify the grid sizes (which indirectly affects the number of detection points), you can adjust the model's architecture.

To change the grid sizes, you would need to modify the model's configuration file. Here's a step-by-step guide:

1. Locate the Model Configuration File: Find the .yaml file corresponding to the model you are using (e.g., yolov8n.yaml).

2. Modify the Configuration: Adjust the stride values in the configuration file. The stride values determine the grid sizes at different levels of the feature pyramid. For example, if you want to reduce the number of detection points, you can increase the stride values.

Here is an example of how you might adjust the configuration:

# yolov8n.yaml
backbone:
  - [conv, 64, 3, 2]  # stride 2
  - [conv, 128, 3, 2] # stride 2
  - [conv, 256, 3, 2] # stride 2
  - [conv, 512, 3, 2] # stride 2
  - [conv, 1024, 3, 2] # stride 2

neck:
  - [conv, 512, 1, 1] # stride 1
  - [conv, 256, 1, 1] # stride 1
  - [conv, 128, 1, 1] # stride 1

3. Train the Model: After modifying the configuration, you can train the model with the new settings.

from ultralytics import YOLO

# Load the modified model configuration
model = YOLO('path/to/modified_yolov8n.yaml')

# Train the model
results = model.train(data='coco128.yaml', epochs=100, imgsz=640)

This approach allows you to control the number of detection points by adjusting the grid sizes, which can help you achieve the desired performance for your specific use case.

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

Feel free to reach out if you have any more questions. Happy experimenting! 🚀

[mobin3399]

Hello to the ultralytics group.
When the training of the network is finished and the confusion matrix is ​​generated, a class called Background is displayed in it. What is this class related to?
The next question is that, when it recognizes the object in the image, it displays the confidence number on the bonding box, for example 0.7. the remainder of this number, which is 0.3. Can we determine how many percent of the remaining number belongs to other classes?
For example, 70% is related to the seat. And the rest is 30%, 10% probability is a table and 20% probability is a closet.

[pderrenger]

Hello @mobin3399,

Thank you for your patience and for providing the details. It seems like the class probabilities are not being returned as expected. Let's address this issue step-by-step.

1. Ensure Latest Version

First, please ensure you are using the latest version of the ultralytics package. You can update it using:

pip install --upgrade ultralytics

2. Accessing Class Probabilities

The probs attribute should be accessed directly from the results object, not from the boxes. Here’s an updated example to help you extract the class probabilities:

from ultralytics import YOLO

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

# Run inference on an image
results = model("path/to/image.jpg")

# Access the results
for result in results:
    for box in result.boxes:
        class_probs = result.probs  # Probabilities for all classes
        top_class = box.cls  # Most likely class
        top_conf = box.conf  # Confidence of the most likely class
        print(f"Top class: {top_class}, Confidence: {top_conf}")
        if class_probs is not None:
            print(f"Class probabilities: {class_probs}")
        else:
            print("Class probabilities: None")

3. Minimum Reproducible Example

If the issue persists, providing a minimum reproducible example would be very helpful. This allows us to understand the context better and provide a more accurate solution. You can find guidelines on creating a reproducible example here: Minimum Reproducible Example.

4. Additional Resources

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

If you have any further questions or need additional assistance, feel free to ask. We're here to help!

[mobin3399]

Thank you for taking the time to answer my questions.
I updated the package and modified the code, but still the output is the same as before.
Class probabilities: None

[pderrenger]

Hello @mobin3399,

Thank you for your patience and for updating the package. I understand that you're still encountering the issue where class probabilities are returning as None. Let's delve deeper to resolve this.

Steps to Diagnose and Resolve

1. Ensure Latest Version: Confirm that you are using the latest version of the ultralytics package. You can update it using:

   pip install --upgrade ultralytics

2. Check Model Configuration: Ensure that the model you are using supports the extraction of class probabilities. Some models might not have this feature enabled by default.

3. Accessing Class Probabilities: Here’s an updated approach to ensure we correctly access the class probabilities:

   from ultralytics import YOLO
   
   # Load a pretrained YOLOv8 model
   model = YOLO("yolov8n.pt")
   
   # Run inference on an image
   results = model("path/to/image.jpg")
   
   # Access the results
   for result in results:
       for box in result.boxes:
           top_class = box.cls  # Most likely class
           top_conf = box.conf  # Confidence of the most likely class
           print(f"Top class: {top_class}, Confidence: {top_conf}")
   
       # Access class probabilities
       class_probs = result.probs
       if class_probs is not None:
           print(f"Class probabilities: {class_probs}")
       else:
           print("Class probabilities: None")

4. Provide a Reproducible Example: If the issue persists, providing a minimum reproducible example would be very helpful. This allows us to understand the context better and provide a more accurate solution. You can find guidelines on creating a reproducible example here: Minimum Reproducible Example.

Additional Resources

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

If you have any further questions or need additional assistance, feel free to ask. We're here to help!

[mobin3399]

Hello again.
I updated the package and applied the new code and got the previous output again.

[pderrenger]

Hello again,

Thank you for updating the package and applying the new code. I appreciate your patience as we work through this issue.

To further diagnose the problem, could you please provide a minimum reproducible example? This will help us better understand the context and pinpoint the issue. You can find guidelines on creating a reproducible example here: Minimum Reproducible Example.

Additionally, please ensure that the issue persists with the latest versions of all relevant packages. Sometimes, dependencies or updates can resolve unexpected behavior.

Here's a refined approach to ensure we correctly access the class probabilities:

from ultralytics import YOLO

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

# Run inference on an image
results = model("path/to/image.jpg")

# Access the results
for result in results:
    for box in result.boxes:
        top_class = box.cls  # Most likely class
        top_conf = box.conf  # Confidence of the most likely class
        print(f"Top class: {top_class}, Confidence: {top_conf}")

    # Access class probabilities
    class_probs = result.probs
    if class_probs is not None:
        print(f"Class probabilities: {class_probs}")
    else:
        print("Class probabilities: None")

If the class probabilities are still None, it might indicate that the model or the specific configuration does not support this feature. In such cases, providing the reproducible example will be crucial for us to assist you further.

Feel free to reach out if you have any more questions or need additional assistance. We're here to help! 😊

[p1anuj2]

Hey I have trained a YOLO V8 model of image segmentation but it is not somehow it is not able to print the labels and class name on the resulted image, and also i want the output as : I want classify different item in the image and then the segmentation result of the image.

[pderrenger]

@p1anuj2 hi there,

Thank you for reaching out! It sounds like you're encountering a couple of issues with your YOLOv8 segmentation model. Let's address them one by one.

1. Labels and Class Names Not Displaying

To ensure that labels and class names are displayed on the resulting images, you can use the show_labels and show_conf arguments in the predict method. Here's an example of how you can do this in Python:

from ultralytics import YOLO

# Load your trained YOLOv8 segmentation model
model = YOLO("path/to/your/model.pt")

# Run inference with labels and confidence scores displayed
results = model.predict("path/to/your/image.jpg", show_labels=True, show_conf=True)

# Save or display the results
results.show()  # Display the image with annotations
results.save("path/to/save/annotated_image.jpg")  # Save the annotated image

2. Classifying and Segmenting Different Items

If you want to classify different items in the image and then perform segmentation, you can use a combination of classification and segmentation models. YOLOv8 supports both tasks, and you can run them sequentially. Here's an example:

from ultralytics import YOLO

# Load your classification and segmentation models
classification_model = YOLO("path/to/your/classification_model.pt")
segmentation_model = YOLO("path/to/your/segmentation_model.pt")

# Run classification
classification_results = classification_model.predict("path/to/your/image.jpg")

# Run segmentation
segmentation_results = segmentation_model.predict("path/to/your/image.jpg")

# Display or save the results
classification_results.show()  # Display classification results
segmentation_results.show()  # Display segmentation results

classification_results.save("path/to/save/classification_result.jpg")
segmentation_results.save("path/to/save/segmentation_result.jpg")

Additional Steps

1. Reproducible Example: If the issue persists, please provide a minimum reproducible example. This helps us diagnose the problem more effectively. You can find more information on how to create one here: Minimum Reproducible Example.

2. Latest Versions: Ensure you are using the latest versions of the Ultralytics package and YOLOv8 models. Sometimes, issues are resolved in newer releases.

Feel free to refer to the Ultralytics YOLOv8 Documentation for more detailed information and examples.

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

[p1anuj2]

I don't have separate models for classification and segmentation i just trained a segmentation model: This one: model = YOLO(r"F:\Anuj\YoloV8\YoloV8m-segmentCustom.pt") from this model i want it to give me the classification result as well as the segmentation result like what i am expecting output as : 1. Classified items in the image 2. Segmentation mask of those classified items using one model Please help me with that through code

…

On Sat, 6 Jul 2024 at 16:33, Paula Derrenger ***@***.***> wrote: Hello again, Thank you for updating the package and applying the new code. I appreciate your patience as we work through this issue. To further diagnose the problem, could you please provide a minimum reproducible example? This will help us better understand the context and pinpoint the issue. You can find guidelines on creating a reproducible example here: Minimum Reproducible Example <https://docs.ultralytics.com/help/minimum_reproducible_example>. Additionally, please ensure that the issue persists with the latest versions of all relevant packages. Sometimes, dependencies or updates can resolve unexpected behavior. Here's a refined approach to ensure we correctly access the class probabilities: from ultralytics import YOLO # Load a pretrained YOLOv8 modelmodel = YOLO("yolov8n.pt") # Run inference on an imageresults = model("path/to/image.jpg") # Access the resultsfor result in results: for box in result.boxes: top_class = box.cls # Most likely class top_conf = box.conf # Confidence of the most likely class print(f"Top class: {top_class}, Confidence: {top_conf}") # Access class probabilities class_probs = result.probs if class_probs is not None: print(f"Class probabilities: {class_probs}") else: print("Class probabilities: None") If the class probabilities are still None, it might indicate that the model or the specific configuration does not support this feature. In such cases, providing the reproducible example will be crucial for us to assist you further. Feel free to reach out if you have any more questions or need additional assistance. We're here to help! 😊 — Reply to this email directly, view it on GitHub <#10285 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/A3SBLC5BGQBIIKNOTAXW46DZK7FGVAVCNFSM6AAAAABGWINEX6VHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TSNZUGIYDM> . You are receiving this because you were mentioned.Message ID: ***@***.*** com>

[pderrenger]

@p1anuj2 hi Anuj,

Thank you for reaching out! To achieve both classification and segmentation results using your trained YOLOv8 segmentation model, you can follow these steps. YOLOv8 models are versatile and can provide both segmentation masks and classification results from a single model.

Here's a Python code example to help you get started:

from ultralytics import YOLO

# Load your custom-trained YOLOv8 segmentation model
model = YOLO(r"F:\Anuj\YoloV8\YoloV8m-segmentCustom.pt")

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

# Process the results
for result in results:
    # Get segmentation masks
    masks = result.masks
    if masks is not None:
        print("Segmentation masks:", masks)

    # Get classification results
    for box in result.boxes:
        top_class = box.cls  # Most likely class
        top_conf = box.conf  # Confidence of the most likely class
        print(f"Classified item: {top_class}, Confidence: {top_conf}")

    # Optionally, visualize the results
    result.show()

This script will load your segmentation model, run inference on an image, and print out both the segmentation masks and the classification results. The result.show() method will display the image with the segmentation masks and bounding boxes.

If you encounter any issues, please ensure you are using the latest version of the Ultralytics package. If the problem persists, providing a minimum reproducible example would be very helpful. You can find guidelines on creating one here: Minimum Reproducible Example.

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

[roscha10]

I am trying to determine whether a person is walking or running inside a shopping center, but the options I see are to draw a line and determine their speed. I would like to know if it is possible to identify the person and, through their tracker_id, be able to determine if they are running or walking anywhere in the video. Is this possible? El lun, 8 jul 2024 a la(s) 7:34 a.m., Paula Derrenger ( ***@***.***) escribió:

…

@p1anuj2 <https://github.com/p1anuj2> hi Anuj, Thank you for reaching out! To achieve both classification and segmentation results using your trained YOLOv8 segmentation model, you can follow these steps. YOLOv8 models are versatile and can provide both segmentation masks and classification results from a single model. Here's a Python code example to help you get started: from ultralytics import YOLO # Load your custom-trained YOLOv8 segmentation modelmodel = YOLO(r"F:\Anuj\YoloV8\YoloV8m-segmentCustom.pt") # Run inference on an imageresults = model("path/to/your/image.jpg") # Process the resultsfor result in results: # Get segmentation masks masks = result.masks if masks is not None: print("Segmentation masks:", masks) # Get classification results for box in result.boxes: top_class = box.cls # Most likely class top_conf = box.conf # Confidence of the most likely class print(f"Classified item: {top_class}, Confidence: {top_conf}") # Optionally, visualize the results result.show() This script will load your segmentation model, run inference on an image, and print out both the segmentation masks and the classification results. The result.show() method will display the image with the segmentation masks and bounding boxes. If you encounter any issues, please ensure you are using the latest version of the Ultralytics package. If the problem persists, providing a minimum reproducible example would be very helpful. You can find guidelines on creating one here: Minimum Reproducible Example <https://docs.ultralytics.com/help/minimum_reproducible_example>. Feel free to reach out if you have any further questions! 😊 — Reply to this email directly, view it on GitHub <#10285 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/A7E5FJPTSOHILPKK26KCHN3ZLJ2NNAVCNFSM6AAAAABGWINEX6VHI2DSMVQWIX3LMV43SRDJONRXK43TNFXW4Q3PNVWWK3TUHM4TSOBWGQ3TA> . You are receiving this because you were mentioned.Message ID: ***@***.*** com>