models/yolov6/

[giscus[bot]]

models/yolov6/

Explore Meituan YOLOv6, a state-of-the-art object detection model striking a balance between speed and accuracy. Dive into features, pre-trained models, and Python usage.

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

[akhilesh99sharma]

There are AP and AR values for results but not precision and recall. I need to compare precision and recall values for different YOLO versions (v5,v6,v7 etc.) on my custom dataset. How to get precision and recall values for YOLOv6 evaluation?

[pderrenger]

Hey there! 👋

For evaluating precision and recall values for YOLOv6 on your custom dataset, you can enhance the existing evaluation script to calculate these metrics from the confusion matrix. While direct options for this are not explicitly provided in the YOLOv6 documentation, you can use the detection results (true positives, false positives, and false negatives) to compute precision and recall manually.

Here's a quick example in Python on how you might approach it:

from ultralytics import YOLO

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

# Run validation to get results
results = model.val(data='path/to/your/dataset.yaml')

# Assume results contains TP (true positives), FP (false positives), FN (false negatives)
TP = results.metrics['TP']
FP = results.metrics['FP']
FN = results.metrics['FN']

# Calculate Precision and Recall
precision = TP / (TP + FP) if (TP + FP) > 0 else 0
recall = TP / (TP + FN) if (TP + FN) > 0 else 0

print(f'Precision: {precision}, Recall: {recall}')

Please note, the above is a simplified illustration. You may need to adjust the code according to how your results and metrics are returned from the validation function. Always ensure that the val function of your model aligns with how detection results are being recorded and interpreted. 🛠️

Hope this helps, and happy comparing across YOLO versions! 🚀

[akhilesh99sharma]

Hello , I tried but was still not able to get these values, could you please help me with that?

[pderrenger]

Hey there! 😊

I understand you're having trouble obtaining precision and recall values for your evaluation on YOLOv6. Let's tackle this! Precision and recall can be calculated from the detection results (true positives, false positives, true negatives, and false negatives), which are not directly given in the output summary but can be inferred.

Here's a quick Python snippet that might help you calculate these values after running your validation:

true_positives = TP  # You would obtain this from your model's validation output
false_positives = FP  # Ditto
false_negatives = FN  # Ditto

precision = true_positives / (true_positives + false_positives) if (true_positives + false_positives) > 0 else 0
recall = true_positives / (true_positives + false_negatives) if (true_positives + false_negatives) > 0 else 0

print(f"Precision: {precision:.4f}, Recall: {recall:.4f}")

Please replace TP, FP, and FN with the actual counts from your model's validation result. If you're unsure where to find these counts, they are typically derived from comparing your model's predictions against the ground truth annotations in your validation dataset.

This approach requires a bit of manual extraction and calculation, but it should get you the values you're after. Hope this helps! Let me know if there's anything else I can do for you. Happy modeling! 🚀

[akhilesh99sharma]

Hello, I tried doing it but was not able to do so. I get the predictions json file in the val folder but don't know how to compare it with the labels to get TP, FP etc. Can you please help me with that? I need to compare results of YOLOv6 with v8, v9 but I am not getting precision and recall values in v6 , I get average precision and average recall

[pderrenger]

@akhilesh99sharma hey there! 🌞

For calculating TP, FP, TN, FN to get precision and recall, especially when comparing different YOLO versions, the predictions JSON in the val folder is indeed where you start. Here's a simplified Python snippet to help you process that JSON file and compare it with your ground truth labels:

import json
from collections import defaultdict

# Load your predictions
with open('path/to/your/predictions.json', 'r') as f:
    predictions = json.load(f)

# Assuming `ground_truths` is a dict with same structure as `predictions`
# where keys are image_ids and values are annotations (list of dicts with 'bbox' and 'category_id')
ground_truths = {...}

# Initialize counters
tp, fp, fn = 0, 0, 0

# Assuming single class for simplicity. Adapt as necessary for multi-class.
for image_id, preds in predictions.items():
    gt_bboxes = [gt['bbox'] for gt in ground_truths.get(image_id, [])]
    pred_bboxes = [pred['bbox'] for pred in preds]

    # Here insert logic to compare `gt_bboxes` with `pred_bboxes`
    # to increment tp, fp, fn accordingly.
    # This often involves IoU (Intersection over Union) calculations.

precision = tp / (tp + fp) if tp + fp > 0 else 0
recall = tp / (tp + fn) if tp + fn > 0 else 0

print(f"Precision: {precision}, Recall: {recall}")

You'll need to implement the logic for matching predicted bounding boxes (pred_bboxes) with the ground truth boxes (gt_bboxes), possibly using an IoU threshold to determine matches (true positives) vs mismatches (false positives, false negatives).

For comparing across YOLO versions (v6, v8, v9, etc.), ensure you run each model with consistent settings on your custom dataset and process each output similarly.

I hope this simplifies the process for you! 🚀 Let me know if you need further assistance.

[kadirnar]

Does ultralytics library support yolov6 model?

ModuleNotFoundError: No module named 'yolov6'

[pderrenger]

@kadirnar hi there!

Yes, the Ultralytics library does support YOLOv6 models. It seems like you might be encountering a ModuleNotFoundError because the YOLOv6 model isn't being recognized. Let's ensure you're using the latest versions of torch and ultralytics. Please update your packages and try again:

pip install --upgrade torch ultralytics

Here's a quick example to get you started with YOLOv6 using the Ultralytics library:

Python

from ultralytics import YOLO

# Load a YOLOv6n model
model = YOLO("yolov6n.yaml")

# Train the model on the COCO8 example dataset for 100 epochs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

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

CLI

# Train YOLOv6n model
yolo train model=yolov6n.yaml data=coco8.yaml epochs=100 imgsz=640

# Run inference with YOLOv6n model
yolo predict model=yolov6n.yaml source=path/to/bus.jpg

If you continue to face issues, please provide a minimum reproducible example so we can better assist you. You can refer to our guide on creating a minimum reproducible example here: Minimum Reproducible Example.

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

[tino926]

I want to replicate your training accuracy of the YOLOv6-N model. Is this the correct command: yolo train model=yolov6n.yaml data=coco.yaml epochs=400 optimizer=SGD cos_lr=True lr0=0.02?
According to YOLOv6's repo https://github.com/meituan/YOLOv6/blob/main/docs/Train_coco_data.md, they have to use anchor-aid and distilling techniques to achieve this accuracy. But I can't find the corresponding parameters in ultralytics'.

[glenn-jocher]

@tino926 to achieve the training accuracy of the YOLOv6-N model as described in the YOLOv6 repository, you would indeed use the anchor-aided training (AAT) and self-distillation strategies, which are not explicitly parameterized in the Ultralytics YOLO interface. Ensure you are using the latest version and check the YOLOv6 documentation for any updates on incorporating these strategies. For precise replication, consider following the original YOLOv6 GitHub instructions alongside Ultralytics for any additional settings or configurations.

[tino926]

@glenn-jocher, thanks for your response.

I apologize if I misunderstood your explanation, as I am not a native English speaker. Could you please clarify if the phrase "which are not explicitly parameterized in the Ultralytics YOLO interface" means that AAT and self-distillation cannot currently be implemented solely through the Ultralytics YOLO interface? Therefore I should manually add anchor branches and implement distillation with additional code?

[glenn-jocher]

Thank you for your question. Yes, that's correct. The current Ultralytics YOLO interface does not explicitly support anchor-aided training (AAT) and self-distillation, so you would need to implement these strategies manually by modifying the code to include anchor branches and self-distillation techniques. If you need further guidance on implementing these, referring to the original YOLOv6 repository might be helpful.