Empezar

Validación de modelos con Ultralytics YOLO

Ultralytics YOLO ecosystem and integrations

Introducción#

La validación es una etapa fundamental del flujo de aprendizaje automático, ya que permite evaluar la calidad de tus modelos entrenados. El modo Val de Ultralytics YOLO26 proporciona herramientas y métricas para evaluar modelos de detección de objetos y de todas las demás tareas compatibles. Esta guía explica cómo utilizar el modo Val para confirmar que tus modelos son precisos y fiables.

Consulta la vista previa de YOLO27, aún no publicada para ver los resultados preliminares de validación.



Ver: Tutorial sobre los modos de Ultralytics: validación

¿Por qué validar con Ultralytics YOLO?#

Motivos para utilizar el modo Val de YOLO26:

  • Precisión: Obtén métricas precisas como mAP50, mAP75 y mAP50-95 para evaluar el modelo de forma exhaustiva.
  • Comodidad: Utiliza funciones integradas que recuerdan los ajustes de entrenamiento y simplifican el proceso de validación.
  • Flexibilidad: Valida tu modelo con los mismos conjuntos de datos o con otros distintos, y con tamaños de imagen iguales o diferentes.
  • Ajuste de hiperparámetros: Usa las métricas de validación para ajustar tu modelo y mejorar su rendimiento.

Características principales del modo Val#

Funciones destacadas del modo Val de YOLO26:

  • Ajustes automatizados: Los modelos recuerdan sus configuraciones de entrenamiento para facilitar la validación.
  • Compatibilidad con varias métricas: Evalúa tu modelo con una serie de métricas de precisión.
  • CLI y API de Python: Valida desde la interfaz de línea de comandos o la API de Python, como prefieras.
  • Compatibilidad con datos: Funciona tanto con los conjuntos de datos utilizados durante el entrenamiento como con conjuntos de datos personalizados.
Consejo
  • Los modelos YOLO26 recuerdan automáticamente sus ajustes de entrenamiento, así que yolo val model=path/to/best.pt o YOLO("path/to/best.pt").val() valida con el tamaño de imagen del entrenamiento y el conjunto de datos original. Si se usan pesos oficiales, se recurre al conjunto de datos predeterminado de la tarea; pasa data para anularlo.

Ejemplos de uso#

Valida la precisión de un modelo YOLO26n entrenado. No hacen falta argumentos, ya que model conserva los argumentos y data del entrenamiento como atributos del modelo: path/to/best.pt valida con el conjunto de datos utilizado para entrenarlo. Los pesos oficiales registran una ruta al conjunto de datos de entrenamiento que no existe en tu equipo, por lo que recurren al valor predeterminado de la tarea coco8.yaml y muestran una advertencia. Pasa data para validar con otro conjunto de datos.

Error de multiprocesamiento en Windows

En Windows, puede aparecer un RuntimeError al iniciar la validación como script. Añade un bloque if __name__ == "__main__": antes del código de validación para solucionarlo.

Ejemplo
from ultralytics import YOLO

# Cargar un modelo
model = YOLO("yolo26n.pt")  # carga un modelo oficial
model = YOLO("path/to/best.pt")  # cargar un modelo personalizado

# Valida el modelo
metrics = model.val()  # no hacen falta argumentos; se recuerdan el conjunto de datos y los ajustes
metrics.box.map  # map50-95
metrics.box.map50  # map50
metrics.box.map75  # map75
metrics.box.maps  # mAP50-95 por clase; las clases ausentes del conjunto de validación conservan el mAP global
metrics.box.ap_class_index  # índices de las clases que se evaluaron realmente
metrics.box.image_metrics  # diccionario de métricas por imagen con precisión, exhaustividad, F1, TP, FP y FN

Argumentos para la validación de modelos YOLO#

Al validar modelos YOLO, puedes ajustar varios argumentos para adaptar el proceso de evaluación. Estos argumentos controlan aspectos como el tamaño de las imágenes de entrada, el procesamiento por lotes y los umbrales de rendimiento. A continuación se describe cada argumento.

ArgumentoTipoPredeterminadoDescripción
datastrNoneEspecifica la ruta al YAML del conjunto de datos (p. ej., coco8.yaml), que debe incluir la ruta a los datos de validación. Para la clasificación, en cambio, se usa un directorio de conjunto de datos o el nombre de un conjunto de datos integrado (p. ej., imagenet10).
imgszint640Define el tamaño de las imágenes de entrada. Todas las imágenes se redimensionan a estas dimensiones antes del procesamiento. Los tamaños mayores pueden mejorar la precisión en objetos pequeños, pero aumentan el tiempo de cálculo.
batchint16Establece el número de imágenes por lote. Los valores más altos aprovechan mejor la memoria de la GPU, pero requieren más VRAM. Ajústalo según los recursos de hardware disponibles.
tilebool o intFalseEjecuta inferencia con teselas fijas y evalúa los resultados fusionados frente a las anotaciones de la imagen completa original. True usa imgsz; un entero positivo establece el tamaño de las teselas. Consulta Teselado de alta resolución.
save_jsonboolFalseSi True, guarda los resultados en un archivo JSON para analizarlos más adelante, integrarlos con otras herramientas o enviarlos a servidores de evaluación como COCO. En los conjuntos de datos de detección, también evalúa las predicciones con faster-coco-eval e informa del mAP de objetos pequeños, medianos y grandes, registrado durante el entrenamiento como metrics/mAP_small(B), metrics/mAP_medium(B) y metrics/mAP_large(B) en results.csv. Para la segmentación semántica, en su lugar guarda máscaras de clases PNG en results/, conservando los subdirectorios de las imágenes.
conffloat0.001Establece el umbral mínimo de confianza para las detecciones. Los valores más bajos aumentan la exhaustividad, pero pueden introducir más falsos positivos. Las curvas de precisión-exhaustividad, el mAP y las matrices de confusión de detección usan este valor; un conf más alto, como 0.25, genera una matriz más parecida a la salida de predicción, pero puede reducir el mAP. La precisión y la exhaustividad resumidas usan la confianza de F1 máximo, por lo que pueden diferir de los valores derivados de confusion_matrix.png. El valor predeterminado para la validación OBB es 0.01 para reducir el uso de memoria.
ioufloat0.7Establece el umbral de intersección sobre unión para la supresión no máxima. Controla la eliminación de detecciones duplicadas.
max_detint300Limita el número máximo de detecciones por imagen. Para detect, segment, pose y OBB, si se mantiene en 300, el límite aumenta hasta el mayor número de objetos etiquetados en la partición validada cuando una imagen lo supera, y se muestra una advertencia; cualquier otro valor se conserva y se muestra una advertencia de que el recall puede quedar limitado si una imagen supera el valor.
quantizeint o strNonePrecisión de validación: 16/"fp16" y 32/"fp32"/unset seleccionan el cálculo FP16 o FP32 para los modelos PyTorch y TorchScript (FP32 en CPU); los demás formatos usan la precisión que seleccionen el artefacto y el entorno de ejecución. En 16, OpenVINO sigue redondeando la entrada a FP16 en el cliente y volviéndola a ampliar a FP32, sin cambiar la precisión del entorno de ejecución. La cuantización INT8/PTQ se configura durante la exportación y se utiliza después al validar el modelo exportado. Sustituye a la marca obsoleta half.
devicestrNoneEspecifica el dispositivo para la validación (cpu, cuda:0, npu, npu:0, etc.). Cuando None, selecciona automáticamente el mejor dispositivo disponible. Se pueden especificar varios dispositivos CUDA separándolos con comas. Los modelos OpenVINO y LiteRT se ejecutan xpu y npu en la GPU y la NPU Intel; consulta dispositivos de inferencia para ver cada formato.
dnnboolFalseSi True, usa el módulo DNN de OpenCV para la inferencia de modelos ONNX, como alternativa a los métodos de inferencia de PyTorch.
plotsboolTrueSi se establece en True, genera y guarda gráficos que comparan las predicciones con la verdad de referencia, matrices de confusión y curvas PR para evaluar visualmente el rendimiento del modelo.
classeslist[int]NoneEspecifica una lista de ID de clase que se van a evaluar. Es útil para filtrar y centrarse solo en determinadas clases durante la evaluación.
rectboolTrueSi True, agrupa las imágenes con relaciones de aspecto similares en formas rectangulares. Añade medio stride antes de redondear cada dimensión al siguiente múltiplo del stride (sin añadir medio stride adicional para semantic). Con un stride de 32, una imagen de 640×640 en imgsz=640 pasa a tener 672×672 con un desplazamiento de 16 px, mientras que predict usa 640×640, por lo que las métricas pueden diferir. rect=False coincide con predict en imágenes cuadradas. Se ignora en depth y RT-DETR, que estiran las imágenes hasta un cuadrado imgsz.
splitstr'val'Determina qué partición del conjunto de datos se usa para la validación (val, test o train). Permite elegir con flexibilidad el segmento de datos para evaluar el rendimiento.
fractionfloat, int o list1.0Subconjunto de la partición validada. Con una lista [train, val, test], se aplica la entrada que coincida con split (1 = partición completa; los enteros superiores a 1 = número de imágenes; las entradas omitidas corresponden a la partición completa). Un valor escalar solo se aplica con split=train; val y test usan entonces la partición completa.
projectstrNoneNombre del directorio del proyecto donde se guardan los resultados de la validación. Una ruta relativa se coloca dentro de runs_dir/<task>, mientras que una ruta absoluta se usa tal cual.
namestrNoneNombre de la ejecución de validación. Se usa para crear un subdirectorio dentro de la carpeta del proyecto, donde se guardan los registros y resultados de validación.
verboseboolTrueSi True, muestra información detallada durante el proceso de validación, incluidas las métricas por clase, el progreso de los lotes y más información de depuración.
save_txtboolFalseSi True, guarda los resultados de detección en archivos de texto, uno por imagen. Es útil para realizar análisis adicionales, posprocesamiento personalizado o integraciones con otros sistemas.
save_confboolFalseSi True, incluye valores de confianza en los archivos de texto guardados cuando se activa save_txt, lo que proporciona resultados más detallados para el análisis y el filtrado.
workersint8Número de subprocesos de trabajo para cargar datos. Los valores más altos pueden acelerar el preprocesamiento, pero aumentar el uso de la CPU. Si se establece en 0, se usa el hilo principal, lo que puede ser más estable en algunos entornos.
augmentboolFalseActiva el aumento en tiempo de prueba (TTA) durante la validación, lo que puede mejorar la precisión de detección a costa de la velocidad de inferencia al ejecutar la inferencia con versiones transformadas de la entrada. Solo está disponible para modelos PyTorch de Ultralytics.
agnostic_nmsboolFalseActiva la supresión no máxima sin distinción de clases, que suprime las cajas superpuestas con puntuaciones más bajas independientemente de la clase predicha. Es útil para aplicaciones centradas en instancias. Con la inferencia sin NMS (nms=False en YOLO26 o YOLOv10), solo evita que una misma detección aparezca con varias etiquetas de clase (duplicados con IoU=1.0) y no aplica supresión basada en el umbral IoU entre cajas distintas.
single_clsboolFalseTrata todas las clases como una sola durante la validación. Es útil para evaluar el rendimiento del modelo en tareas de detección binaria o cuando las diferencias entre clases no son importantes.
visualizeboolFalseVisualiza la verdad de referencia, los verdaderos positivos, los falsos positivos y los falsos negativos de cada imagen. Es útil para depurar e interpretar el modelo.
show_labelsboolTrueMuestra las etiquetas de clase en las visualizaciones de validación cuando visualize=True. Configúralo en False para ver las coincidencias y los errores con más claridad.
show_confboolTrueMuestra las puntuaciones de confianza en las visualizaciones de validación cuando visualize=True. Configúralo en False para ver las coincidencias y los errores con más claridad.
compilebool o strFalseActiva la compilación de grafos torch.compile de PyTorch 2.x con backend='inductor'. Acepta True → "default" para activarla, False → para desactivarla o un modo de cadena como "default", "reduce-overhead", "max-autotune-no-cudagraphs". Si no es compatible, vuelve al modo eager y muestra una advertencia.
channels_lastboolNoneUsa el formato de memoria channels_last (NHWC) para la validación nativa de PyTorch. None lo activa automáticamente en CPU x86 con Linux y Windows, compatible con oneDNN y PyTorch 1.13 o posterior; False lo desactiva y True lo solicita en dispositivos CPU x86 o CUDA compatibles. ARM64, MPS, las versiones anteriores de PyTorch, las CPU sin oneDNN y los formatos exportados no cambian; durante el entrenamiento, la validación mantiene la disposición del modelo de entrenamiento.
nmsbool, opcionalNonePor defecto, ejecuta inferencia uno a varios con NMS (None o True). Configura False para usar el cabezal uno a uno sin NMS cuando esté disponible. Consulta la guía de detección de extremo a extremo para obtener más información.

Ajustar estos parámetros a tus necesidades y recursos te ayuda a encontrar el equilibrio adecuado entre la precisión y la velocidad de evaluación.

Geometría de validación rectangular (rect)#

Las exportaciones estáticas usan la forma de entrada registrada (height, width), incluidas las exportaciones no cuadradas, para la validación. Por ejemplo, YOLO("yolo26n.onnx").val(data="coco8.yaml") usa una entrada 384×640 si el modelo se exportó con imgsz=(384, 640).

Para detección, segmentación de instancias, pose y OBB, la validación rectangular (rect=True) redondea cada dimensión del lote hacia arriba usando ceil(shape * imgsz / stride + 0.5) * stride, donde shape es la altura o anchura normalizada del lote. El relleno resultante se reparte entre los lados opuestos. Por ejemplo, una imagen cuadrada de 640×640 validada en imgsz=640 con un stride de 32 usa una entrada de 672×672 con 16 px de relleno en cada lado, mientras que predict() usa 640×640 sin relleno.

Esta diferencia puede afectar a las métricas de validación. Para entradas cuadradas alineadas con el stride, model.val(rect=False) coincide con la geometría de predict() y de las exportaciones cuadradas con forma fija. Durante el entrenamiento, estas tareas de YOLO usan lotes de validación rectangulares independientemente del ajuste de entrenamiento rect, por lo que model.train(rect=False) sigue seleccionando best.pt mediante la validación rectangular. Otras tareas son distintas: la segmentación semántica no añade relleno adicional durante la validación, la estimación de profundidad desactiva la validación rectangular, la clasificación ignora rect y RT-DETR usa su propio generador de conjuntos de datos con rect=False.

Ejemplo de validación con argumentos#



Ver: Cómo exportar los resultados de validación de modelos a CSV, JSON, SQL, DataFrame de Polars y mucho más

Explore model validation and different export methods in Google Colab

Los ejemplos siguientes ejecutan la validación de un modelo YOLO con argumentos personalizados en Python y CLI.

Ejemplo
from ultralytics import YOLO

# Cargar un modelo
model = YOLO("yolo26n.pt")

# Personaliza los ajustes de validación
metrics = model.val(data="coco8.yaml", imgsz=640, batch=16, conf=0.25, iou=0.7, device="0")
Exportar ConfusionMatrix

También puedes exportar los resultados de la matriz de confusión en distintos formatos, por ejemplo, como un DataFrame:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

results = model.val(data="coco8.yaml", plots=True)
print(results.confusion_matrix.to_df())
Precisión, exhaustividad y F1 por imagen

La validación guarda métricas por imagen de precisión, recuperación, F1, TP, FP y FN (con un umbral de IoU de 0.5). Accede a ellas mediante results.box.image_metrics para detección y OBB, results.seg.image_metrics para segmentación y results.pose.image_metrics para pose, una vez finalizada la validación.

from ultralytics import YOLO

# Cargar un modelo
model = YOLO("yolo26n.pt")

# Valida y accede a las métricas por imagen
results = model.val(data="coco8.yaml")

# Las claves son rutas relativas al directorio común de imágenes, p. ej., 'image1.jpg' o 'a/image1.jpg'
print(results.box.image_metrics)
# Output: {'image1.jpg': {'precision': 0.85, 'recall': 0.92, 'f1': 0.88, 'tp': 17, 'fp': 3, 'fn': 1}, ...}

# Accede a las métricas de una imagen concreta
results.box.image_metrics["image1.jpg"]  # {'precision': 0.85, 'recall': 0.92, 'f1': 0.88, 'tp': 17, 'fp': 3, 'fn': 1}

Cada entrada de image_metrics contiene las siguientes claves:

ClaveDescripción
precisionPuntuación de precisión de la imagen (tp / (tp + fp)).
recallPuntuación de exhaustividad de la imagen (tp / (tp + fn)).
f1Media armónica de la precisión y la exhaustividad.
tpNúmero de verdaderos positivos de la imagen.
fpNúmero de falsos positivos de la imagen.
fnNúmero de falsos negativos de la imagen.

Esta función está disponible para las tareas de detección, segmentación, pose y OBB.

El objeto de métricas devuelto también ofrece funciones de exportación de DataExportMixin para análisis posteriores:

MétodoTipo de retornoDescripción
summary()List[Dict[str, Any]]Devuelve los resultados de validación como una lista de diccionarios, uno por fila.
to_df()DataFrameDevuelve los resultados de validación como un DataFrame de Polars estructurado.
to_csv()strExporta los resultados de validación en formato CSV y devuelve la cadena CSV.
to_json()strExporta los resultados de validación en formato JSON y devuelve la cadena JSON.

Los resultados de detección, segmentación, segmentación semántica, pose y OBB tienen una fila por clase en las etiquetas de validación, por lo que to_csv() y to_json() exportan métricas por clase:

TareaColumnas por clase
detecciónClass, Images, Instances, Box-P, Box-R, Box-F1, mAP50, mAP75, mAP50-95
segmentaciónLas columnas de detección, seguidas de Mask-P, Mask-R, Mask-F1, Mask-mAP50, Mask-mAP75, Mask-mAP50-95
semánticaClass, Images, Pixels, IoU, mIoU y pixel_acc (ambos globales), class_pixel_acc
poseLas columnas de detección, seguidas de Pose-P, Pose-R, Pose-F1, Pose-mAP50, Pose-mAP75, Pose-mAP50-95
obbLas columnas de detección

La estimación de profundidad devuelve una sola fila con delta1, delta2, delta3, abs_rel, rmse y silog, y la clasificación devuelve una sola fila con top1_acc y top5_acc.

from ultralytics import YOLO

model = YOLO("yolo26n-seg.pt")
metrics = model.val(data="coco8-seg.yaml")
metrics.to_csv()  # una fila por clase, con métricas de cajas y máscaras

Qué hacer a continuación#

¿Te convencen las métricas? Exporta el modelo a un formato de despliegue. Si la precisión no es la adecuada, vuelve atrás y entrena de nuevo con hiperparámetros distintos o más datos de entrenamiento.

Preguntas frecuentes#

  • Para validar tu modelo YOLO26, puedes usar el modo Val que ofrece Ultralytics. Por ejemplo, con la API de Python puedes cargar un modelo y ejecutar la validación así:

    from ultralytics import YOLO
    
    # Cargar un modelo
    model = YOLO("yolo26n.pt")
    
    # Valida el modelo
    metrics = model.val()
    print(metrics.box.map)  # map50-95

    También puedes usar la interfaz de línea de comandos (CLI):

    yolo detect val model=yolo26n.pt data=coco8.yaml

    Para personalizarlo más, puedes ajustar varios argumentos, como imgsz, batch y conf, tanto en Python como en CLI. Consulta la sección Argumentos para la validación de modelos YOLO para ver la lista completa de parámetros.

  • La validación de modelos YOLO26 proporciona varias métricas clave para evaluar el rendimiento del modelo. Entre ellas se incluyen:

    • mAP50 (precisión media con un umbral de IoU de 0,5)
    • mAP75 (precisión media con un umbral de IoU de 0,75)
    • mAP50-95 (precisión media en varios umbrales de IoU, de 0,5 a 0,95)

    Con la API de Python, puedes acceder a estas métricas así:

    metrics = model.val()  # se supone que `model` ya está cargado
    print(metrics.box.map)  # mAP50-95
    print(metrics.box.map50)  # mAP50
    print(metrics.box.map75)  # mAP75
    print(metrics.box.maps)  # mAP50-95 por clase; las clases ausentes del conjunto de validación conservan el mAP global
    print(metrics.box.ap_class_index)  # índices de las clases que se evaluaron realmente
    print(metrics.box.image_metrics)  # diccionario de métricas por imagen con precisión, exhaustividad, F1, TP, FP y FN

    Revisa todas estas métricas para obtener una evaluación completa del rendimiento.

  • Usar Ultralytics YOLO para la validación ofrece varias ventajas:

    • Precisión: YOLO26 ofrece métricas de rendimiento precisas, como mAP50, mAP75 y mAP50-95.
    • Comodidad: Los modelos recuerdan sus ajustes de entrenamiento, lo que simplifica la validación.
    • Flexibilidad: Puedes validar con los mismos conjuntos de datos o con otros distintos, y con tamaños de imagen iguales o diferentes.
    • Ajuste de hiperparámetros: Las métricas de validación ayudan a ajustar los modelos y mejorar su rendimiento.

    Estas ventajas te ayudan a evaluar los modelos en profundidad y a optimizarlos.

  • Sí, puedes validar tu modelo YOLO26 con un conjunto de datos personalizado. Especifica el argumento data con la ruta al archivo YAML de tu conjunto de datos, que debe incluir la ruta a los datos de validación. Para clasificación, en cambio, se indica un directorio de conjunto de datos o el nombre de un conjunto de datos integrado (p. ej., imagenet10).

    Nota

    La validación se realiza utilizando los nombres de clase del propio modelo, que puedes consultar con model.names y que pueden diferir de los definidos por el conjunto de datos.

    Ejemplo en Python:

    from ultralytics import YOLO
    
    # Cargar un modelo
    model = YOLO("yolo26n.pt")
    
    # Valida con un conjunto de datos personalizado
    metrics = model.val(data="path/to/your/custom_dataset.yaml")
    print(metrics.box.map)  # map50-95

    Ejemplo con CLI:

    yolo val model=yolo26n.pt data=path/to/your/custom_dataset.yaml

    Para ver más opciones de personalización durante la validación, consulta la sección Ejemplo de validación con argumentos.

  • Para guardar los resultados de validación en un archivo JSON, puedes establecer el argumento save_json en True al ejecutar la validación. Puedes hacerlo tanto con la API de Python como con CLI.

    Ejemplo en Python:

    from ultralytics import YOLO
    
    # Cargar un modelo
    model = YOLO("yolo26n.pt")
    
    # Guarda los resultados de validación en JSON
    metrics = model.val(save_json=True)

    Ejemplo con CLI:

    yolo val model=yolo26n.pt save_json=True

    En los conjuntos de datos de detección, save_json=True también indica la mAP de objetos pequeños, medianos y grandes mediante faster-coco-eval. Consulta Argumentos para la validación de modelos YOLO para obtener más información.

Comentarios279

Haz una pregunta, comparte tus resultados o ayuda a otra persona.

  1. BedoHatemGitHub

    I have a couple of models (a mix of object detection and segmentation), so I want to run them on the same validation dataset to compare them properly. The exact tasks for the seg and obj-det models are the same at a certain level, so I'm aware that seg models give a B-Box and Mask, while obj-det gives just a B-Box.

    With that said, will a segmentation dataset work on both seg and obj-det models ? Or should i make a seg and a obj-det version of the same dataset, so i can use it to equally validate the models ?

    Thanks in Advance

    1
    1. BedoHatemGitHub

      I tested it. It seems you can use a segmentation dataset to validate an obj-det model, as the seg datasets include B-Boxes and Masks of the classes.

      1
    2. Glenn JocherUltralytics(editado)

      @BedoHatem yes, you're correct! Segmentation datasets can be used to validate object detection models because they contain the bounding box annotations needed for detection evaluation. The segmentation masks are simply ignored when the dataset is used with a detection model.

      This flexibility is an advantage of the YOLO annotation format - the additional segmentation data doesn't interfere with detection evaluation. For the most accurate comparison between models, using the same validation dataset ensures you're evaluating performance on exactly the same ground truth data.

      @417dq the recall reported by val() is taken at the confidence value that maximizes F1, while the confusion matrix is built at the validation conf (0.001 by default) with an IoU matching threshold of 0.45, so the two can differ. The metrics output from val() is the reference for your model's performance.

  2. CyedenGitHub

    请问如果验针集是已经被多尺度分割了,那么再进行验证的时候imgsz应该设置为不同尺度验证的逻辑吗?例如: if name == 'main': model = YOLO(r'C:\Users\Lazy\Desktop\yolo_detect\weights\best.pt')

    multi_scale_sizes = [640, 800, 1024, 1280] 
    
    for size in multi_scale_sizes:
        model.val(
            data='ultralytics/cfg/datasets/DOTAv1.yaml',
            split='val',
            imgsz=size,
            batch=16,
            project='runs/val',
            name=f'v8n-obb-LSKNet_prev8x-obbpt_{size}',
        )
    1
    1. Glenn JocherUltralytics

      @Cyeden for multi-scale validation, you can indeed set imgsz to different scales within a loop. This approach allows you to evaluate the model's performance across various image sizes. Your implementation looks correct. Ensure you are using the latest version of the Ultralytics package to avoid any potential issues. For more details, you can refer to the validation documentation.

  3. YunYeTangGitHub

    hi, when I use yolov8-obb to validate DOTAv1, I found that confusion matrix is empty. Does it mean that confusion matrix is not supported in OBB validation?

    1
    1. Glenn JocherUltralytics(editado)

      Hi there! 👋

      The confusion matrix is supported for OBB validation in current Ultralytics versions. If yours is empty, update with pip install -U ultralytics and re-run validation with plots=True. If it is still empty, please share your yolo checks output and the validation command so we can look into it.

      In the meantime, you can still rely on the other validation metrics such as mAP, precision, and recall.

    2. Glenn JocherUltralytics(editado)

      Hey there! 🚀

      Thank you for reaching out! The confusion matrix is supported for OBB validation in current Ultralytics versions. If yours is empty, update with pip install -U ultralytics and re-run validation with plots=True; if it is still empty, share your yolo checks output and validation command so we can look into it.

      For a comprehensive evaluation you can also rely on the other metrics provided during validation, such as mAP, precision, and recall. Cheers! 🌟

  4. xyzxyzxyzxyzxzGitHub

    I want to read this page in English. Why it automatically become Chinese even though I click "GB English".

    1. Glenn JocherUltralytics

      It looks like you’re on the Chinese locale (the URL contains "/zh/"). Remove "/zh/" to view the English version, or use the top‑right language selector (GB English) and hard‑refresh; also ensure your browser’s auto‑translate is disabled.

    2. Glenn JocherUltralytics

      Thanks for the detailed description—that behavior sounds like a docs locale‑routing bug on our side rather than anything you can fix locally; we’ll get it forwarded to the web/docs team, and in the meantime could you confirm whether going directly to the English URL Model Validation with Ultralytics YOLO (English) still forces you back to Chinese and share your OS + browser version so we can reproduce it?

    3. Glenn JocherUltralytics

      Thanks for the extra details—that confirms this is an issue on the docs side, likely tied to your system/browser language being Chinese and our locale detection forcing /zh/ even when you pick English. I’ve passed this to the web/docs team to investigate; as a temporary workaround you can try using a browser whose interface language is set to English (or move English to the top of Chrome’s language preferences) so the site stops auto‑redirecting to the Chinese locale.

  5. AA278-HUBGitHub

    I have a model trained on a dataset containing four classes (car, bus, motorbike, and trunk). Now, I have a new dataset with only one class (vehicle). How can I validate this model using the new dataset, given that I only care about whether the model can identify the vehicle and its position, without concern for the specific type of vehicle?

    1. AA278-HUBGitHub

      f I want to change the validation rules in this specific situation, which .py files need to be modified

    2. Glenn JocherUltralytics

      @liujixingit save_txt writes normalized YOLO xywh (center x/y, width, height) relative to the original image size; recover pixel xyxy via the original W,H then center→corner conversion, e.g.:

      # line format: class x y w h [conf]
      cls, x, y, w, h, *rest = map(float, line.split())
      x1 = (x - w/2) * W; y1 = (y - h/2) * H
      x2 = (x + w/2) * W; y2 = (y + h/2) * H

      Function details are in the save_one_txt reference and the save_txt format is noted under Validation settings.

      @carlos-cell To get APs/APm/APl, run COCO-style evaluation with JSON saving and check the printed COCO summary:

      yolo detect val model=yolo11n.pt data=coco.yaml save_json=True

      This triggers COCO eval inside validation; see COCO evaluation in val and the size-specific metrics overview in the Performance metrics deep dive.

      @AA278-HUB For “any vehicle” validation, use single-class evaluation so all types collapse to one:

      metrics = model.val(data='vehicle.yaml', single_cls=True, agnostic_nms=True)

      Argument behavior is documented in the Val mode arguments.

      @AA278-HUB You don’t need code changes for the above, but if you must customize matching/metrics, start from DetectionValidator and the val() entry point: see the DetectionValidator reference and the val() method in engine/model.py; if proposing a PR, please keep scope minimal and include tests.

  6. liujixingitGitHub

    YOLOv8 调用验证功能开启save_txt后保存的坐标如何还原到原图,我尝试了直接×原图宽高,还原的坐标是错误的。save_txt保存的结果是相对什么计算得出的归一化坐标?

  7. CherishzyhGitHub

    hello, I read some dialog about the IOU threshold and confidence threshold and have some questions.

    1. CherishzyhGitHub
      1. the document shows that 'iou' is the threshold for NMS.Is it also a threshold for calculate the confusion matrix? eg. I hope that if the IoU between the prediction and the ground truth is greater than 0.2, it will be considered a true positive (TP). At the same time, does the NMS threshold also have to be 0.2?
    2. CherishzyhGitHub
      1. For confidence threshold, if I set it to 0.1, that mean all bboxes with a score lower than 0.1 will be removed when calculate the PR-curve?. If so, does it will also be remove in result json or txt ?
    3. Glenn JocherUltralytics

      @Cherishzyh great questions:

      1. The iou argument in val() controls NMS overlap removal only; it does not change the IoU used to determine TP/FP or mAP. Metrics are computed over fixed IoU thresholds 0.50–0.95. If you need evaluation at IoU=0.2, export predictions and compute custom metrics offline. See the Performance Metrics deep dive.

      2. The conf argument is a minimum score filter. Setting conf=0.1 removes all predictions with score < 0.1 prior to evaluation and from saved outputs (save_json/save_txt). You can still access PR data from the results object:

      from ultralytics import YOLO
      model = YOLO("yolo11n.pt")
      res = model.val(conf=0.1, iou=0.7, save_json=True, save_txt=True, plots=True)
      print(res.box.p_curve)  # precision curve vs score thresholds
      print(res.box.r_curve)  # recall curve vs score thresholds

      Argument details are in the Val mode arguments.

  8. lauravchrobakGitHub

    When I run validate without setting plots=True I still get the f1, PR curve plots in the val folder. Potentially the default for this flag is actually true despite it being false in the table above?

  9. sea190GitHub

    The question about val of yoloworld, and I used my custom dataset, and I make sure the format of ma dataset is corret. While when I run the val.py the code still validate the categories of COCO Dataset instead of my dataset? How can I solve this problem?

    1. ihciabGitHub

      You can try specifying the path of the validation set. When calling the val function, specify model.val(data=‘your_data’)

    2. Glenn JocherUltralytics

      @sea190 for YOLO-World validation with custom datasets, ensure your dataset YAML file correctly defines the class names and paths. YOLO-World may default to COCO categories if the dataset configuration isn't properly specified. Try:

      model.val(data='path/to/your/custom_dataset.yaml')

      Make sure your YAML file includes the correct names field with your custom class names and verify the val path points to your validation images and labels. If issues persist, check that your dataset follows the expected format for YOLO-World validation.