Ir al contenido

Entrena YOLOv5 en datos personalizados

📚 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 visión artificial a aplicaciones específicas del mundo real más allá de la detección de objetos genérica.

Antes de empezar

Primero, asegúrate de tener configurado el entorno necesario. Clona el repositorio YOLOv5 e instala las dependencias requeridas desde requirements.txt. Un Python>=3.8.0 entorno con PyTorch>=1.8 es esencial. Los modelos y conjuntos de datos se descargan automáticamente del último YOLOv5 release 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

Diagrama del bucle de aprendizaje activo de Ultralytics que muestra la recopilación, el etiquetado, el entrenamiento, la implementación y la recopilación de casos límite de datos

El desarrollo de 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. Etiquetar objetos: Anote los objetos de interés dentro de sus imágenes con precisión.
  3. Entrenar un modelo: Utilice los datos etiquetados para entrenar su modelo YOLOv5. Aproveche el aprendizaje por transferencia comenzando con pesos preentrenados.
  4. Implementar y predecir: Utilice el modelo entrenado para la inferencia en datos nuevos y no vistos.
  5. Recopila casos límite: Identifica escenarios donde el modelo tiene un rendimiento deficiente (casos límite) y añade datos similares a tu conjunto de datos para mejorar la robustez. Repite el ciclo.

Ultralytics HUB ofrece una solución optimizada y sin código para todo este ciclo de operaciones de aprendizaje automático (MLOps), incluida la gestión de conjuntos de datos, el entrenamiento de modelos y la implementación.

Licencias

Ultralytics ofrece dos opciones de licencia para adaptarse a diversos escenarios de uso:

  • Licencia AGPL-3.0: Esta licencia de código abierto aprobada por la OSI es ideal para estudiantes, investigadores y entusiastas apasionados por la colaboración abierta y el intercambio de conocimientos. Requiere que los trabajos derivados se compartan bajo la misma licencia. Consulte el archivo LICENSE para obtener todos los detalles.
  • Licencia Enterprise: Diseñada para aplicaciones comerciales, esta licencia permite la integración perfecta del software Ultralytics y los modelos de IA en productos y servicios comerciales sin las estipulaciones de código abierto de AGPL-3.0. Si su proyecto requiere una implementación comercial, solicite una Licencia Enterprise.

Explore nuestras opciones de licencia con más detalle en la página de Licencias de Ultralytics.

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

1. Crear un Conjunto de Datos

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

1.1 Crear dataset.yaml

El archivo de configuración del conjunto de datos (p. ej., 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 COCO conjunto de datos. Es útil para probar rápidamente la canalización de entrenamiento y diagnosticar posibles problemas como sobreajuste.

El dataset.yaml la estructura del archivo incluye:

  • path: El directorio raíz que contiene el conjunto de datos.
  • train, val, test: Rutas relativas desde path a 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 clase (comenzando desde 0) a sus nombres de clase correspondientes.

A continuación, se muestra la estructura para 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 Aprovechar los Modelos para el Etiquetado Automatizado

Si bien el etiquetado manual con herramientas es un enfoque común, el proceso puede llevar mucho tiempo. Los avances recientes en los modelos básicos ofrecen posibilidades para automatizar o semiautomatizar el proceso de anotación, lo que podría acelerar significativamente la creación del conjunto de datos. Aquí hay algunos ejemplos de modelos que pueden ayudar a generar etiquetas:

  • Google Gemini: Los modelos multimodales grandes 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 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. Si bien son principalmente para la 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. Puede proporcionar descripciones de texto de los objetos que le interesan, y YOLOWorld puede localizarlos en las imágenes sin necesidad de un entrenamiento previo en esas clases específicas. Esto puede utilizarse como punto de partida para generar etiquetas iniciales, que luego pueden ser refinadas.

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

El formato YOLO *.txt las especificaciones del archivo son precisas:

  • Una fila por cada bounding box de objeto.
  • Cada fila debe contener: class_index x_center y_center width height.
  • Las coordenadas deben ser normalizado a un rango entre 0 y 1. Para lograr esto, divide los valores de píxeles de x_center y width por el ancho total de la imagen, y dividir y_center y height por la altura total de la imagen.
  • Los índices de clase están indexados desde cero (es decir, la primera clase está representada por 0, el segundo por 1, y así sucesivamente).

Ejemplo de imagen con dos personas y una corbata anotadas

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

Ejemplo de contenido de archivo de etiquetas en formato YOLO para la imagen anotada

1.3 Organizar los Directorios

Estructure su conjuntos de datos directorio como se ilustra a continuación. De forma predeterminada, YOLOv5 anticipa el directorio del conjunto de datos (p. ej., /coco128) para residir dentro de un /datasets carpeta ubicada adyacente a el /yolov5 directorio del repositorio.

YOLOv5 localiza automáticamente las etiquetas de cada imagen sustituyendo 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 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)
            └── ...

Diagrama que muestra la estructura de directorio del conjunto de datos YOLOv5 recomendada

2. Seleccionar un Modelo

Elige un modelo preentrenado 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 tabla README para obtener una comparación detallada de todos los modelos disponibles.

Gráfico comparativo de los modelos YOLOv5 que muestra el tamaño, la velocidad y la precisión

3. Entrenar

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

  • --img: Define la entrada Tamaño de la imagen (p. ej., --img 640). Los tamaños más grandes generalmente producen una mejor precisión, pero requieren más memoria de la GPU.
  • --batch: Determina el tamaño de lote (p. ej., --batch 16). Elija el tamaño más grande que su GPU pueda soportar.
  • --epochs: Especifica el número total de épocas (p. ej., --epochs 100). Una época representa un paso completo sobre todo el conjunto de datos de entrenamiento.
  • --data: Ruta a tu dataset.yaml archivo (p. ej., --data coco128.yaml).
  • --weights: Ruta al archivo de pesos inicial. Usando pesos preentrenados (por ejemplo, --weights yolov5s.pt) es altamente recomendable para una convergencia más rápida y mejores resultados. Para entrenar desde cero (no se aconseja a menos que tenga un conjunto de datos muy grande y necesidades específicas), utilice --weights '' --cfg yolov5s.yaml.

Los pesos preentrenados se descargan automáticamente de 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

Optimizar la velocidad de entrenamiento

💡 Emplea --cache ram o --cache disk para almacenar en caché las imágenes del conjunto de datos en RAM o en el disco local, respectivamente. Esto acelera drásticamente el entrenamiento, especialmente cuando las operaciones de E/S (Entrada/Salida) del conjunto de datos son un cuello de botella. Ten en cuenta que esto requiere una cantidad considerable de RAM o espacio en disco.

Almacenamiento de datos local

💡 Entrena siempre utilizando conjuntos de datos almacenados localmente. Acceder a datos desde unidades de red (como Google Drive) o almacenamiento remoto puede ser significativamente más lento e impedir el rendimiento del entrenamiento. Copiar tu conjunto de datos a un SSD local es a menudo la mejor práctica.

Todos los resultados del entrenamiento, incluyendo los pesos y los registros, se guardan en el runs/train/ directorio. Cada sesión de entrenamiento crea un nuevo subdirectorio (p. ej., runs/train/exp, runs/train/exp2, etc.). Para una experiencia interactiva y práctica, explore la sección de entrenamiento en nuestros cuadernos de tutoriales oficiales: Abrir en Colab Abrir en Kaggle

4. Visualizar

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

Registro y visualización de Comet 🌟 NUEVO

Comet está totalmente integrado para un seguimiento exhaustivo de los experimentos. Visualice las métricas en directo, guarde los hiperparámetros, gestione los conjuntos de datos y los puntos de control de los modelos, y analice las predicciones de los modelos mediante paneles personalizados de Comet 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!

Profundice en las características admitidas en nuestro Guía de integración de Comet. Obtenga más información sobre las capacidades de Comet en su documentación. Pruebe el cuaderno Comet Colab para una demostración en vivo: Abrir en Colab

Interfaz de usuario de Comet que muestra las métricas y visualizaciones del entrenamiento de YOLOv5

Registro y automatización de ClearML 🌟 NUEVO

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

  • Instala el paquete: pip install clearml
  • Inicializar ClearML: Ejecutar clearml-init una vez para conectarte a tu servidor ClearML (ya sea auto alojado o el nivel gratuito).

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. Puede programar fácilmente tareas de entrenamiento en agentes remotos y administrar las versiones de los conjuntos de datos utilizando ClearML Data. Explore la Guía de integración de ClearML para obtener detalles completos.

Interfaz de usuario de gestión de experimentos de ClearML que muestra gráficos y registros para una ejecución de entrenamiento de YOLOv5

Registro local

Los resultados del entrenamiento se registran automáticamente utilizando TensorBoard y guardado como CSV archivos dentro del directorio de experimento específico (p. ej., runs/train/exp). Los datos registrados incluyen:

  • Pérdida de entrenamiento y validación, y métricas de rendimiento.
  • Imágenes de muestra que muestran aumentos aplicados (como mosaicos).
  • Etiquetas de ground truth junto con las predicciones del modelo para la inspección visual.
  • Métricas de evaluación clave como las curvas de Precisión-Recall (PR).
  • Matrices de confusión para un análisis detallado del rendimiento por clases.

Ejemplo de resultados de registro local que incluyen gráficos y mosaicos de imágenes del entrenamiento de YOLOv5

El results.csv archivo se actualiza después de cada época y se representa como results.png una vez que concluye el entrenamiento. También puedes trazar cualquier results.csv archivo 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

Ejemplo de gráfico results.png que muestra métricas de entrenamiento como mAP, precisión, recall y pérdida a lo largo de las épocas

5. Próximos Pasos

Tras la finalización exitosa del entrenamiento, el punto de control del modelo con mejor rendimiento (best.pt) se guarda y está listo para su despliegue o para un mayor perfeccionamiento. Los posibles pasos siguientes incluyen:

Entornos Compatibles

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

Estado del Proyecto

Insignia de estado de integración continua de YOLOv5

Esta insignia indica que todas las pruebas de GitHub Actions de Integración Continua (CI) de YOLOv5 están pasando con éxito. Estas rigurosas pruebas de CI cubren las funcionalidades principales, incluyendo el entrenamiento, la validación, la inferencia, la exportación y los benchmarks, en los sistemas operativos macOS, Windows y Ubuntu. Las pruebas se ejecutan automáticamente cada 24 horas y tras cada confirmación de código, lo que garantiza una estabilidad constante y un rendimiento óptimo.

Preguntas frecuentes

Preguntas frecuentes

¿Cómo entreno YOLOv5 en mi dataset personalizado?

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

  1. Prepara tu conjunto de datos: Recopila imágenes y anótalas. Asegúrate de que las anotaciones estén en el formato requerido formato YOLO. Organice las imágenes y las etiquetas en train/ y val/ (y opcionalmente test/) directorios. Considere el uso de modelos como Google Gemini, SAM2, o YOLOWorld para ayudar o automatizar el proceso de etiquetado (ver Sección 1.2).
  2. Configurar su entorno: Clona el repositorio 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. Crear 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 dataset.yaml archivo.
  4. Comenzar el entrenamiento: Ejecute el train.py script, proporcionando las rutas a tus dataset.yaml, pesos preentrenados deseados (p. ej., yolov5s.pt), el tamaño de la 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 HUB para entrenar mis modelos YOLO?

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

  • Entrenamiento Simplificado: Entrene modelos fácilmente utilizando entornos preconfigurados y una interfaz de usuario intuitiva.
  • Gestión de datos integrada: Cargue, controle las versiones y gestione sus conjuntos de datos de forma eficiente dentro de la plataforma.
  • Monitoreo en Tiempo Real: Realice un seguimiento del progreso del entrenamiento y visualice las métricas de rendimiento utilizando 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 fácil intercambio de modelos.
  • Implementación sin código: Implemente modelos entrenados directamente en varios objetivos.

Para una guía práctica, consulta nuestra entrada de blog: Cómo entrenar tus modelos personalizados con Ultralytics HUB.

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

Tanto si anota manualmente como si utiliza 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:

  • Crear uno .txt archivo para cada imagen. El nombre del archivo debe coincidir con el nombre del archivo de la imagen (p. ej., image1.jpg corresponde a image1.txt). Coloque estos archivos en un labels/ directorio paralelo a su images/ directorio (p. ej., ../datasets/mydataset/labels/train/).
  • Cada línea dentro de un .txt archivo representa una anotación de objeto y sigue el formato: class_index center_x center_y width height.
  • Coordenadas (center_x, center_y, width, height) debe ser normalizado (valores entre 0.0 y 1.0) relativos a las dimensiones de la imagen.
  • Los índices de clase son basado en cero (la primera clase es 0, el segundo es 1, etc.).

Muchas herramientas de anotación manual ofrecen exportación directa al formato YOLO. Si utiliza modelos automatizados, necesitará scripts o procesos para convertir su salida (por ejemplo, coordenadas de cuadros delimitadores, máscaras de segmentación) en este formato de texto normalizado específico. Asegúrese de que la estructura final de su conjunto de datos se ajuste al ejemplo proporcionado en la guía. Para obtener más detalles, consulte nuestra Guía de recopilación y anotación de datos.

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

Ultralytics proporciona licencias flexibles adaptadas a diferentes necesidades:

  • Licencia AGPL-3.0: Esta licencia de código abierto es adecuada para la investigación académica, los proyectos personales y las situaciones en las que el cumplimiento del código abierto es aceptable. Exige que las modificaciones y los trabajos derivados también sean de código abierto bajo AGPL-3.0. Revise los detalles de la licencia AGPL-3.0.
  • Licencia Enterprise: Una licencia comercial diseñada para empresas que integran YOLOv5 en productos o servicios patentados. Esta licencia elimina las obligaciones de código abierto de AGPL-3.0, lo que permite la distribución de código cerrado. Visite nuestra página de licencias para obtener más detalles o para solicitar una Licencia Enterprise.

Selecciona la licencia que mejor se ajuste a los requisitos de tu proyecto y al modelo de distribución.



📅 Creado hace 1 año ✏️ Actualizado hace 2 meses

Comentarios