Validación de modelos con Ultralytics YOLO#
Introducción#
La validación es un paso fundamental en el flujo de aprendizaje automático, ya que te permite evaluar la calidad de tus modelos entrenados. El modo Val de Ultralytics YOLO26 proporciona un conjunto sólido de herramientas y métricas para evaluar el rendimiento de tus modelos de detección de objetos. Esta guía es un recurso completo para comprender cómo usar eficazmente el modo Val y garantizar que tus modelos sean precisos y fiables.
Consulta la vista previa inédita de YOLO27 para ver los resultados de validación preliminares.
Watch: Ultralytics Modes Tutorial: Validation
¿Por qué validar con Ultralytics YOLO?#
Estas son las ventajas de usar el modo Val de YOLO26:
- Precisión: Obtén métricas precisas como mAP50, mAP75 y mAP50-95 para evaluar tu modelo de forma exhaustiva.
- Comodidad: Utiliza funciones integradas que recuerdan la configuración de entrenamiento y simplifican el proceso de validación.
- Flexibilidad: Valida tu modelo con los mismos conjuntos de datos o con otros, y con distintos tamaños de imagen.
- Ajuste de hiperparámetros: Usa las métricas de validación para perfeccionar tu modelo y mejorar su rendimiento.
Funciones principales del modo Val#
Estas son las funcionalidades destacadas que ofrece el modo Val de YOLO26:
- Configuración automatizada: Los modelos recuerdan sus configuraciones de entrenamiento para facilitar la validación.
- Compatibilidad con varias métricas: Evalúa tu modelo según un conjunto de métricas de precisión.
- API de CLI y Python: Elige entre la interfaz de línea de comandos o la API de Python según tus preferencias para la validación.
- Compatibilidad de datos: Funciona sin problemas tanto con los conjuntos de datos usados durante el entrenamiento como con conjuntos de datos personalizados.
- Los modelos YOLO26 recuerdan automáticamente su configuración de entrenamiento, por lo que puedes validar fácilmente un modelo con el mismo tamaño de imagen y el conjunto de datos original usando solo
yolo val model=yolo26n.ptoYOLO("yolo26n.pt").val()
Ejemplos de uso#
Valida la precisión de un modelo YOLO26n entrenado con el conjunto de datos COCO8. No se necesitan argumentos, ya que model conserva su data de entrenamiento y los argumentos como atributos del modelo. Consulta la sección Argumentos más abajo para ver la lista completa de argumentos de validación.
En Windows, es posible que recibas un RuntimeError al iniciar la validación como script. Añade un bloque if __name__ == "__main__": antes del código de validación para resolverlo.
from ultralytics import YOLO
# Load a model
model = YOLO("yolo26n.pt") # load an official model
model = YOLO("path/to/best.pt") # load a custom model
# Validate the model
metrics = model.val() # no arguments needed, dataset and settings remembered
metrics.box.map # map50-95
metrics.box.map50 # map50
metrics.box.map75 # map75
metrics.box.maps # a list containing mAP50-95 for each category
metrics.box.image_metrics # per-image metrics dictionary with precision, recall, F1, TP, FP, and FNArgumentos para la validación de modelos YOLO#
Al validar modelos YOLO, puedes ajustar varios argumentos para optimizar 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 detalla cada argumento para ayudarte a personalizar eficazmente la configuración de validación.
| Argumento | Tipo | Predeterminado | Descripción |
|---|---|---|---|
data | str | None | Especifica la ruta al YAML del conjunto de datos (por ejemplo, coco8.yaml), que debe incluir la ruta a los datos de validación. En clasificación, se indica un directorio de conjunto de datos o el nombre de un conjunto de datos integrado (por ejemplo, imagenet10). |
imgsz | int | 640 | Define el tamaño de las imágenes de entrada. Todas las imágenes se redimensionan a estas dimensiones antes del procesamiento. Los tamaños más grandes pueden mejorar la precisión con objetos pequeños, pero aumentan el tiempo de cálculo. |
batch | int | 16 | Establece el número de imágenes por lote. Los valores más altos utilizan la memoria de la GPU de forma más eficiente, pero requieren más VRAM. Ajústalo según los recursos de hardware disponibles. |
save_json | bool | False | Si True, guarda los resultados en un archivo JSON para su posterior análisis, integración con otras herramientas o envío a servidores de evaluación como COCO. En conjuntos de datos de detección, también evalúa las predicciones con faster-coco-eval e informa el 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. |
conf | float | 0.001 | Establece 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 usan 0.001 de forma predeterminada; las matrices de confusión de detección usan un valor explícito conf, o 0.25 cuando se omite. La precisión y la exhaustividad resumidas usan la confianza del F1 máximo, por lo que pueden diferir de los valores derivados de confusion_matrix.png. El valor predeterminado es 0.01 para la validación de OBB con el fin de reducir el uso de memoria. |
iou | float | 0.7 | Establece el umbral de intersección sobre unión para la supresión no máxima. Controla la eliminación de detecciones duplicadas. |
max_det | int | 300 | Limita el número máximo de detecciones por imagen. Para detect, segment, pose y OBB, si se deja en 300, este valor se eleva al mayor recuento de objetos etiquetados en la división validada cuando una imagen lo supera, acompañado de una advertencia; cualquier otro valor se mantiene, con la advertencia de que la recuperación puede verse limitada cuando una imagen lo supera. |
quantize | int o str | None | Precisión de validación: 16/"fp16" y 32/"fp32"/sin definir seleccionan cálculo FP16 o FP32 para modelos de PyTorch y TorchScript; otros formatos calculan con la precisión que seleccionan su artefacto y su motor de ejecución. En 16, OpenVINO sigue redondeando la entrada a FP16 en el cliente y la vuelve a ampliar a FP32, sin cambiar aquello con lo que calcula el motor de ejecución. La cuantización INT8/PTQ se configura durante la exportación y luego se utiliza validando el modelo exportado. Reemplaza al indicador obsoleto half. |
device | str | None | Especifica el dispositivo para la validación (cpu, cuda:0, npu, npu:0, etc.). Cuando se establece en None, selecciona automáticamente el mejor dispositivo disponible. Se pueden especificar varios dispositivos CUDA separándolos mediante comas. |
dnn | bool | False | Si True, utiliza el módulo DNN de OpenCV para la inferencia de modelos ONNX, como alternativa a los métodos de inferencia de PyTorch. |
plots | bool | True | Cuando se establece en True, genera y guarda gráficos de las predicciones frente a la verdad fundamental, matrices de confusión y curvas PR para evaluar visualmente el rendimiento del modelo. |
classes | list[int] | None | Especifica una lista de identificadores de clase que se evaluarán. Es útil para filtrar y centrarse únicamente en determinadas clases durante la evaluación. |
rect | bool | True | Si True, utiliza inferencia rectangular para el procesamiento por lotes, reduciendo el relleno y aumentando potencialmente la velocidad y la eficiencia al procesar las imágenes con su relación de aspecto original. Se ignora en la validación de depth, que ajusta cada imagen a un cuadrado fijo de imgsz en lugar de añadir relleno. |
split | str | 'val' | Determina la partición del conjunto de datos que se usará para la validación (val, test o train). Permite elegir con flexibilidad el segmento de datos para evaluar el rendimiento. |
fraction | float, int o list | 1.0 | Subconjunto de la partición validada. Con una lista [train, val, test], se aplica la entrada que coincide con split (1 = partición completa, enteros superiores a 1 = recuentos de imágenes; las entradas omitidas son completas). Un escalar solo se aplica con split=train; val y test utilizan entonces la partición completa. |
project | str | None | Nombre del directorio del proyecto donde se guardan las salidas de validación. Ayuda a organizar los resultados de distintos experimentos o modelos. |
name | str | None | Nombre de la ejecución de validación. Se utiliza para crear un subdirectorio dentro de la carpeta del proyecto, donde se almacenan los registros y las salidas de validación. |
verbose | bool | True | Si True, muestra información detallada durante el proceso de validación, incluidas las métricas por clase, el progreso de los lotes y datos adicionales de depuración. |
save_txt | bool | False | Si True, guarda los resultados de detección en archivos de texto, uno por imagen, lo que resulta útil para análisis posteriores, posprocesamiento personalizado o integración con otros sistemas. |
save_conf | bool | False | Si True, incluye los valores de confianza en los archivos de texto guardados cuando save_txt está habilitado, proporcionando resultados más detallados para el análisis y el filtrado. |
workers | int | 8 | Número de subprocesos de trabajo para la carga de datos. Los valores más altos pueden acelerar el preprocesamiento de datos, pero pueden aumentar el uso de la CPU. Establecerlo en 0 utiliza el subproceso principal, lo que puede ser más estable en algunos entornos. |
augment | bool | False | Habilita 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 sobre versiones transformadas de la entrada. Solo está disponible para modelos de PyTorch de Ultralytics. |
agnostic_nms | bool | False | Habilita la supresión no máxima independiente de la clase, suprimiendo las cajas superpuestas con puntuaciones más bajas independientemente de su clase predicha. Es útil para aplicaciones centradas en instancias. Con la inferencia sin NMS (nms=False en YOLO26 o YOLOv10), esto solo evita que la misma detección aparezca con múltiples etiquetas de clase (duplicados con IoU=1.0) y no realiza la supresión basada en el umbral de IoU entre cajas distintas. |
single_cls | bool | False | Trata todas las clases como una sola clase durante la validación. Es útil para evaluar el rendimiento del modelo en tareas de detección binaria o cuando las distinciones entre clases no son importantes. |
visualize | bool | False | Visualiza la verdad fundamental, los verdaderos positivos, los falsos positivos y los falsos negativos de cada imagen. Es útil para depurar e interpretar el modelo. |
show_labels | bool | True | Muestra las etiquetas de clase en las visualizaciones de validación cuando visualize=True. Establécelo en False para obtener una vista más limpia de las coincidencias y los errores. |
show_conf | bool | True | Muestra las puntuaciones de confianza en las visualizaciones de validación cuando visualize=True. Establécelo en False para obtener una vista más limpia de las coincidencias y los errores. |
compile | bool o str | False | Habilita la compilación de grafos torch.compile de PyTorch 2.x con backend='inductor'. Acepta True → "default", False → deshabilita la función, 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_last | bool | None | Utiliza el formato de memoria channels_last (NHWC) para la validación nativa de PyTorch. None lo habilita automáticamente en CPU x86 con Linux y Windows que tengan oneDNN habilitado y PyTorch 1.13 o posterior; False lo deshabilita y True lo solicita en dispositivos CPU x86 o CUDA compatibles. ARM64, MPS, las versiones antiguas de PyTorch, las CPU sin oneDNN y los formatos exportados no cambian; la validación durante el entrenamiento mantiene la disposición del modelo de entrenamiento. |
nms | bool, opcional | None | Ejecuta la inferencia de uno a muchos con NMS por defecto (None o True). Configura False para utilizar la cabeza de uno a uno sin NMS cuando esté disponible. Consulta la guía de detección de extremo a extremo para obtener más detalles. |
Cada una de estas configuraciones desempeña un papel fundamental en el proceso de validación y permite una evaluación personalizable y eficiente de los modelos YOLO. Ajustar estos parámetros según tus necesidades y recursos específicos puede ayudarte a lograr el mejor equilibrio entre precisión y rendimiento.
Ejemplo de validación con argumentos#
Watch: How to Export Model Validation Results in CSV, JSON, SQL, Polars DataFrame & More
Los ejemplos siguientes muestran la validación de modelos YOLO con argumentos personalizados en Python y CLI.
from ultralytics import YOLO
# Load a model
model = YOLO("yolo26n.pt")
# Customize validation settings
metrics = model.val(data="coco8.yaml", imgsz=640, batch=16, conf=0.25, iou=0.7, device="0")También puedes guardar los resultados de la matriz de confusión en distintos formatos mediante el código proporcionado.
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
results = model.val(data="coco8.yaml", plots=True)
print(results.confusion_matrix.to_df())La validación almacena las métricas de precisión, exhaustividad, F1, TP, FP y FN por imagen (con un umbral de IoU de 0.5) para todas las tareas, excepto la clasificación. Puedes acceder 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 completada la validación.
from ultralytics import YOLO
# Load a model
model = YOLO("yolo26n.pt")
# Validate and access per-image metrics
results = model.val(data="coco8.yaml")
# image_metrics is a dictionary with image filenames as keys
print(results.box.image_metrics)
# Output: {'image1.jpg': {'precision': 0.85, 'recall': 0.92, 'f1': 0.88, 'tp': 17, 'fp': 3, 'fn': 1}, ...}
# Access metrics for a specific image
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 claves siguientes:
| Clave | Descripción |
|---|---|
precision | Puntuación de precisión de la imagen (tp / (tp + fp)). |
recall | Puntuación de exhaustividad de la imagen (tp / (tp + fn)). |
f1 | Media armónica de la precisión y la exhaustividad. |
tp | Número de verdaderos positivos de la imagen. |
fp | Número de falsos positivos de la imagen. |
fn | Nú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 expone asistentes de exportación para el análisis posterior:
| Método | Tipo de retorno | Descripción |
|---|---|---|
summary() | List[Dict[str, Any]] | Convierte los resultados de validación en un diccionario resumido. |
to_df() | DataFrame | Devuelve los resultados de validación como un DataFrame estructurado de Polars. |
to_csv() | str | Exporta los resultados de validación en formato CSV y devuelve la cadena CSV. |
to_json() | str | Exporta los resultados de validación en formato JSON y devuelve la cadena JSON. |
Para obtener más información, consulta la documentación de la clase DataExportMixin.
¿Y ahora qué?#
¿Estás satisfecho con las métricas? Exporta el modelo a un formato de despliegue. Si la precisión no es la esperada, vuelve a entrenarlo con otros hiperparámetros o con más datos de entrenamiento.
Preguntas frecuentes#
Para validar tu modelo YOLO26, puedes usar el modo Val proporcionado por Ultralytics. Por ejemplo, mediante la API de Python, puedes cargar un modelo y ejecutar la validación con:
from ultralytics import YOLO # Load a model model = YOLO("yolo26n.pt") # Validate the model metrics = model.val() print(metrics.box.map) # map50-95También puedes usar la interfaz de línea de comandos (CLI):
yolo val model=yolo26n.ptPara personalizar aún más el proceso, puedes ajustar varios argumentos, como
imgsz,batchyconf, tanto en el modo 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 promedio con un umbral de IoU de 0.5)
- mAP75 (precisión media promedio con un umbral de IoU de 0.75)
- mAP50-95 (precisión media promedio en múltiples umbrales de IoU de 0.5 a 0.95)
Mediante la API de Python, puedes acceder a estas métricas de la siguiente forma:
metrics = model.val() # assumes `model` has been loaded print(metrics.box.map) # mAP50-95 print(metrics.box.map50) # mAP50 print(metrics.box.map75) # mAP75 print(metrics.box.maps) # list of mAP50-95 for each category print(metrics.box.image_metrics) # per-image metrics dictionary with precision, recall, F1, TP, FP, and FNPara realizar una evaluación completa del rendimiento, es fundamental revisar todas estas métricas. Para obtener más información, consulta Funciones principales del modo Val.
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 su configuración de entrenamiento, lo que simplifica la validación.
- Flexibilidad: Puedes validar con los mismos conjuntos de datos o con otros diferentes, así como con distintos tamaños de imagen.
- Ajuste de hiperparámetros: Las métricas de validación ayudan a ajustar los modelos para mejorar el rendimiento.
Estas ventajas garantizan que tus modelos se evalúen exhaustivamente y puedan optimizarse para obtener mejores resultados. Descubre más información sobre estas ventajas en la sección Por qué validar con Ultralytics YOLO.
Sí, puedes validar tu modelo YOLO26 con un conjunto de datos personalizado. Especifica el argumento
datacon la ruta a tu archivo YAML del conjunto de datos, que debe incluir la ruta a los datos de validación. En la clasificación, en su lugar, se indica un directorio de conjunto de datos o el nombre de un conjunto de datos integrado (por ejemplo,imagenet10).NotaLa validación se realiza utilizando los nombres de clase propios del modelo, que puedes ver mediante
model.namesy que pueden ser diferentes de los definidos por el propio conjunto de datos.Ejemplo en Python:
from ultralytics import YOLO # Load a model model = YOLO("yolo26n.pt") # Validate with a custom dataset metrics = model.val(data="path/to/your/custom_dataset.yaml") print(metrics.box.map) # map50-95Ejemplo mediante CLI:
yolo val model=yolo26n.pt data=path/to/your/custom_dataset.yamlPara consultar más opciones personalizables 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_jsonenTrueal ejecutar la validación. Esto puede hacerse tanto en la API de Python como en CLI.Ejemplo en Python:
from ultralytics import YOLO # Load a model model = YOLO("yolo26n.pt") # Save validation results to JSON metrics = model.val(save_json=True)Ejemplo mediante CLI:
yolo val model=yolo26n.pt save_json=TrueEn conjuntos de datos de detección,
save_json=Truetambién informa el mAP de objetos pequeños, medianos y grandes a través defaster-coco-eval. Consulta los Arguments for YOLO Model Validation para obtener más detalles.