Link to this sectionEntrena YOLOv5 con datos personalizados#

📚 Esta guía explica cómo entrenar tu propio dataset personalizado usando el modelo YOLOv5 🚀. Entrenar modelos personalizados es un paso fundamental para adaptar las soluciones de visión artificial a aplicaciones específicas del mundo real más allá de la detección de objetos genérica.

Link to this sectionAntes de empezar#

Primero, asegúrate de tener configurado el entorno necesario. Clona el repositorio de YOLOv5 e instala las dependencias necesarias desde requirements.txt. Es fundamental un entorno con Python>=3.8.0 y PyTorch>=1.8. Los modelos y conjuntos de datos se descargan automáticamente desde la última versión 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

Link to this sectionEntrenar con datos personalizados#

Desarrollar un modelo de detección de objetos 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 Recopilación y anotación de datos.
2. Etiqueta objetos: anota con precisión los objetos de interés dentro de tus imágenes.
3. Entrena un modelo: Usa los datos etiquetados para entrenar tu modelo YOLOv5. Aprovecha el aprendizaje por transferencia empezando con pesos preentrenados.
4. Despliega y predice: Utiliza el modelo entrenado para inferencia en datos nuevos y no vistos.
5. Recopila casos extremos: identifica los escenarios en los que el modelo tiene un rendimiento deficiente (casos extremos) 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 operaciones de aprendizaje automático (MLOps), incluyendo la gestión de datasets, el entrenamiento de modelos y el despliegue.

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

Link to this sectionCrea un conjunto de datos#

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

Link to this section1.1 Crea dataset.yaml#

El archivo de configuración del dataset (p. ej., coco128.yaml) describe la estructura del dataset, los nombres de las clases y las rutas a los directorios de imágenes. COCO128 sirve como ejemplo de dataset pequeño, compuesto por las primeras 128 imágenes del extenso dataset COCO. Es útil para probar rápidamente el flujo de entrenamiento y diagnosticar posibles problemas como el sobreajuste.

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 listan las rutas de imágenes para los conjuntos de entrenamiento, validación y prueba.
• names: un diccionario que asigna índices de clase (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

Link to this section1.2 Aprovecha los modelos para el etiquetado automatizado#

El etiquetado manual es el enfoque habitual, pero consume 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 capacidades de comprensión de imágenes potentes. Se les puede pedir que identifiquen y localicen objetos dentro de las imágenes, generando cuadros delimitadores o descripciones que pueden convertirse en etiquetas con formato YOLO. Explora su potencial en el cuaderno de tutorial proporcionado.
• SAM2 (Segment Anything Model 2): Los modelos base centrados en 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 caja delimitadora 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 usar como punto de partida para generar etiquetas iniciales, que luego pueden refinarse.

El uso de estos modelos puede proporcionar un paso de "pre-etiquetado", lo que reduce 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 potencialmente refinar) tus etiquetas, asegúrate de que se ajusten al formato YOLO: 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 de formato YOLO son precisas:

• Una fila por objeto cuadro delimitador.
• Cada fila debe contener: class_index x_center y_center width height.
• Las coordenadas deben estar normalizadas a un rango entre 0 y 1. Para lograrlo, 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 clase 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 de arriba, que contiene dos objetos 'persona' (índice de clase 0) y un objeto 'corbata' (índice de clase 27), tendría este aspecto:

Link to this section1.3 Organiza los directorios#

Estructura tu directorio de datasets como se ilustra a continuación. Por defecto, YOLOv5 espera que el directorio del dataset (p. ej., /coco128) resida dentro de una carpeta /datasets ubicada adyacente al directorio del repositorio /yolov5.

YOLOv5 localiza automáticamente las etiquetas de cada imagen sustituyendo la última instancia de /images/ en la ruta de la imagen por /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 directorios 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)
            └── ...

Link to this sectionSelecciona un modelo#

Elige un modelo preentrenado para iniciar el proceso de entrenamiento. Empezar 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 forma diferente. Por ejemplo, YOLOv5s es el segundo modelo más pequeño y rápido, adecuado para entornos con recursos limitados. Consulta la tabla del README para una comparación detallada de todos los modelos disponibles.

Link to this sectionEntrena#

Comienza el entrenamiento del modelo usando el script train.py. Los argumentos esenciales incluyen:

• --img: Define el tamaño de la imagen de entrada (p. ej., --img 640). Tamaños mayores generalmente producen una mejor precisión pero requieren más memoria GPU.
• --batch: Determina el tamaño de lote (p. ej., --batch 16). Elige el tamaño más grande que tu GPU pueda manejar.
• --epochs: Especifica el número total de épocas de entrenamiento (p. ej., --epochs 100). Una época representa una pasada completa por 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 inicial. 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 la última versión de YOLOv5 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

Todas las salidas de entrenamiento, incluyendo pesos y registros, se guardan en el directorio runs/train/. Cada sesión de entrenamiento crea un nuevo subdirectorio (por ejemplo, runs/train/exp, runs/train/exp2, etc.). Para una experiencia práctica e interactiva, explora la sección de entrenamiento en nuestros cuadernos de tutoriales oficiales:

Link to this sectionVisualiza#

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

Link to this sectionRegistro y visualización con Comet#

Comet está totalmente integrado para el seguimiento integral de experimentos. Visualiza métricas en tiempo real, guarda hiperparámetros, gestiona datasets y puntos de control del modelo, y analiza las predicciones del modelo usando 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 funciones compatibles en nuestra Guía de integración de Comet. Aprende más sobre las capacidades de Comet en su documentación oficial. Prueba el cuaderno de Colab de Comet para una demostración en vivo:

Link to this sectionRegistro y automatización con ClearML#

La integración de ClearML permite un seguimiento detallado de los experimentos, gestión de versiones de datasets 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 autoalojado o la versión gratuita).

ClearML captura automáticamente los detalles del experimento, subidas de modelos, comparaciones, cambios de código no confirmados y paquetes instalados, garantizando una reproducibilidad total. Puedes programar fácilmente tareas de entrenamiento en agentes remotos y gestionar versiones de datasets usando ClearML Data. Explora la Guía de integración de ClearML para obtener detalles completos.

Link to this sectionRegistro local#

Los resultados del entrenamiento se registran automáticamente usando TensorBoard y se guardan como archivos CSV dentro del directorio específico del experimento (p. ej., 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 las aumentaciones aplicadas (como mosaicos).
• Etiquetas de verdad fundamental junto con las predicciones del modelo para su inspección visual.
• Métricas clave de evaluación como las curvas de Precisión-Exhaustividad (PR).
• Matrices de confusión para un análisis detallado del rendimiento por clase.

El archivo results.csv se actualiza después de cada época y se traza 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

Link to this sectionPasos siguientes#

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 refinamiento adicional. Los posibles pasos siguientes incluyen:

• Ejecuta inferencia en imágenes o vídeos nuevos usando el modelo entrenado a través de la CLI o Python.
• Realiza la validación para evaluar la precisión y las capacidades de generalización del modelo en diferentes divisiones de datos (p. ej., un conjunto de prueba reservado).
• Exporta el modelo a varios formatos de despliegue como ONNX, TensorFlow SavedModel o TensorRT para una inferencia optimizada en diversas plataformas.
• Emplea técnicas de ajuste de hiperparámetros para intentar extraer ganancias de rendimiento adicionales.
• Continúa mejorando tu modelo siguiendo nuestros Consejos para obtener los mejores resultados de entrenamiento y añadiendo de forma iterativa datos más diversos y desafiantes basados en el análisis de rendimiento.

Link to this sectionEntornos admitidos#

Ultralytics proporciona entornos listos para usar equipados con dependencias esenciales como CUDA, cuDNN, Python y PyTorch, facilitando un comienzo fluido.

• Cuadernos de GPU gratuitos:
  • 
  • 
  • 
• Plataformas en la nube:
  • Google Cloud: Guía de inicio rápido de GCP
  • Amazon AWS: Guía de inicio rápido de AWS
  • Microsoft Azure: Guía de inicio rápido de AzureML
• Configuración local:
  • Docker: Guía de inicio rápido de Docker

Link to this sectionEstado 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.

Link to this sectionFAQ#

Link to this section¿Cómo entreno YOLOv5 con mi propio conjunto de datos personalizado?#

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

1. Prepara tu dataset: Recopila imágenes y anótalas. Asegúrate de que las anotaciones estén en el formato YOLO requerido. Organiza las imágenes y 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 (por ejemplo, yolov5s.pt), el tamaño de imagen, el tamaño de 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

Link to this section¿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.
• Monitorización 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 a través de recursos compartidos, herramientas de gestión de proyectos y un sencillo uso compartido de modelos.
• Implementación sin código: Implementa modelos entrenados directamente en diversos destinos.

Para un tutorial práctico, echa un vistazo a nuestra entrada de blog: Cómo entrenar tus modelos personalizados con Ultralytics Platform.

Link to this section¿Cómo convierto mis datos anotados al formato YOLOv5?#

Ya sea que anotes manualmente o utilices herramientas automatizadas (como las mencionadas en la Sección 1.2), las etiquetas finales deben estar en el formato YOLO específico requerido por YOLOv5:

• Crea un archivo .txt por cada imagen. El nombre del archivo debe coincidir con el nombre de la imagen (por ejemplo, image1.jpg corresponde a image1.txt). Coloca estos archivos en un directorio labels/ paralelo a tu directorio images/ (por ejemplo, ../datasets/mydataset/labels/train/).
• Cada línea dentro de un archivo .txt representa la anotación de un 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 están basados 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 usas modelos automatizados, necesitarás scripts o procesos para convertir su salida (p. ej., coordenadas de caja delimitadora, máscaras de segmentación) a este formato de texto normalizado específico. Asegúrate de que la estructura final de tu dataset se adhiera al ejemplo proporcionado en la guía. Para más detalles, consulta nuestra Guía de recopilación y anotación de datos.

Link to this section¿Cuáles son las opciones de licencia para usar YOLOv5 en aplicaciones comerciales?#

Ultralytics ofrece licencias flexibles adaptadas a diferentes necesidades:

• Licencia AGPL-3.0: Esta licencia de código abierto es adecuada para 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 la AGPL-3.0. Revisa los detalles de la licencia AGPL-3.0.
• Licencia Enterprise: 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 la AGPL-3.0, permitiendo la distribución de código cerrado. Visita nuestra página de Licencias para obtener más detalles o para solicitar una Licencia Enterprise.

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