Entrena YOLOv5 con tus propios datos

📚 Esta guía explica cómo entrenar tu propio conjunto de datos personalizado utilizando el modelo YOLOv5 🚀. Entrenar modelos personalizados es un paso fundamental para adaptar las soluciones de computer vision a aplicaciones específicas del mundo real más allá de la object detection genérica.

Antes de empezar

Primero, asegúrate de tener el entorno necesario configurado. Clona el repositorio de YOLOv5 e instala las dependencias requeridas desde requirements.txt. Un entorno Python>=3.8.0 con PyTorch>=1.8 es esencial. Los modelos y conjuntos de datos se descargan automáticamente desde la versión más reciente release de YOLOv5 si no se encuentran localmente.

git clone https://github.com/ultralytics/yolov5 # Clone the repository
cd yolov5
pip install -r requirements.txt # Install dependencies

Entrenar con datos personalizados

El desarrollo de un modelo de object detection personalizado es un proceso iterativo:

1. Recopila y organiza imágenes: reúne imágenes relevantes para tu tarea específica. Los datos diversos y de alta calidad son cruciales. Consulta nuestra guía sobre Data Collection and Annotation.
2. Etiqueta objetos: anota los objetos de interés dentro de tus imágenes con precisión.
3. Entrena un modelo: utiliza los datos etiquetados para train tu modelo YOLOv5. Aprovecha el transfer learning empezando con pesos preentrenados.
4. Despliega y predice: utiliza el modelo entrenado para inference en datos nuevos y desconocidos.
5. Recopila casos extremos: identifica escenarios donde el modelo tiene un rendimiento deficiente (edge cases) y añade datos similares a tu conjunto de datos para mejorar la solidez. Repite el ciclo.

Ultralytics Platform ofrece una solución optimizada y sin código para todo este ciclo de machine learning operations (MLOps), incluyendo la gestión de conjuntos de datos, el entrenamiento de modelos y el despliegue.

Antes de iniciar el entrenamiento, la preparación del conjunto de datos es esencial.

Crea un conjunto de datos

Los modelos YOLOv5 requieren datos etiquetados para aprender las características visuales de las clases de objetos. Organizar correctamente tu conjunto de datos es clave.

1.1 Crea dataset.yaml

El archivo de configuración del conjunto de datos (por ejemplo, coco128.yaml) describe la estructura del conjunto de datos, los nombres de las clases y las rutas a los directorios de imágenes. COCO128 sirve como un pequeño conjunto de datos de ejemplo, que comprende las primeras 128 imágenes del extenso conjunto de datos COCO. Es útil para probar rápidamente la canalización de entrenamiento y diagnosticar posibles problemas como el overfitting.

La estructura del archivo dataset.yaml incluye:

• path: el directorio raíz que contiene el conjunto de datos.
• train, val, test: rutas relativas desde path a los directorios que contienen imágenes o archivos de texto que enumeran las rutas de las imágenes para los conjuntos de entrenamiento, validación y prueba.
• names: un diccionario que asigna los índices de las clases (empezando desde 0) a sus nombres de clase correspondientes.

Puedes establecer path a un directorio absoluto (por ejemplo, /home/user/datasets/coco128) o a una ruta relativa como ../datasets/coco128 al iniciar el entrenamiento desde la raíz del repositorio de YOLOv5.

A continuación se muestra la estructura de coco128.yaml (ver en GitHub):

# Dataset root directory relative to the yolov5 directory
path: coco128

# Train/val/test sets: specify directories, *.txt files, or lists
train: images/train2017 # 128 images for training
val: images/train2017 # 128 images for validation
test: # Optional path to test images

# Classes (example using 80 COCO classes)
names:
    0: person
    1: bicycle
    2: car
    # ... (remaining COCO classes)
    77: teddy bear
    78: hair drier
    79: toothbrush

1.2 Aprovecha los modelos para el etiquetado automatizado

El etiquetado manual es el enfoque común pero requiere mucho tiempo. Los modelos base pueden automatizar o semiautomatizar la anotación y acelerar la creación del conjunto de datos. Ejemplos de modelos que pueden ayudar a generar etiquetas:

• Google Gemini: Los grandes modelos multimodales como Gemini poseen potentes capacidades de comprensión de imágenes. Se les puede indicar que identifiquen y localicen objetos dentro de las imágenes, generando cuadros delimitadores o descripciones que se pueden convertir en etiquetas de formato YOLO. Explora su potencial en el cuaderno de tutorial proporcionado.
• SAM2 (Segment Anything Model 2): Los modelos base centrados en la segmentación, como SAM2, pueden identificar y delinear objetos con alta precisión. Aunque son principalmente para segmentación, las máscaras resultantes a menudo se pueden convertir en anotaciones de cuadros delimitadores adecuadas para tareas de detección de objetos.
• YOLOWorld: Este modelo ofrece capacidades de detección de vocabulario abierto. Puedes proporcionar descripciones de texto de los objetos que te interesan y YOLOWorld puede localizarlos en imágenes sin entrenamiento previo en esas clases específicas. Esto se puede utilizar como punto de partida para generar etiquetas iniciales, que luego se pueden refinar.

Usar estos modelos puede proporcionar un paso de "pre-etiquetado", reduciendo el esfuerzo manual necesario. Sin embargo, es crucial revisar y refinar las etiquetas generadas automáticamente para garantizar la precisión y la coherencia, ya que la calidad afecta directamente al rendimiento de tu modelo YOLOv5 entrenado. Después de generar (y posiblemente refinar) tus etiquetas, asegúrate de que se adhieran al YOLO format: un archivo *.txt por imagen, con cada línea representando un objeto como class_index x_center y_center width height (coordenadas normalizadas, clase indexada en cero). Si una imagen no tiene objetos de interés, no es necesario ningún archivo *.txt correspondiente.

Las especificaciones del archivo *.txt en formato YOLO son precisas:

• Una fila por objeto bounding box.
• Cada fila debe contener: class_index x_center y_center width height.
• Las coordenadas deben estar normalizadas en un rango entre 0 y 1. Para lograr esto, divide los valores de píxel de x_center y width por el ancho total de la imagen, y divide y_center y height por la altura total de la imagen.
• Los índices de las clases están indexados en cero (es decir, la primera clase está representada por 0, la segunda por 1, y así sucesivamente).

El archivo de etiquetas correspondiente a la imagen anterior, que contiene dos objetos 'persona' (índice de clase 0) y un objeto 'corbata' (índice de clase 27), se vería así:

1.3 Organiza los directorios

Estructura tu directorio de datasets como se ilustra a continuación. De forma predeterminada, YOLOv5 espera que el directorio del conjunto de datos (por ejemplo, /coco128) resida dentro de una carpeta /datasets ubicada adyacente a el directorio del repositorio /yolov5.

YOLOv5 localiza automáticamente las etiquetas para cada imagen reemplazando la última instancia de /images/ en la ruta de la imagen con /labels/. Por ejemplo:

../datasets/coco128/images/im0.jpg # Path to the image file
../datasets/coco128/labels/im0.txt # Path to the corresponding label file

La estructura de directorio recomendada es:

/datasets/
└── coco128/  # Dataset root
    ├── images/
    │   ├── train2017/  # Training images
    │   │   ├── 000000000009.jpg
    │   │   └── ...
    │   └── val2017/    # Validation images (optional if using same set for train/val)
    │       └── ...
    └── labels/
        ├── train2017/  # Training labels
        │   ├── 000000000009.txt
        │   └── ...
        └── val2017/    # Validation labels (optional if using same set for train/val)
            └── ...

Selecciona un modelo

Elige un pretrained model para iniciar el proceso de entrenamiento. Comenzar con pesos preentrenados acelera significativamente el aprendizaje y mejora el rendimiento en comparación con el entrenamiento desde cero. YOLOv5 ofrece varios tamaños de modelo, cada uno equilibrando la velocidad y la precisión de manera diferente. Por ejemplo, YOLOv5s es el segundo modelo más pequeño y rápido, adecuado para entornos con recursos limitados. Consulta la README table para obtener una comparación detallada de todos los models disponibles.

Entrena

Comienza el model training utilizando el script train.py. Los argumentos esenciales incluyen:

• --img: Define el image size de entrada (por ejemplo, --img 640). Los tamaños más grandes generalmente producen una mejor precisión pero requieren más memoria de GPU.
• --batch: Determina el batch size (por ejemplo, --batch 16). Elige el tamaño más grande que tu GPU pueda manejar.
• --epochs: Especifica el número total de epochs de entrenamiento (por ejemplo, --epochs 100). Una época representa un pase completo sobre todo el conjunto de datos de entrenamiento.
• --data: Ruta a tu archivo dataset.yaml (por ejemplo, --data coco128.yaml).
• --weights: Ruta al archivo de pesos iniciales. Se recomienda encarecidamente utilizar pesos preentrenados (por ejemplo, --weights yolov5s.pt) para una convergencia más rápida y resultados superiores. Para entrenar desde cero (no recomendado a menos que tengas un conjunto de datos muy grande y necesidades específicas), usa --weights '' --cfg yolov5s.yaml.

Los pesos preentrenados se descargan automáticamente desde el latest YOLOv5 release si no se encuentran localmente.

# Example: Train YOLOv5s on the COCO128 dataset for 3 epochs
python train.py --img 640 --batch 16 --epochs 3 --data coco128.yaml --weights yolov5s.pt

Todos los resultados del entrenamiento, incluidos los pesos y los registros, se guardan en el directorio runs/train/. Cada sesión de entrenamiento crea un nuevo subdirectorio (por ejemplo, runs/train/exp, runs/train/exp-2, etc.). Para una experiencia interactiva y práctica, explora la sección de entrenamiento en nuestros cuadernos de tutoriales oficiales:

Visualiza

YOLOv5 se integra perfectamente con varias herramientas para visualizar el progreso del entrenamiento, evaluar resultados y monitorear el rendimiento en tiempo real.

Registro y visualización con Comet

Comet está totalmente integrado para el seguimiento integral de experimentos. Visualiza métricas en vivo, guarda hiperparámetros, gestiona conjuntos de datos y puntos de control de modelos, y analiza las predicciones del modelo utilizando Comet Custom Panels interactivos.

Empezar es sencillo:

pip install comet_ml                                                          # 1. Install Comet library
export COMET_API_KEY=YOUR_API_KEY_HERE                                        # 2. Set your Comet API key (create a free account at Comet.ml)
python train.py --img 640 --epochs 3 --data coco128.yaml --weights yolov5s.pt # 3. Train your model - Comet automatically logs everything!

Profundiza en las características compatibles en nuestra Comet Integration Guide. Aprende más sobre las capacidades de Comet en su documentation oficial. Prueba el cuaderno de Colab de Comet para una demostración en vivo:

Registro y automatización con ClearML

La integración con ClearML permite un seguimiento detallado de los experimentos, la gestión de versiones de conjuntos de datos e incluso la ejecución remota de ejecuciones de entrenamiento. Activa ClearML con estos sencillos pasos:

• Instala el paquete: pip install clearml
• Inicializa ClearML: Ejecuta clearml-init una vez para conectarte a tu servidor ClearML (ya sea autohospedado o el free tier).

ClearML captura automáticamente los detalles del experimento, las cargas de modelos, las comparaciones, los cambios de código no confirmados y los paquetes instalados, lo que garantiza una reproducibilidad total. Puedes programar fácilmente tareas de entrenamiento en agentes remotos y gestionar versiones de conjuntos de datos utilizando ClearML Data. Explora la ClearML Integration Guide para obtener detalles completos.

Registro local

Los resultados del entrenamiento se registran automáticamente usando TensorBoard y se guardan como archivos CSV dentro del directorio de experimentos específico (por ejemplo, runs/train/exp). Los datos registrados incluyen:

• Métricas de pérdida y rendimiento de entrenamiento y validación.
• Imágenes de muestra que muestran aumentos aplicados (como mosaicos).
• Etiquetas de verdad fundamental junto con las predicciones del modelo para inspección visual.
• Métricas de evaluación clave como curvas de Precision-Recall (PR).
• Confusion matrices para un análisis detallado del rendimiento por clase.

El archivo results.csv se actualiza después de cada época y se representa como results.png una vez que concluye el entrenamiento. También puedes trazar cualquier archivo results.csv manualmente utilizando la función de utilidad proporcionada:

from utils.plots import plot_results

# Plot results from a specific training run directory
plot_results("runs/train/exp/results.csv")  # This will generate 'results.png' in the same directory

Próximos pasos

Una vez completado con éxito el entrenamiento, el punto de control del modelo con mejor rendimiento (best.pt) se guarda y está listo para su despliegue o posterior refinamiento. Los posibles pasos siguientes incluyen:

• Ejecutar inference en nuevas imágenes o vídeos utilizando el modelo entrenado a través de la CLI o Python.
• Realizar validation para evaluar la accuracy y las capacidades de generalización del modelo en diferentes divisiones de datos (por ejemplo, un conjunto de prueba reservado).
• Export el modelo a varios formatos de despliegue como ONNX, TensorFlow SavedModel o TensorRT para una inferencia optimizada en diversas plataformas.
• Emplear técnicas de hyperparameter tuning para obtener potencialmente ganancias de rendimiento adicionales.
• Continúa mejorando tu modelo siguiendo nuestros Tips for Best Training Results y añadiendo iterativamente datos más diversos y desafiantes basados en el análisis de rendimiento.

Entornos compatibles

Ultralytics ofrece entornos listos para usar equipados con dependencias esenciales como CUDA, cuDNN, Python y PyTorch, lo que facilita un comienzo sin problemas.

• Cuadernos de GPU gratuitos:
  • 
  • 
  • 
• Plataformas en la nube:
  • Google Cloud: GCP Quickstart Guide
  • Amazon AWS: AWS Quickstart Guide
  • Microsoft Azure: AzureML Quickstart Guide
• Configuración local:
  • Docker: Docker Quickstart Guide

Estado del proyecto

This badge indicates that all YOLOv5 GitHub Actions Continuous Integration (CI) tests are passing successfully. These rigorous CI tests cover the core functionalities, including training, validation, inference, export, and benchmarks, across macOS, Windows, and Ubuntu operating systems. Tests are executed automatically every 24 hours and upon each code commit, ensuring consistent stability and optimal performance.

Preguntas frecuentes

¿Cómo entreno YOLOv5 en mi conjunto de datos personalizado?

Entrenar YOLOv5 en un conjunto de datos personalizado implica varios pasos clave:

1. Prepara tu conjunto de datos: recopila imágenes y anonímalas. Asegúrate de que las anotaciones estén en el YOLO format requerido. Organiza las imágenes y las etiquetas en directorios train/ y val/ (y opcionalmente test/). Considera usar modelos como Google Gemini, SAM2 o YOLOWorld para ayudar o automatizar el proceso de etiquetado (consulta la sección 1.2).
2. Configura tu entorno: clona el repositorio de YOLOv5 e instala las dependencias usando pip install -r requirements.txt.

   git clone https://github.com/ultralytics/yolov5
   cd yolov5
   pip install -r requirements.txt

3. Crea la configuración del conjunto de datos: define las rutas del conjunto de datos, el número de clases y los nombres de las clases en un archivo dataset.yaml.
4. Inicia el entrenamiento: ejecuta el script train.py, proporcionando las rutas a tu dataset.yaml, los pesos preentrenados deseados (p. ej., yolov5s.pt), el tamaño de imagen, el tamaño del lote y el número de épocas.

   python train.py --img 640 --batch 16 --epochs 100 --data path/to/your/dataset.yaml --weights yolov5s.pt

¿Por qué debería usar Ultralytics Platform para entrenar mis modelos YOLO?

Ultralytics Platform es una plataforma integral diseñada para optimizar todo el ciclo de vida de desarrollo de modelos YOLO, a menudo sin necesidad de escribir código. Los beneficios clave incluyen:

• Entrenamiento simplificado: entrena modelos fácilmente usando entornos preconfigurados y una interfaz de usuario intuitiva.
• Gestión de datos integrada: sube, controla las versiones y gestiona tus conjuntos de datos de forma eficiente dentro de la plataforma.
• Monitoreo en tiempo real: realiza un seguimiento del progreso del entrenamiento y visualiza métricas de rendimiento usando herramientas integradas como Comet o TensorBoard.
• Funciones de colaboración: facilita el trabajo en equipo mediante recursos compartidos, herramientas de gestión de proyectos y el intercambio sencillo de modelos.
• Despliegue sin código: despliega modelos entrenados directamente a diversos objetivos.

Para un tutorial práctico, echa un vistazo a nuestra entrada del blog: How to Train Your Custom Models with Ultralytics Platform.

¿Cómo convierto mis datos anotados al formato YOLOv5?

Tanto si anotas manualmente como si utilizas herramientas automatizadas (como las mencionadas en la sección 1.2), las etiquetas finales deben estar en el YOLO format específico requerido por YOLOv5:

• Crea un archivo .txt para cada imagen. El nombre del archivo debe coincidir con el de la imagen (p. ej., image1.jpg corresponde a image1.txt). Coloca estos archivos en un directorio labels/ paralelo a tu directorio images/ (p. ej., ../datasets/mydataset/labels/train/).
• Cada línea dentro de un archivo .txt representa una anotación de objeto y sigue el formato: class_index center_x center_y width height.
• Las coordenadas (center_x, center_y, width, height) deben estar normalizadas (valores entre 0.0 y 1.0) en relación con las dimensiones de la imagen.
• Los índices de clase se basan en cero (la primera clase es 0, la segunda es 1, etc.).

Muchas herramientas de anotación manual ofrecen exportación directa al formato YOLO. Si utilizas modelos automatizados, necesitarás scripts o procesos para convertir su salida (p. ej., coordenadas de BBox, máscaras de segmentación) a este formato de texto normalizado específico. Asegúrate de que la estructura de tu conjunto de datos final se ajuste al ejemplo proporcionado en la guía. Para más detalles, consulta nuestra Data Collection and Annotation Guide.

¿Cuáles son las opciones de licencia para usar YOLOv5 en aplicaciones comerciales?

Ultralytics ofrece licencias flexibles adaptadas a diferentes necesidades:

• AGPL-3.0 License: esta licencia de código abierto es adecuada para la investigación académica, proyectos personales y situaciones en las que el cumplimiento del código abierto sea aceptable. Exige que las modificaciones y los trabajos derivados también sean de código abierto bajo AGPL-3.0. Revisa los AGPL-3.0 License details.
• Enterprise License: una licencia comercial diseñada para empresas que integran YOLOv5 en productos o servicios propietarios. Esta licencia elimina las obligaciones de código abierto de AGPL-3.0, permitiendo la distribución de código cerrado. Visita nuestra Licensing page para más detalles o para solicitar una Enterprise License.

Selecciona la licencia que mejor se alinee con los requisitos y el modelo de distribución de tu proyecto.