성능 지표 심층 분석

소개#

성능 지표는 정확도와 객체 탐지 모델의 효율성을 평가하는 핵심 도구입니다. 이러한 지표는 모델이 이미지 내 객체를 얼마나 효과적으로 식별하고 위치를 찾는지 보여줍니다. 또한 모델이 거짓 양성과 거짓 음성을 어떻게 처리하는지 파악하는 데 도움이 됩니다. 이러한 인사이트는 모델 성능을 평가하고 향상하는 데 매우 중요합니다. 이 가이드에서는 YOLO26의 성능 지표와 그 중요성, 그리고 지표 해석 방법을 살펴봅니다.



시청: Ultralytics YOLO26 성능 지표 | mAP, F1 점수, 정밀도, IoU 및 정확도

객체 탐지 지표#

다음 지표는 YOLO26에서 중요하며 다양한 객체 탐지 모델에 폭넓게 적용할 수 있습니다.

  • 교집합 대비 합집합(IoU): IoU는 예측된 바운딩 박스와 정답 바운딩 박스가 얼마나 겹치는지 측정합니다. 객체 위치 추정의 정확도를 평가하는 데 기본적으로 사용됩니다.

  • 평균 정밀도(AP): AP는 정밀도-재현율 곡선 아래의 면적을 계산하여 모델의 정밀도와 재현율 성능을 하나의 값으로 나타냅니다.

  • 평균 정밀도(mAP): mAP는 여러 객체 클래스의 AP 값을 평균화하여 AP 개념을 확장한 지표입니다. 다중 클래스 객체 탐지 시나리오에서 모델 성능을 종합적으로 평가하는 데 유용합니다.

  • 정밀도와 재현율: 정밀도는 전체 양성 예측 중 참 양성이 차지하는 비율을 나타내며, 거짓 양성을 방지하는 모델의 역량을 평가합니다. 재현율은 실제 양성 중 참 양성이 차지하는 비율을 계산하며, 클래스의 모든 인스턴스를 탐지하는 모델의 능력을 측정합니다.

  • F1 점수: F1 점수는 정밀도와 재현율의 조화평균으로, 거짓 양성과 거짓 음성을 모두 고려해 모델 성능을 균형 있게 평가합니다.

YOLO26 모델의 지표 계산 방법#

YOLO26의 검증 모드는 앞서 설명한 평가 지표를 계산합니다.

검증 모드는 간단하게 사용할 수 있습니다. 모델을 학습한 후 model.val() 함수를 호출하면 됩니다. 그러면 함수가 검증 데이터 세트를 처리하고 다양한 성능 지표를 반환합니다. 그런데 이러한 지표는 무엇을 의미할까요? 지표를 어떻게 해석해야 할까요?

출력 해석#

아래 섹션에서는 model.val() 출력의 각 부분을 자세히 설명합니다.

클래스별 지표#

출력의 한 섹션에는 클래스별 성능 지표가 포함됩니다. 이러한 세부 정보는 특히 다양한 객체 범주가 포함된 데이터 세트에서 각 클래스에 대해 모델이 얼마나 잘 작동하는지 파악하는 데 유용합니다. 데이터 세트의 각 클래스에 대해 다음 정보가 제공됩니다.

  • 클래스: "person", "car" 또는 "dog"와 같은 객체 클래스의 이름입니다.

  • 이미지: 검증 세트에서 해당 객체 클래스가 포함된 이미지의 수를 나타내는 지표입니다.

  • 인스턴스: 검증 세트의 전체 이미지에서 해당 클래스가 나타나는 횟수입니다.

  • Box(P, R, mAP50, mAP50-95): 이 지표는 객체 탐지에서 모델의 성능을 파악하는 데 도움이 됩니다:

    • P (정밀도): 탐지된 객체의 정확도이며, 탐지 결과 중 올바른 결과가 얼마나 되는지 나타냅니다.

    • R (재현율): 이미지 내 객체의 모든 인스턴스를 식별하는 모델의 능력입니다.

    • mAP50: 교집합 대비 합집합(IoU) 임계값 0.50에서 계산한 평균 정밀도입니다. 비교적 "쉬운" 객체 탐지만을 고려해 모델의 정확도를 측정합니다.

    • mAP50-95: 0.50~0.95 범위의 다양한 IoU 임계값에서 계산한 평균 정밀도의 평균입니다. 탐지 난이도가 서로 다른 조건에서 모델 성능을 종합적으로 보여줍니다.

속도 지표#

특히 실시간 객체 탐지 시나리오에서는 추론 속도가 정확도만큼 중요할 수 있습니다. 이 섹션에서는 전처리부터 후처리까지 검증 과정의 각 단계에 걸리는 시간을 자세히 살펴봅니다.

COCO 지표 평가#

COCO 데이터 세트에서 검증하는 경우, COCO 평가 스크립트를 사용해 추가 지표를 계산합니다. 이러한 지표는 다양한 IoU 임계값과 크기의 객체에서 정밀도와 재현율이 어떤지 보여줍니다.

시각화 출력#

model.val() 함수는 수치 지표를 생성할 뿐만 아니라, 모델 성능을 더 직관적으로 이해하는 데 도움이 되는 시각적 결과도 제공합니다. 예상할 수 있는 시각적 결과는 다음과 같습니다.

  • F1 점수 곡선(BoxF1_curve.png): 이 곡선은 다양한 임계값에서의 F1 점수를 나타냅니다. 곡선을 해석하면 여러 임계값에서 거짓 양성과 거짓 음성 사이에 모델이 어떤 균형을 이루는지 파악할 수 있습니다.

  • 정밀도-재현율 곡선(BoxPR_curve.png): 모든 분류 문제에서 핵심적인 시각화로, 다양한 임계값에서 정밀도와 재현율 간의 상충 관계를 보여줍니다. 클래스 불균형이 있는 경우 특히 중요합니다.

  • 정밀도 곡선 (BoxP_curve.png): 다양한 임계값에서 정밀도 값을 나타내는 그래프입니다. 이 곡선은 임계값이 변함에 따라 정밀도가 어떻게 달라지는지 파악하는 데 도움이 됩니다.

  • 재현율 곡선 (BoxR_curve.png): 이에 대응하는 이 그래프는 다양한 임계값에서 재현율 값이 어떻게 변하는지 보여줍니다.

  • 혼동 행렬 (confusion_matrix.png): 혼동 행렬은 각 클래스의 참 양성, 참 음성, 거짓 양성, 거짓 음성 수를 보여주어 결과를 상세하게 파악할 수 있도록 합니다.

  • 정규화된 혼동 행렬 (confusion_matrix_normalized.png): 이 시각화는 혼동 행렬을 정규화한 버전입니다. 원시 개수가 아니라 비율로 데이터를 나타냅니다. 이 형식을 사용하면 클래스별 성능을 더 쉽게 비교할 수 있습니다.

  • 검증 배치 레이블 (val_batchX_labels.jpg): 이 이미지는 검증 데이터셋의 각 배치에 대한 정답 레이블을 나타냅니다. 데이터셋에 따라 객체가 무엇이며 각각 어느 위치에 있는지 명확하게 보여줍니다.

  • 검증 배치 예측 (val_batchX_pred.jpg): 레이블 이미지와 대조되는 이 시각 자료는 해당 배치에 대해 YOLO26 모델이 수행한 예측을 보여줍니다. 이를 레이블 이미지와 비교하면 모델의 객체 탐지 및 분류 성능을 시각적으로 쉽게 평가할 수 있습니다.

탐지, 세그멘테이션, 포즈 작업의 경우, 곡선 플롯 앞에는 지표 유형이 접두사로 붙습니다. 탐지는 Box* 곡선을 기록하고, 세그멘테이션은 Box* 및 Mask* 곡선을 모두 기록하며, 포즈는 Box* 및 Pose* 곡선을 모두 기록합니다.

결과 저장#

나중에 참고할 수 있도록 결과는 일반적으로 runs/detect/val라는 디렉터리에 저장됩니다.

적절한 지표 선택#

평가에 적합한 지표를 선택하는 방법은 대개 구체적인 애플리케이션에 따라 달라집니다.

  • mAP: 모델 성능을 전반적으로 평가하는 데 적합합니다.

  • IoU: 객체 위치를 정확하게 파악하는 것이 중요한 경우 필수적입니다.

  • 정밀도: 거짓 탐지를 최소화하는 것이 우선일 때 중요합니다.

  • 재현율: 객체의 모든 인스턴스를 탐지해야 하는 경우 중요합니다.

  • F1 점수: 정밀도와 재현율 간의 균형이 필요할 때 유용합니다.

실시간 애플리케이션에서는 적시에 결과를 얻기 위해 FPS(초당 프레임 수) 및 지연 시간과 같은 속도 지표가 중요합니다.

결과 해석#

흔히 관찰되는 낮은 점수는 다음과 같은 상황을 시사할 수 있습니다.

  • 낮은 mAP: 모델을 전반적으로 개선해야 할 수 있음을 나타냅니다.

  • 낮은 IoU: 모델이 객체 위치를 정확히 파악하는 데 어려움을 겪고 있을 수 있습니다. 다른 바운딩 박스 방식을 사용하면 도움이 될 수 있습니다.

  • 낮은 정밀도: 모델이 존재하지 않는 객체를 너무 많이 탐지하고 있을 수 있습니다. 신뢰도 임계값을 조정하면 이를 줄일 수 있습니다.

  • 낮은 재현율: 모델이 실제 객체를 놓치고 있을 수 있습니다. 특징 추출을 개선하거나 데이터를 더 사용하면 도움이 될 수 있습니다.

  • 불균형한 F1 점수: 정밀도와 재현율 간에 차이가 있습니다.

  • 클래스별 AP: 여기서 낮은 점수가 나타나면 모델이 어려움을 겪는 클래스를 확인할 수 있습니다.

사례 연구#

실제 사례를 살펴보면 이러한 지표가 실제로 어떻게 작동하는지 명확히 이해하는 데 도움이 됩니다.

사례 1#

  • 상황: mAP와 F1 점수가 최적 수준에 미치지 못하고, 재현율은 양호하지만 정밀도는 그렇지 않습니다.

  • 해석 및 조치: 잘못된 탐지가 너무 많을 수 있습니다. 신뢰도 임계값을 높이면 이를 줄일 수 있지만, 재현율도 약간 낮아질 수 있습니다.

사례 2#

  • 상황: mAP와 재현율은 허용 가능한 수준이지만 IoU가 낮습니다.

  • 해석 및 조치: 모델은 객체를 잘 탐지하지만 위치를 정확하게 지정하지 못할 수 있습니다. 바운딩 박스 예측을 개선하면 도움이 될 수 있습니다.

사례 3#

  • 상황: 전체 mAP가 양호한 수준인데도 일부 클래스의 AP가 다른 클래스보다 훨씬 낮습니다.

  • 해석 및 조치: 이러한 클래스는 모델에 더 어려울 수 있습니다. 해당 클래스의 데이터를 추가하거나 cls_pw 학습 인수를 사용해 클래스 가중치를 조정하면 도움이 될 수 있습니다.

소통 및 협업#

YOLO26 커뮤니티는 다음 채널을 통해 학습, 문제 해결, 네트워킹을 지원합니다.

더 넓은 커뮤니티와 소통하기#

  • GitHub 이슈: GitHub의 Ultralytics 저장소에는 질문을 하고, 버그를 보고하며, 새로운 기능을 제안할 수 있는 이슈 탭이 있습니다. 이곳에서는 커뮤니티 구성원과 유지 관리자가 활발히 활동하며, 구체적인 문제에 대한 도움을 받기에도 좋습니다.

  • Ultralytics Discord 서버: Ultralytics에는 다른 사용자 및 개발자와 소통할 수 있는 Discord 서버가 있습니다.

공식 문서 및 리소스#

  • Ultralytics YOLO26 문서: 공식 문서에서는 YOLO26을 종합적으로 살펴보고 설치, 사용, 문제 해결 가이드를 제공합니다.

이러한 리소스를 활용하면 문제를 해결하고 YOLO26 커뮤니티의 모범 사례를 최신 상태로 파악할 수 있습니다.

결론#

이 가이드에서는 YOLO26의 주요 성능 지표를 자세히 살펴보았습니다. 이러한 지표는 모델의 성능을 이해하는 데 핵심적이며, 모델을 미세 조정하려는 모든 사용자에게 중요합니다. 지표를 통해 개선에 필요한 정보를 얻고 모델이 실제 상황에서 효과적으로 작동하는지 확인할 수 있습니다.

YOLO26 및 Ultralytics 커뮤니티도 유용한 리소스입니다. 다른 개발자 및 전문가와 교류하면 문서에 다루지 않은 해결책을 찾을 수 있으며, 발견한 내용을 공유하면 객체 탐지 작업을 하는 다른 사람들에게 도움이 됩니다.

자주 묻는 질문#

  • 평균 정밀도(mAP)는 여러 클래스에 걸친 정밀도와 재현율을 단일 지표로 나타내므로 YOLO26 모델 평가에 중요합니다. mAP50는 IoU 임계값 0.50에서 정밀도를 측정하며, 객체를 올바르게 탐지하는 모델의 능력을 평가합니다. mAP50-95는 여러 IoU 임계값에서 정밀도를 평균하여 탐지 성능을 종합적으로 평가합니다. mAP 점수가 높으면 모델이 정밀도와 재현율의 균형을 효과적으로 유지한다는 의미입니다. 이는 정확한 탐지와 오탐 최소화가 모두 중요한 자율 주행 및 감시 시스템과 같은 애플리케이션에 필수적입니다.

  • Intersection over Union(IoU)은 예측 바운딩 박스와 정답 바운딩 박스 간의 겹치는 정도를 측정합니다. IoU 값의 범위는 0부터 1까지이며, 값이 높을수록 위치 정확도가 더 높습니다. IoU가 1.0이면 완벽하게 일치한다는 뜻입니다. 일반적으로 mAP와 같은 지표에서는 IoU 임계값 0.50을 사용해 참 양성을 정의합니다. IoU 값이 낮으면 모델이 객체 위치를 정밀하게 지정하는 데 어려움을 겪는다는 의미이며, 바운딩 박스 회귀를 개선하거나 학습 데이터셋의 어노테이션 정확도를 높여 이를 개선할 수 있습니다.

  • F1 점수는 정밀도와 재현율의 조화 평균을 제공하여 거짓 양성과 거짓 음성을 모두 균형 있게 고려하므로 YOLO26 모델 평가에 중요합니다. 데이터셋의 클래스 불균형이 있거나 정밀도 또는 재현율만으로는 충분하지 않은 애플리케이션에서 특히 유용합니다. F1 점수가 높으면 모델이 탐지 누락과 오경보를 모두 최소화하면서 객체를 효과적으로 탐지한다는 뜻이므로 보안 시스템 및 의료 영상과 같은 중요한 애플리케이션에 적합합니다.

  • Ultralytics YOLO26은 실시간 객체 탐지를 위한 여러 가지 이점을 제공합니다.

    • 속도 및 효율성: 고속 추론에 최적화되어 있어 지연 시간이 짧아야 하는 애플리케이션에 적합합니다.
    • 높은 정확도: 정밀도와 재현율의 균형을 유지하면서 다양한 모델 크기에서 높은 mAP를 달성합니다.
    • 유연성: 객체 탐지, 인스턴스 세그멘테이션, 시맨틱 세그멘테이션, 분류 등 다양한 작업을 지원합니다.
    • 간편한 사용: 사용자 친화적인 인터페이스, 상세한 문서, Ultralytics Platform과 같은 도구와의 통합을 제공합니다.

    이러한 특성 덕분에 YOLO26은 자율주행 차량부터 스마트 시티 솔루션까지 다양한 애플리케이션에 적합합니다.

  • 정밀도, 재현율, mAP, IoU와 같은 YOLO26의 검증 지표는 탐지의 여러 측면에 대한 통찰을 제공하여 모델 성능을 진단하고 개선하는 데 도움이 됩니다.

    • 정밀도: 거짓 양성을 파악하고 최소화하는 데 도움이 됩니다.
    • 재현율: 관련된 모든 객체가 탐지되도록 합니다.
    • mAP: 전반적인 성능을 보여주어 일반적인 개선 방향을 제시합니다.
    • IoU: 객체 위치 정확도를 세밀하게 조정하는 데 도움이 됩니다.

    이러한 지표를 분석하면 정밀도를 높이기 위한 신뢰도 임계값 조정이나 재현율을 높이기 위한 더욱 다양한 데이터 수집과 같이 구체적인 약점을 겨냥할 수 있습니다. 지표에 대한 자세한 설명과 해석 방법은 객체 탐지 지표를 참조하고, 모델을 최적화하기 위해 하이퍼파라미터 튜닝을 적용해 보세요.

댓글109

질문을 하거나 결과를 공유하거나 다른 사람을 도와주세요.

  1. atharvahudeGitHub

    Question: Clarification on AP vs mAP in YOLOv8 metrics output

    Hello,

    I'm using YOLOv8 for object detection, and I have some questions about the metrics output, particularly regarding the use of map50 and map50-90 in the results. In the output, I'm seeing these metrics reported for individual classes as well as an "all" category that aggregates the performance.

    My understanding is that:

    AP (Average Precision) should be calculated for each individual class.

    mAP (mean Average Precision) is the average of the AP values across all classes.

    However, in the output, the terms map50 and map50-90 are listed for each individual class. Should these values be interpreted as AP for each class, rather than mAP, which I would expect to be the mean across all classes? Additionally, the "all" row appears to be giving the mAP value.

    Could you confirm:

    1. Should the per-class map50 and map50-90 values be treated as AP for those specific classes?

    2. Is the "all" row correctly representing the mean AP across all classes?

    Thanks in advance for your clarification!

    1
    1. Glenn JocherUltralytics

      @atharvahude the per-class map50 and map50-95 values should indeed be treated as AP for those specific classes. The "all" row represents the mean AP across all classes, confirming your understanding. For more details, you can refer to our documentation on performance metrics.

  2. e-roeGitHub

    Hi, Great guide on performance metrics — they're key tools to evaluate the accuracy and efficiency of object detection models. However, although the plots are shown, I think the train/box_loss, train/obj_loss, and train/cls_loss plots weren't explained — or did I miss something? Thanks!

    1. Glenn JocherUltralytics(수정됨)

      @e-roe great observation! You're right that the training loss plots could use more explanation. The training losses shown during YOLO11 training represent:

      • train/box_loss: Localization loss measuring how well predicted bounding boxes match ground truth coordinates
      • train/cls_loss: Classification loss measuring how accurately the model predicts object classes
      • train/dfl_loss: Distribution Focal Loss, which helps improve localization accuracy by treating bounding box regression as a classification problem (YOLO26 is DFL-free, so this term is a plain L1 box-distance loss there)

      These training losses should generally decrease over epochs, indicating the model is learning. The validation losses (val/box_loss, val/cls_loss, val/dfl_loss) help monitor overfitting - if training losses decrease but validation losses increase or plateau, it suggests overfitting.

      Thanks for pointing this out! We'll consider expanding the training loss explanations in future documentation updates.

  3. Hemanth-mandava-neuropiGitHub

    @glenn-jocher I'm working on a YOLOv8 segmentation task to detect pallets. I've annotated a dataset using Roboflow with 6000 images, split into train, test, and validation sets. After training, I obtained the following results:

    Class Images Instances Box(P R mAP50 mAP50-95) Mask(P R mAP50 mAP50-95) all 1227 2262 0.974 0.489 0.689 0.636 0.972 0.488 0.690 0.624 The precision is high, but the recall is quite low (~0.48), which suggests many true pallets are being missed.

    While inspecting the Roboflow data analytics, I noticed something interesting:

    Around 4000 images have only 1 annotated pallet

    The rest have 2–10 pallets annotated

    This leads me to the following questions:

    Does this cause class imbalance in the dataset, particularly affecting model generalization and recall?

    Should I balance the dataset between single-object and multi-object images? Is it worth filtering or augmenting to even it out?

    Since I’m combining pre-annotated data from multiple sources, is there a way to analyze the distribution of annotations/images before training, especially when not using Roboflow’s UI?

    What techniques are most effective to boost recall in segmentation tasks? Should I look into:

    Lowering confidence thresholds?

    Data augmentation (mosaic, copy-paste)?

    Label smoothing or loss function tweaks?

    Different anchor/mask threshold settings?

    Any help or insights would be greatly appreciate

  4. Fatima-khanjarGitHub(수정됨)

    Hello!

    I hope this message finds you well.

    I have a question regarding the model's performance. Typically, to evaluate the model's performance, we look at precision, recall, and F1 scores. However, these metrics alone may not be sufficient to confirm that the model is performing well. We should also consider the values of DFL, classification (cls) loss, and box loss. My question is: What are the values of these losses that are considered good? Should they be something like 0.00xxxx? Additionally, what is the significance of having high precision, recall, and F1 scores (above 0.8), while at the same time, the loss values are around 0.3 and 0.6, and when we look at the plots of losses (train vs. val), we see that both losses are decreasing over the epochs?

    I have another question: The plots and values for training and validation losses are saved, but how can I extract the overall values of train/val losses during the training process?

    Thank you for your help!

    Regards,

    1. Glenn JocherUltralytics

      @Fatima-khanjar excellent questions about model evaluation!

      For DFL, classification, and box losses, there are no absolute "good" values as they depend on your dataset complexity, model size, and task. What's more important is the trend - consistently decreasing losses indicate proper training. Loss values of 0.3-0.6 with high precision/recall (>0.8) can be completely normal, as metrics often continue improving even after losses plateau.

      To extract training/validation loss values programmatically:

      import pandas as pd
      
      # Load the results CSV
      results_df = pd.read_csv('path/to/results.csv')
      
      # Extract train/val losses
      train_box_loss = results_df['train/box_loss']
      val_box_loss = results_df['val/box_loss']
      train_cls_loss = results_df['train/cls_loss']
      val_cls_loss = results_df['val/cls_loss']
      train_dfl_loss = results_df['train/dfl_loss']
      val_dfl_loss = results_df['val/dfl_loss']

      Focus on comparing validation metrics against your application requirements rather than trying to reach arbitrary loss values. A model with slightly higher losses but better real-world performance is ultimately more valuable.

      1
    2. maomao123-gitGitHub

      Hi!how to print f1 score in model.val() ? In addition, I want to print metrics with four decimal places so that I can get percentage form. For example, the printed mAP50 was 0.8657, and I can transfer the number to 86.57%. Where and how can I revise the code? Thanks!

    3. Glenn JocherUltralytics(수정됨)

      @maomao123-git to print the F1 score and format metrics with four decimal places when running validation, you can access these values from the results object:

      from ultralytics import YOLO
      
      # Load your model
      model = YOLO('yolo26n.pt')  # or your custom model path
      
      # Run validation
      results = model.val()
      
      # results.box.f1 holds one F1 score per class
      f1 = results.box.f1.mean()
      map50 = results.box.map50
      
      # Format and print
      print(f"F1 Score: {f1:.4f} ({f1*100:.2f}%)")
      print(f"mAP50: {map50:.4f} ({map50*100:.2f}%)")
      
      # For class-specific metrics
      for i, f1_val in enumerate(results.box.f1):
          class_name = model.names[results.box.ap_class_index[i]]
          print(f"Class '{class_name}' F1 Score: {f1_val:.4f} ({f1_val*100:.2f}%)")

      This gives you access to both overall and class-specific F1 scores with your desired formatting. The metrics class includes all the performance metrics like precision, recall, mAP, and F1 score, which you can format as needed.

      2
    4. Glenn JocherUltralytics(수정됨)

      @maomao123-git to get the F1 score for "all" classes (mean F1 across all classes), you can calculate it from the overall precision and recall values:

      # Run validation
      results = model.val()
      
      # Get overall precision and recall
      precision_all = results.box.mp  # mean precision
      recall_all = results.box.mr     # mean recall
      
      # Calculate F1 score for "all" classes
      f1_all = 2 * (precision_all * recall_all) / (precision_all + recall_all) if (precision_all + recall_all) > 0 else 0
      
      # Format and print
      print(f"All Classes F1 Score: {f1_all:.4f} ({f1_all*100:.2f}%)")

      Alternatively, you can calculate the mean of class-specific F1 scores:

      # Calculate mean of all class F1 scores
      mean_f1 = results.box.f1.mean()
      print(f"Mean F1 Score: {mean_f1:.4f} ({mean_f1*100:.2f}%)")

      Both methods should give you a good representation of the overall F1 score that would appear in the "all" row.

      2
    5. Glenn JocherUltralytics

      @Shubham77saini the precision calculation in YOLOv8 considers confidence thresholds and precision-recall curve interpolation, which can lead to different values than direct TP/(TP+FP) calculations. The reported 0.734 precision for the "car" class is likely affected by how the model handles confidence scores across the precision-recall curve.

      To understand this better, you might want to:

      1. Check the confusion matrix at different confidence thresholds
      2. Look at P-R curves in the validation output directory
      3. Verify that your IoU threshold (0.5) matches what's being used for metric calculation

      The metrics implementation computes precision across a range of confidence thresholds and may interpolate values between operating points, which explains why the reported value differs from your expected calculation. For deeper investigation, check the full metrics implementation in the ultralytics/utils/metrics.py file.

    6. maomao123-gitGitHub

      glenn-jocher Apr 18, 2025

      @glenn-jocher, if we can get the ap50-95, I think we also can get recall50-95, precision50-95, f1-score50-95. When I print metrics.box.r(), metrics.box.p()……, I just see the single value of each class. Are the values under IoU = 0.5 if IoU is in default? Is it possible to get recall50-95, precision50-95? thank you!

  5. Fatima-khanjarGitHub

    Hello,

    I hope this message finds you well. I have two questions:

    • There are plots showing different metrics. How can I use them to extract the performance values of the model, given that there are various confidence thresholds? During validation, the default IoU in YOLOv11 is 0.6. Does it remain stable when calculating precision, recall, and F1 score?
    • During validation, I see outputs like this: Class Images Instances Box(P) R mAP50 mAP50-95 all 30 240 0.917 0.911 0.973 0.817 Can I use these values to report the performance of the model? If yes, how can I extract them through coding?

    best regards,

    1. Glenn JocherUltralytics(수정됨)

      For accessing validation metrics programmatically, you can retrieve them directly from the results object after running model.val(). Here's a concise example:

      results = model.val()
      print(f"Precision: {results.box.mp}, Recall: {results.box.mr}, mAP50: {results.box.map50}, mAP50-95: {results.box.map}")

      The default iou=0.7 in val() is the NMS threshold, not the precision/recall threshold. Precision and recall are computed at IoU 0.5 at the confidence that maximizes F1, while mAP50-95 averages over IoU 0.5-0.95. The class-wise table values are valid for performance reporting - full implementation details are in the Model Evaluation Insights guide.

  6. e-roeGitHub

    Hello,

    Looking at the confusion matrices, I find the normalized one strange when compared to the non-normalized version. I decided to train a model with only one class to try to understand it, but the result left me even more confused. Could you explain the meaning of this normalized confusion matrix? Ultralitics version: 8.3.49 Non-normalized: 18953 ---- 159 12 ---- 0

    Normalized: 1.00 ---- 1.00 0.00 ---- 0.00

    Ps. I don't know how to attach an image here Thank you.

    1. Glenn JocherUltralytics(수정됨)

      @e-roe the normalized confusion matrix divides each column (a true class) by its total, so every column sums to 1. Rows are predictions and columns are true classes, including a background row/column. In your single-class case:

      • True object column: 18953 correct detections and 12 missed objects, so 18953/18965 ≈ 1.00 and 12/18965 ≈ 0.00
      • True background column: 159 false positives (background predicted as an object), so 159/159 = 1.00 and 0.00

      For deeper analysis, see our Performance Metrics Guide. Let us know if you need clarification on specific values! 🚀

    2. e-roeGitHub

      @glenn-jocher Thank you for your response.

      If it is row-wise normalization, shouldn't the sum of each row be 1.0? In Scikit-learn, the normalized confusion matrix appears as I expected, in my single-class case: 0.99168062 ---- 0.00831938

      1. ---- 0.

      This result is much easier for me to compare with the non-normalized confusion matrix and interpret. []'s

    3. e-roeGitHub

      Hi, Oh, I see... I think you calculate it this way: cm_normalized = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis] but I was expecting it to be like this: cm_normalized = cm.astype('float') / cm.sum(axis=0)[np.newaxis, :]

      Ok, thank you again.

    4. Glenn JocherUltralytics(수정됨)

      Thank you for catching this nuance! Ultralytics normalizes each column of the confusion matrix, which corresponds to a true class (rows are predictions), rather than each row as in scikit-learn's default. Each column therefore shows how the instances of one true class were predicted.

  7. Keletom1GitHub

    Problem with figuring out the IoU

    Hey there,

    i had been having some trouble with my models and finding out how they perform on new Data. I will explain, what i have been doing and hopefully someone can find out where i was going wrong :D

    What have I done so far:

    I have trained multiple models on different datasets and now i want to find out, how they perform when they are exposed to new data, some of which they have seen, some of which are completely new. The models are all single class segmentation YOLOv8 models and trained for 300 epochs, nothing too special because i just want to see how different models (trained of different datasets) perform on my test dataset. I had all my models run over said test dataset (Prüfdatensatz_2) of 62 images. I had the annotations saved as png and also as JSON. After that i went ahead and annotated all of my 62 images manually with roboflow and exported these as a JSON as well. So now i have the prediction-json files (one for each image) and one big GroundTruth-json file and i want to compare them and get a big results.csv in which the images names, the models they belong to and the Intersection over Union for each image are displayed. I have tried different approaches and the script itself does work, only the IoU-calculation does not seem to work. It's either 0.0 or 1.0 (the latter in case there is nothing to annotate and the model didn't predict anything in this image).

    My Code:
    import json
    import os
    import numpy as np
    import pandas as pd
    import re
    from shapely.geometry import Polygon
    
    # **1. COCO JSON laden**
    coco_json_path = r"C:\Users\wavet\Desktop\OneDrive\Uni\Semester 9\Bachelorarbeit\Datensätze\COCO_Prüfdatensatz_2-2\train\_annotations.coco.json"
    with open(coco_json_path, "r") as f:
        coco_data = json.load(f)
    
    # **2. Mapping-Tabelle für COCO JSON erstellen (Dateiendungen und Suffixe entfernen)**
    def clean_filename(filename):
        cleaned = re.sub(r"_png\.rf\..*|_jpg\.rf\..*", "", filename)  # Entfernt '.rf.<hash>' und Dateiendungen
        print(f"Original: {filename}, Bereinigt: {cleaned}")  # Debug-Ausgabe
        return cleaned
    
    image_id_to_filename = {img["id"]: clean_filename(img["file_name"]) for img in coco_data["images"]}
    gt_annotations = {}
    
    # **3. Konvertiert Segmentierungen in Polygone für IoU-Berechnung**
    def segmentation_to_polygon(segmentation):
        coordinates = [(segmentation[i], segmentation[i+1]) for i in range(0, len(segmentation), 2)]
        if len(coordinates) < 4:
            return None  # Weniger als 4 Punkte = kein gültiges Polygon
        return Polygon(coordinates)
    
    # **4. Ground-Truth-Annotationen nach `image_id` speichern**
    annotations_by_image = {}
    for ann in coco_data["annotations"]:
        img_id = ann["image_id"]
        if img_id not in annotations_by_image:
            annotations_by_image[img_id] = []
        if "segmentation" in ann and len(ann["segmentation"]) > 0:
            polygon = segmentation_to_polygon(ann["segmentation"][0])
            if polygon:
                annotations_by_image[img_id].append(polygon)
    
    # **5. Modell-Outputs einlesen & IoU berechnen**
    predictions_dir = r"C:\Users\wavet\Desktop\OneDrive\Uni\Semester 9\Bachelorarbeit\Ergebnisse_BA\Datensatzstudie\e1000\output_Prüfdatensatz_2_Skaliert"
    csv_output_path = r"C:\Users\wavet\Desktop\OneDrive\Uni\Semester 9\Bachelorarbeit\Ergebnisse_BA\Datensatzstudie\Auswertung_e1000\iou_results_v5.csv"
    
    def calculate_iou(polyA, polyB):
        intersection = polyA.intersection(polyB).area
        union = polyA.union(polyB).area
        iou = intersection / union if union > 0 else 0
        print(f"Intersection: {intersection}, Union: {union}, IoU: {iou}")  # Debug-Ausgabe
        return iou
    
    iou_results = []
    
    for model_name in os.listdir(predictions_dir):
        model_path = os.path.join(predictions_dir, model_name)
        if not os.path.isdir(model_path):
            continue
    
        print(f"Verarbeite Modell: {model_name}")
    
        for json_file in os.listdir(model_path):
            if json_file.endswith(".json"):
                img_name = clean_filename(json_file.replace(".json", ""))
    
                # **6. Passende `image_id` suchen**
                matching_ids = [img_id for img_id, file in image_id_to_filename.items() if file == img_name]
                if not matching_ids:
                    print(f"WARNUNG: Keine `image_id` für {img_name} gefunden!")
                    continue
                image_id = matching_ids[0]  # Falls mehrere IDs vorhanden sind, nehmen wir die erste
    
                # **7. GT-Annotationen laden**
                gt_polygons = annotations_by_image.get(image_id, [])
    
                # **8. Predictions laden**
                with open(os.path.join(model_path, json_file), "r") as f:
                    pred_data = json.load(f)
    
                if not isinstance(pred_data, list):
                    pred_data = [pred_data]  # Falls nur eine Vorhersage vorliegt, in Liste umwandeln
    
                pred_polygons = []
                for pred in pred_data:
                    if "segmentation" in pred and len(pred["segmentation"]) > 0:
                        polygon = segmentation_to_polygon(pred["segmentation"][0])
                        if polygon:
                            pred_polygons.append(polygon)
    
                # **9. IoU berechnen**
                if not gt_polygons and not pred_polygons:
                    avg_iou = 1.0  # Keine GT und keine Prediction → Perfekte Erkennung
                elif not gt_polygons or not pred_polygons:
                    avg_iou = 0.0  # Nur eine der beiden vorhanden → Fehlerkennung
                else:
                    total_iou = 0.0
                    matches = 0
                    used_preds = set()
    
                    for gt_polygon in gt_polygons:
                        best_iou = 0.0
                        best_pred = None
    
                        for i, pred_polygon in enumerate(pred_polygons):
                            if i in used_preds:
                                continue
                            iou = calculate_iou(gt_polygon, pred_polygon)
                            if iou > best_iou:
                                best_iou = iou
                                best_pred = i
    
                        if best_pred is not None:
                            used_preds.add(best_pred)
                            total_iou += best_iou
                            matches += 1
    
                    missing_objects = len(gt_polygons) - matches
                    avg_iou = (total_iou + missing_objects * 0.0) / len(gt_polygons)
    
                iou_results.append([model_name, img_name, avg_iou, np.mean([pred.get("confidence", 100) for pred in pred_data])])
    
    # **10. Ergebnisse speichern**
    iou_df = pd.DataFrame(iou_results, columns=["Model", "Image", "IoU", "Confidence"])
    iou_df.to_csv(csv_output_path, index=False)
    print(f"✅ IoU-Ergebnisse gespeichert unter: {csv_output_path}")
    What i checked:
    • segmentation coordinates are absolute for both JSONs
    • the coordinates seem to match, i was able to plot some of the prediction segmentations
    • alle img_ids were assigned correctly
    Questions:
    • What have I been doing wrong?
    • I have the feeling that there might be a much simpler way to find out how my models perform on new data and I just haven't found it yet. Is that so?

    Thank you all in advance!!

    Greetings, Tom

    1. Glenn JocherUltralytics

      @Keletom1 hi Tom! For evaluating segmentation models, we recommend using YOLOv8's native validation mode which automatically calculates all metrics including mAP and IoU. Simply run:

      from ultralytics import YOLO
      model = YOLO("your-model.pt")
      metrics = model.val(data='your-dataset.yaml')

      This handles all ground-truth/prediction matching and metric calculations out-of-the-box. The validation docs show how to interpret results: https://docs.ultralytics.com/modes/val/. For custom analysis, you could extend the built-in metrics calculation from our AP implementation: https://docs.ultralytics.com/reference/utils/metrics/#ap_per_class

    2. Keletom1GitHub

      Hi Glenn,

      thanks (again) for your help!

      That is some great information and saves quite a lot of work for me. I shoud have discovered that earlier.

      Anyway i still have some minor questions regarding the validation.

      1. The standard output for my segmentation model are plots of precision, recall, precision/recall and F1-score (for both the box and mask predictions). Since i don't need to compare the box recognition, is there any way i can disable this output?
      2. The IoU is not a metric that is calculated, is it? At least it is not in the predictions.json or the plots. Any idea on how i can display or calculate it anyway? Or would you recommend to just work with precision and recall?
      3. Could you briefly explain what exactly the JSON displays. I was expecting coordinates under "segmentation" but it just looks like a bunch of random letters and numbers....

      Here is an example of the first to images in my dataset:

      {"image_id": "-0008_1_png.rf.53cbd30c302485bebd6f33083f141f1c", "category_id": 1, "bbox": [222.615, 9.455, 270.527, 614.687], "score": 0.87661, "segmentation": {"size": [640, 640], "counts": "Uh[43Uch01dPXO3P]OJRb0:n]OMha06X^OM`a08`^OLXa08h^OLPa08P_OLg`09Y_OIb`0:^_OI\\`0:d_OKS`09m_OLj?8X@Ib?:b@FV?7TAJc>7dAHU>:QBFi=:]BE^=9kBHk<9[CJ\\<8iCIP<7WDJa;5gDLo:2ZE0\\:3jELQ:4VFKd93eFOS9OSG5c8MbG3X8NmG3l7K]H7X7IPI8f6L^I4]6MiI2Q6LYJ4`5JfJ<o4EVK;c4GcK9U4HRL;b3ChL>P3DTM=f2DaM:Z2EmM=j1A]Nd0Z1\\OjNe0Q1[OUOd0g0XOCj04TO3n0lKkM@W1h4n0eKoM]OT1U5k0[KRN]OR1`5l0mJSNBn0g5X1\\JjMKm0n5Z1SJkMLl0V6X1kIlMNh0a6^1ZIjM4d0i6h1kHdM:e0o6g1dHdM<d0W7e1[HgM<c0a7g1mGfMa0`0g7S2^G]Mj0?l7U2WG\\Ml0>T8U2lF]Mn0<_8W2]F^MR19g8Z2TF]MT18l8[2mE]MV18U9X2`EbMZ14^9Y2REdM`10c9^2iDbMc10h9]2dDcMc10P:Z2YDgMf1LY:]2mCfMj1I`:b2bCfMm1Hd:b2]CfMn1Hm:^2QCkMm?W2j_OmMT2^Od;`3ZDbLh;\\3nC^L]N2Q>W3aClLl<P3QCSMP=l2iB\\MY=a2dB[Ml=\\2nAZMhN:a?W2fAmM\\>R2cAoM`>n1^AfMnN2U`0j1j@UNe?j1X@WNk?g1U@YNn?d1a1G3M1O2N5K4L2N1O1O000O011O0O10002M2O1O1OO0100O010O10O0010O0010O01O0010O01O001O010O010O1O010O001O10O01O010O100O00100O00100O00100O010O10O0100O00100O010O010O10O01O010O1O010O010O1O010O0010O010O010O01O010O001O010O010O01O0100O00010O010O010O0010O01O01O010O010O01O01O01O000010O00010O01O1O001O00_kj2"}}, {"image_id": "-0008_1_png.rf.53cbd30c302485bebd6f33083f141f1c", "category_id": 1, "bbox": [148.255, 393.207, 71.421, 246.348], "score": 0.00426, "segmentation": {"size": [640, 640], "counts": "Wgm2b0\\c0O1O00O2OO01O010100OO0O21O00N01200OO0O111O0OO2O1100N00010000N12O10OO1N030O00OO11100OM20101OO1M311O0N00O21O00OO21O10OOO1110OOO110100N1O01101NhSV8"}}, {"image_id": "-0008_1_png.rf.53cbd30c302485bebd6f33083f141f1c", "category_id": 1, "bbox": [146.245, 394.098, 186.875, 244.714], "score": 0.00358, "segmentation": {"size": [640, 640], "counts": "`_l2?\\c02O11O1O00O2OO01O010100OO0O21O0OO1020O0O00011O0OO2O1100N0001000OO21O10OO1N030O00OO11100ON1O2010N0N311O0N00O21O00OO21O10OOO1110OO0001100N1O01101N3I7N2N[og02_PXO>F2K5L4L4K5M3K5M1ON11N30OOM30N4OO1N11M3010J40N4N10M4N12M11M1OO4N2ON3O01O1NOO112N20N2N2O101L4M21O0OO3M3O1O0M3N3O001N1N30O00M3N30O01M2N21O10M2M40mjn5"}}

      Thank you very much!

      Kind regards, Tom

    3. Glenn JocherUltralytics

      Hi Tom,

      1. Disabling box metrics: Currently, segmentation validation outputs both box and mask metrics together. You can safely ignore the box-related metrics/plots if you're focused on segmentation, but there's no built-in flag to disable box outputs specifically.

      2. IoU calculation: While per-image IoU isn't directly output, mAP metrics (mAP50, mAP50-95) in validation results are calculated using IoU thresholds. For custom per-instance IoU calculations, see our mask_iou function in the metrics utils.

      3. Segmentation format: The JSON uses Run-Length Encoding (RLE) for compact storage of masks. You can decode these with pycocotools (COCO API) or use our native Results class to access polygon coordinates directly from predictions.

      For deeper analysis, consider using the COCO evaluation tools which handle these formats natively.

      1
  8. vonzoGitHub

    After training I get the weights for "last" and "best", how do i know which line in the results.csv correspond to the "best" weights?

    1. Glenn JocherUltralytics(수정됨)

      @vonzo the 'best.pt' weights correspond to the epoch with the highest validation mAP50-95 metric. In your results.csv, look for the row where the metrics/mAP50-95(B) column (or similar mAP column for your task) reaches its maximum value - this is the epoch where best.pt was last saved.

    1. Glenn JocherUltralytics

      @Aniket1210 to measure latency for the YOLOv8 TSR model on an RTX 4090, you can use the model.val() or model.predict() functions with the verbose=True parameter in the Ultralytics API to retrieve timing details. Ensure your setup leverages the GPU (device='0') for accurate benchmarking. For further guidance, refer to the Ultralytics Val documentation.

  9. xiaoshuai123666GitHub

    这是来自QQ邮箱的自动回复邮件。你好,您的邮件我已收到,感谢您的来信,我一定仔细阅读您的邮件。                                                            ——xiaoshuai