Cómo utilizar Ultralytics YOLOv5 con Comet

En Ultralytics colaboramos comercialmente con otras startups para ayudarnos a financiar la investigación y el desarrollo de nuestras increíbles herramientas de código abierto, como YOLOv5, y mantenerlas gratuitas para todo el mundo. Este artículo puede contener enlaces de afiliación a dichos socios.

Nuestro socio más reciente, Comet, desarrolla herramientas que ayudan a científicos de datos, ingenieros y responsables de equipos a acelerar y optimizar modelos de machine learning y deep learning.

Comet es una herramienta potente para realizar el seguimiento de tus modelos, conjuntos de datos y métricas. También registra las variables del sistema y del entorno para garantizar la reproducibilidad y facilitar la depuración de cada ejecución. Es como tener un asistente virtual que sabe mágicamente qué notas guardar. Realiza el seguimiento y visualiza las métricas de los modelos en tiempo real, guarda tus hiperparámetros, conjuntos de datos y puntos de control de los modelos, y visualiza las predicciones de tus modelos con Paneles personalizados de Comet.

Además, Comet garantiza que nunca pierdas de vista tu trabajo y facilita compartir resultados y colaborar entre equipos de cualquier tamaño.

YOLOv5 es un excelente punto de partida para tu trayectoria en visión artificial. Para mejorar el rendimiento de tu modelo y prepararlo para producción, tendrás que registrar los resultados en una herramienta de seguimiento de experimentos como Comet.

La integración de Comet y YOLOv5 ofrece 3 funciones principales:

• Funciones de registro automático y personalizado
• Guardar conjuntos de datos y modelos como artefactos para la depuración y la reproducibilidad
• Organizar tu vista con los paneles personalizados de Comet

En esta guía se explica cómo usar YOLOv5 con Comet.

¿Listo para realizar el seguimiento de tus experimentos en tiempo real? ¡Empecemos!

Primeros pasos#

1. Instala Comet#

pip install comet_ml

2. Configura las credenciales de Comet#

Hay dos formas de configurar Comet con YOLOv5.

Puedes establecer tus credenciales mediante variables de entorno o crear un archivo .comet.config en tu directorio de trabajo y establecerlas allí.

Variables de entorno#

export COMET_API_KEY=<Your API Key>
export COMET_PROJECT_NAME=<Your Comet Project Name> # This will default to 'yolov5'

Archivo de configuración de Comet#

[comet]
api_key=<Your API Key>
project_name=<Your Comet Project Name> # This will default to 'yolov5'

3. Ejecuta el script de entrenamiento#

# Train YOLOv5s on COCO128 for 5 epochs
python train.py --img 640 --batch 16 --epochs 5 --data coco128.yaml --weights yolov5s.pt

¡Eso es todo!

Comet registrará automáticamente tus hiperparámetros, argumentos de la línea de comandos y métricas de entrenamiento y validación. Puedes visualizar y analizar tus ejecuciones en la interfaz de Comet.

¡Pruébalo tú mismo!#

Consulta aquí un ejemplo de una ejecución completada.

O, mejor aún, pruébalo tú mismo en este cuaderno de Colab.

Registra automáticamente#

De forma predeterminada, Comet registrará los siguientes elementos:

Métricas#

• Pérdida de cajas, pérdida de objetos y pérdida de clasificación para los datos de entrenamiento y validación
• Métricas mAP_0.5 y mAP_0.5:0.95 para los datos de validación
• Precisión y exhaustividad para los datos de validación

Parámetros#

• Hiperparámetros del modelo
• Todos los parámetros pasados mediante las opciones de la línea de comandos

Visualizaciones#

• Matriz de confusión de las predicciones del modelo sobre los datos de validación
• Gráficas de las curvas PR y F1 para todas las clases
• Correlograma de las etiquetas de clase

Configura el registro de Comet#

Puedes configurar Comet para que registre datos adicionales mediante indicadores de la línea de comandos pasados al script de entrenamiento o mediante variables de entorno.

export COMET_MODE=online # Set whether to run Comet in 'online' or 'offline' mode. Defaults to online
export COMET_MODEL_NAME=<your model name> # Set the name for the saved model. Defaults to yolov5
export COMET_LOG_CONFUSION_MATRIX=false # Set to disable logging a Comet Confusion Matrix. Defaults to true
export COMET_MAX_IMAGE_UPLOADS=<number of allowed images to upload to Comet> # Controls how many total image predictions to log to Comet. Defaults to 100.
export COMET_LOG_PER_CLASS_METRICS=true # Set to log evaluation metrics for each detected class at the end of training. Defaults to false
export COMET_DEFAULT_CHECKPOINT_FILENAME=<your checkpoint filename> # Set this if you would like to resume training from a different checkpoint. Defaults to 'last.pt'
export COMET_LOG_BATCH_LEVEL_METRICS=true # Set this if you would like to log training metrics at the batch level. Defaults to false.
export COMET_LOG_PREDICTIONS=true # Set this to false to disable logging model predictions

Registro de puntos de control con Comet#

El registro de modelos en Comet está desactivado de forma predeterminada. Para activarlo, pasa el argumento save-period al script de entrenamiento. Esto guardará los puntos de control registrados en Comet según el valor del intervalo proporcionado por save-period.

python train.py \
  --img 640 \
  --batch 16 \
  --epochs 5 \
  --data coco128.yaml \
  --weights yolov5s.pt \
  --save-period 1

Registro de predicciones del modelo#

De forma predeterminada, las predicciones del modelo (imágenes, etiquetas de referencia y cajas delimitadoras) se registrarán en Comet. Puedes controlar la frecuencia de las predicciones registradas y de las imágenes asociadas pasando el argumento de la línea de comandos bbox_interval. Las predicciones se pueden visualizar mediante el panel personalizado de detección de objetos de Comet. Esta frecuencia corresponde a cada lote número N de datos por época. En el ejemplo siguiente, registramos cada segundo lote de datos de cada época.

Nota: el cargador de datos de validación de YOLOv5 usará de forma predeterminada un tamaño de lote de 32, por lo que tendrás que establecer la frecuencia de registro en consecuencia.

Aquí tienes un proyecto de ejemplo que utiliza el panel.

python train.py \
  --img 640 \
  --batch 16 \
  --epochs 5 \
  --data coco128.yaml \
  --weights yolov5s.pt \
  --bbox_interval 2

Controla el número de imágenes de predicciones registradas en Comet#

Al registrar predicciones de YOLOv5, Comet registrará las imágenes asociadas a cada conjunto de predicciones. De forma predeterminada, se registra un máximo de 100 imágenes de validación. Puedes aumentar o reducir este número mediante la variable de entorno COMET_MAX_IMAGE_UPLOADS.

env COMET_MAX_IMAGE_UPLOADS=200 python train.py \
  --img 640 \
  --batch 16 \
  --epochs 5 \
  --data coco128.yaml \
  --weights yolov5s.pt \
  --bbox_interval 1

Registro de métricas por clase#

Usa la variable de entorno COMET_LOG_PER_CLASS_METRICS para registrar mAP, precisión, exhaustividad y f1 de cada clase.

env COMET_LOG_PER_CLASS_METRICS=true python train.py \
  --img 640 \
  --batch 16 \
  --epochs 5 \
  --data coco128.yaml \
  --weights yolov5s.pt

Sube un conjunto de datos a los artefactos de Comet#

Si quieres almacenar tus datos mediante Artefactos de Comet, puedes hacerlo usando el indicador upload_dataset.

El conjunto de datos se organiza tal como se describe en la documentación de YOLOv5. El archivo yaml de configuración del conjunto de datos debe seguir el mismo formato que el archivo coco128.yaml.

python train.py \
  --img 640 \
  --batch 16 \
  --epochs 5 \
  --data coco128.yaml \
  --weights yolov5s.pt \
  --upload_dataset

Puedes encontrar el conjunto de datos subido en la pestaña Artifacts de tu espacio de trabajo de Comet.

Puedes previsualizar los datos directamente en la interfaz de Comet.

Los artefactos tienen control de versiones y también permiten añadir metadatos sobre el conjunto de datos. Comet registrará automáticamente los metadatos del archivo yaml de tu conjunto de datos.

Usa un artefacto guardado#

Si quieres usar un conjunto de datos de los artefactos de Comet, establece la variable path en el archivo yaml de tu conjunto de datos para que apunte a la siguiente URL de recurso de Artifact.

# contents of artifact.yaml file
path: "comet://<workspace name>/<artifact name>:<artifact version or alias>"

Después, pasa este archivo a tu script de entrenamiento de la siguiente forma:

python train.py \
  --img 640 \
  --batch 16 \
  --epochs 5 \
  --data artifact.yaml \
  --weights yolov5s.pt

Los artefactos también te permiten realizar el seguimiento del linaje de los datos a medida que fluyen por tu flujo de trabajo de experimentación. Aquí puedes ver un grafo que muestra todos los experimentos que han utilizado tu conjunto de datos subido.

Reanuda una ejecución de entrenamiento#

Si tu ejecución de entrenamiento se interrumpe por cualquier motivo, por ejemplo, debido a una conexión a Internet inestable, puedes reanudarla usando el indicador resume y la ruta de ejecución de Comet.

La ruta de ejecución tiene el siguiente formato: comet://<your workspace name>/<your project name>/<experiment id>.

Esto restaurará la ejecución al estado que tenía antes de la interrupción, lo que incluye restaurar el modelo desde un punto de control, restaurar todos los hiperparámetros y argumentos de entrenamiento y descargar los artefactos de conjuntos de datos de Comet si se usaron en la ejecución original. La ejecución reanudada continuará registrando datos en el experimento existente de la interfaz de Comet.

python train.py \
  --resume "comet://<your run path>"

Búsqueda de hiperparámetros con el optimizador de Comet#

YOLOv5 también está integrado con el optimizador de Comet, lo que facilita visualizar barridos de hiperparámetros en la interfaz de Comet.

Configura un barrido del optimizador#

Para configurar el optimizador de Comet, tendrás que crear un archivo JSON con la información del barrido.

Se proporciona un archivo de ejemplo en utils/loggers/comet/optimizer_config.json.

python utils/loggers/comet/hpo.py \
  --comet_optimizer_config "utils/loggers/comet/optimizer_config.json"

El script hpo.py acepta los mismos argumentos que train.py. Si quieres pasar argumentos adicionales a tu barrido, solo tienes que añadirlos después del script.

python utils/loggers/comet/hpo.py \
  --comet_optimizer_config "utils/loggers/comet/optimizer_config.json" \
  --save-period 1 \
  --bbox_interval 1

Ejecuta un barrido en paralelo#

comet optimizer -j <num_workers> utils/loggers/comet/hpo.py \
  utils/loggers/comet/optimizer_config.json

Comet ofrece muchas formas de visualizar los resultados de tu barrido. Echa un vistazo a un proyecto con un barrido completado aquí:

Mantente en contacto#

Empieza a usar nuestra integración con Comet para gestionar, visualizar y optimizar tus modelos YOLOv5, desde las ejecuciones de entrenamiento hasta la supervisión en producción.

Y, por supuesto, únete a la Comunidad de Ultralytics, un lugar donde hacer preguntas y compartir consejos sobre el entrenamiento, la validación y el despliegue de YOLOv5.