YOLOv5 con Comet#

Esta guía explica cómo usar YOLOv5 con Comet, una potente herramienta para hacer seguimiento, comparar y optimizar experimentos de aprendizaje automático.

Acerca de Comet#

Comet desarrolla herramientas que ayudan a científicos de datos, ingenieros y responsables de equipo a acelerar y optimizar modelos de aprendizaje automático y aprendizaje profundo.

Haz seguimiento de las métricas del modelo y visualízalas en tiempo real, guarda los hiperparámetros, los conjuntos de datos y los puntos de control del modelo, y visualiza las predicciones con los paneles personalizados de Comet. Comet se asegura de que no pierdas de vista tu trabajo y facilita compartir resultados y colaborar con equipos de cualquier tamaño.

Primeros pasos#

Instala Comet#

pip install comet_ml

Configura las credenciales de Comet#

Hay dos formas de configurar Comet con YOLOv5.

Puedes configurar tus credenciales mediante variables de entorno:

Variables de entorno

export COMET_API_KEY=YOUR_API_KEY
export COMET_PROJECT_NAME=YOUR_COMET_PROJECT_NAME # This will default to 'yolov5'

También puedes crear un archivo .comet.config en el directorio de trabajo y configurar allí tus credenciales:

Archivo de configuración de Comet

[comet]
api_key=YOUR_API_KEY
project_name=YOUR_COMET_PROJECT_NAME # This will default to 'yolov5'

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

¡Y 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.

¡Prueba un ejemplo!#

Echa un vistazo a una ejecución completada.

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

Registro automático#

De forma predeterminada, Comet registra los siguientes elementos:

Métricas#

• Pérdida de cajas, pérdida de objetos y pérdida de clasificación para los datos de validación y entrenamiento
• 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áficos 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 opciones de la línea de comandos pasadas 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="yolov5"                   # 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=30                  # 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="last.pt" # Set this if you would like to resume training from a different checkpoint. Defaults to 'last.pt'
export COMET_LOG_BATCH_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

Registra 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. Así, los puntos de control registrados se guardarán en Comet según el intervalo indicado por save-period:

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

Registra las predicciones del modelo#

De forma predeterminada, las predicciones del modelo (imágenes, etiquetas de referencia y cuadros delimitadores) se registran en Comet.

Puedes controlar la frecuencia con la que se registran las predicciones y las imágenes asociadas pasando el argumento de línea de comandos bbox_interval. Las predicciones se pueden visualizar con el panel personalizado de detección de objetos de Comet. Esta frecuencia corresponde a cada N.º lote 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 utiliza el doble del tamaño de lote del entrenamiento (32 para --batch 16), así que tendrás que ajustar la frecuencia de registro en consecuencia.

Aquí tienes un proyecto de ejemplo que usa 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 predicción que se registran en Comet#

Al registrar predicciones de YOLOv5, Comet registra 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

Registra métricas por clase#

Usa la variable de entorno COMET_LOG_PER_CLASS_METRICS para registrar mAP, precisión, exhaustividad y F1 para 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 Comet Artifacts#

Si quieres almacenar tus datos mediante Comet Artifacts, puedes hacerlo con la opción upload_dataset.

El conjunto de datos debe organizarse tal como se describe en la documentación de YOLOv5. El archivo de configuración del conjunto de datos yaml debe tener 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 registra automáticamente los metadatos del archivo yaml de tu conjunto de datos:

Usa un artefacto guardado#

Si quieres usar un conjunto de datos de Comet Artifacts, configura la variable path del archivo yaml de tu conjunto de datos para que apunte a la siguiente URL del recurso Artifact:

# Contents of artifact.yaml file
path: "comet://WORKSPACE_NAME/ARTIFACT_NAME:ARTIFACT_VERSION_OR_ALIAS"

A continuación, pasa este archivo al script de entrenamiento de la siguiente manera:

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

Artifacts también te permite seguir la procedencia de los datos a medida que avanzan por el flujo de trabajo de experimentación. Aquí puedes ver un gráfico con todos los experimentos que han utilizado el conjunto de datos que has subido:

Reanudar una ejecución de entrenamiento#

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

La ruta de ejecución tiene el siguiente formato: comet://WORKSPACE_NAME/PROJECT_NAME/EXPERIMENT_ID.

Esto restaurará la ejecución al estado anterior a la interrupción, lo que incluye restaurar el modelo desde un punto de control, recuperar todos los hiperparámetros y argumentos de entrenamiento y descargar los artefactos del conjunto de datos de Comet si se utilizaron en la ejecución original. La ejecución reanudada seguirá registrando datos en el experimento existente en la interfaz de Comet:

python train.py \
  --resume "comet://YOUR_RUN_PATH"

Búsqueda de hiperparámetros con Comet Optimizer#

YOLOv5 también está integrado con el optimizador de Comet, lo que facilita la visualización de las exploraciones de hiperparámetros en la interfaz de Comet.

Configurar una exploración del optimizador#

Para configurar Comet Optimizer, tendrás que crear un archivo JSON con la información de la exploración. 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 la exploración, 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

Visualizar los resultados#

Comet ofrece varias formas de visualizar los resultados de la exploración. Echa un vistazo a un proyecto con una exploración completada.

Preguntas frecuentes#