Entrenar YOLOv5 con datos personalizados

📚 En esta guía se explica cómo entrenar su propio conjunto de datos personalizado utilizando el programa YOLOv5 🚀. El entrenamiento de modelos personalizados es un paso fundamental para adaptar las soluciones de visión por ordenador a aplicaciones específicas del mundo real más allá de la detección genérica de objetos.

Antes de empezar

En primer lugar, asegúrate de tener configurado el entorno necesario. Clona el repositorio YOLOv5 e instala las dependencias necesarias desde requirements.txt. A Python.8.0 entorno con PyTorch.8 es esencial. Los modelos y conjuntos de datos se descargan automáticamente de la última versión YOLOv5 liberar 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 personalizado de detección de objetos es un proceso iterativo:

1. Recopilar y organizar imágenes: Reúna imágenes relevantes para su tarea específica. Es crucial disponer de datos diversos y de alta calidad. Consulte nuestra guía sobre Recopilación y anotación de datos.
2. Etiquetar objetos: Anota los objetos de interés dentro de tus imágenes con precisión.
3. Entrene un modelo: Utilice los datos etiquetados para entrenar su modelo YOLOv5 . Aproveche el aprendizaje por transferencia empezando con pesos preentrenados.
4. Despliegue y predicción: Utilice el modelo entrenado para realizar inferencias sobre datos nuevos y desconocidos.
5. Recopilar casos extremos: Identifique los escenarios en los que el modelo funciona mal(casos extremos) y añada datos similares a su conjunto de datos para mejorar la solidez. Repita el ciclo.

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

Antes de iniciar el entrenamiento, es esencial preparar el conjunto de datos.

1. Crear un conjunto de datos

Los modelos YOLOv5 requieren datos etiquetados para aprender las características visuales de las clases de objetos. Organizar correctamente el conjunto de datos 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 pequeño conjunto de datos de ejemplo, compuesto por las 128 primeras imágenes del extenso COCO conjunto de datos. Es útil para probar rápidamente el proceso de formación y diagnosticar posibles problemas como sobreajuste.

En dataset.yaml incluye la estructura del archivo:

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

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

# Dataset root directory relative to the yolov5 directory
path: ../datasets/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 Modelos de aprovechamiento para el etiquetado automatizado

Aunque el etiquetado manual mediante herramientas es un método habitual, el proceso puede llevar mucho tiempo. Los recientes avances en los modelos de fundamentos ofrecen la posibilidad de automatizar o semiautomatizar el proceso de anotación, lo que podría acelerar considerablemente la creación de conjuntos de datos. He aquí algunos ejemplos de modelos que pueden ayudar a generar etiquetas:

• Google Géminis: Los grandes modelos multimodales como Gemini poseen potentes capacidades de comprensión de imágenes. Se les puede pedir que identifiquen y localicen objetos dentro de las imágenes, generando cuadros delimitadores o descripciones que pueden convertirse en etiquetas en formato YOLO . Explora su potencial en el cuaderno tutorial proporcionado.
• SAM2 (Segment Anything Model 2): Los modelos de base centrados en la segmentación, como SAM2, pueden identificar y delinear objetos con gran precisión. Aunque sirven principalmente para la segmentación, las máscaras resultantes pueden convertirse a menudo en anotaciones de cuadros delimitadores adecuadas para tareas de detección de objetos.
• YOLOWorld: Este modelo ofrece capacidades de detección de vocabulario abierto. El usuario puede proporcionar descripciones textuales de los objetos que le interesan y YOLOWorld puede localizarlos en las imágenes sin formación previa sobre esas clases específicas. Esto puede utilizarse como punto de partida para generar etiquetas iniciales, que luego pueden refinarse.

El uso de estos modelos puede proporcionar un paso de "pre-etiquetado", reduciendo el esfuerzo manual necesario. Sin embargo, es fundamental revisar y perfeccionar las etiquetas generadas automáticamente para garantizar su precisión y coherencia, ya que la calidad influye directamente en el rendimiento del modelo YOLOv5 entrenado. Después de generar (y posiblemente perfeccionar) las etiquetas, asegúrese de que se adhieren a la etiqueta YOLO formato: uno *.txt por imagen, donde cada línea representa un objeto como class_index x_center y_center width height (coordenadas normalizadas, clase de índice cero). Si una imagen no tiene objetos de interés, no se le asigna el correspondiente *.txt es necesario.

El formato YOLO *.txt las especificaciones de los archivos son precisas:

• Una fila por cuadro delimitador del 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 conseguirlo, divide los valores de los píxeles de x_center y width por la anchura total de la imagen, y divide y_center y height por la altura total de la imagen.
• Los índices de clase tienen índice cero (es decir, la primera clase está representada por 0el segundo por 1etc.).

El archivo de etiquetas correspondiente a la imagen anterior, que contiene dos objetos "persona" (índice de clase 0) y un objeto "empate" (índice de clase 27), quedaría así:

1.3 Organizar directorios

Estructure su conjuntos de datos como se ilustra a continuación. Por defecto, YOLOv5 anticipa el directorio del conjunto de datos (por ejemplo, /coco128) para residir dentro de un /datasets carpeta ubicada junto 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)
            └── ...

2. Seleccione un modelo

Elija 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 modelos, cada uno de los cuales equilibra de forma diferente la velocidad y la precisión. Por ejemplo, YOLOv5s es el segundo modelo más pequeño y rápido, adecuado para entornos con recursos limitados. Consulte la tabla README para obtener una comparación detallada de todos los modelos disponibles.

3. Tren

Comienza el formación de modelos utilizando el train.py guión. Los argumentos esenciales incluyen:

• --img: Define la entrada tamaño de la imagen (por ejemplo --img 640). Los tamaños más grandes suelen ofrecer mayor precisión, pero requieren más memoria GPU .
• --batch: Determina el tamaño del lote (por ejemplo --batch 16). Elija el tamaño más grande que pueda soportar su GPU .
• --epochs: Especifica el número total de entrenamientos épocas (por ejemplo --epochs 100). Una época representa una pasada completa por todo el conjunto de datos de entrenamiento.
• --data: Camino a su dataset.yaml (por ejemplo --data coco128.yaml).
• --weights: Ruta al archivo de pesos iniciales. Utilizando pesos preentrenados (por ejemplo, --weights yolov5s.pt) es muy recomendable para una convergencia más rápida y resultados superiores. Para entrenar desde cero (no aconsejable 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

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

4. Visualice

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

Comet Registro y visualización 🌟 NUEVO

Comet está totalmente integrado para un seguimiento exhaustivo de los experimentos. Visualice métricas en tiempo real, guarde hiperparámetros, gestione conjuntos de datos y puntos de control de modelos y analice predicciones de modelos mediante paneles personalizados interactivos de Comet .

Empezar es muy 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 funciones compatibles en nuestro Guía de integración de Comet. Obtenga más información sobre las capacidades de Comet en su página oficial documentación. Pruebe el cuaderno Comet Colab para una demostración en directo:

ClearML Registro y automatización 🌟 NUEVO

ClearML permite el seguimiento detallado de experimentos, la gestión de versiones de conjuntos de datos e incluso la ejecución remota de series de entrenamiento. Active ClearML con estos sencillos pasos:

• Instala el paquete: pip install clearml
• Inicializar ClearML: Ejecutar clearml-init una vez para conectarse a su servidor ClearML (ya sea autoalojado o el nivel gratuito).

ClearML captura automáticamente los detalles del experimento, las cargas de modelos, las comparaciones, los cambios de código no comprometidos y los paquetes instalados, garantizando una reproducibilidad total. Puede programar fácilmente tareas de formación en agentes remotos y gestionar versiones de conjuntos de datos mediante ClearML Data. Explore la Guía de integración deClearML para obtener información detallada.

Registro local

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

• Pérdidas de formación y validación y métricas de rendimiento.
• Imágenes de muestra de aumentos aplicados (como mosaicos).
• Etiquetas de la verdad sobre el terreno junto a las predicciones del modelo para la inspección visual.
• Métricas de evaluación clave, como las curvas de Precisión-Recuperación (PR).
• Matrices de confusión para un análisis detallado del rendimiento por clases.

En results.csv se actualiza después de cada época y se representa como results.png una vez concluido el entrenamiento. También puede trazar cualquier 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

5. 5. Próximos pasos

Una vez completado con éxito el entrenamiento, el punto de control del modelo con mejores resultados (best.pt) está guardado y listo para su despliegue o perfeccionamiento. Los posibles pasos siguientes incluyen:

• Ejecute la inferencia en nuevas imágenes o vídeos utilizando el modelo entrenado a través de la CLI o Python.
• Realice una validación para evaluar la precisión y la capacidad de generalización del modelo en diferentes divisiones de datos (por ejemplo, un conjunto de prueba retenido).
• Exporte el modelo a varios formatos de despliegue como ONNX, TensorFlow SavedModelo TensorRT para una inferencia optimizada en diversas plataformas.
• Utilizar técnicas de ajuste de hiperparámetros para obtener ganancias de rendimiento adicionales.
• Continúe mejorando su 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 del rendimiento.

Entornos compatibles

Ultralytics proporciona entornos listos para usar equipados con dependencias esenciales como CUDAcuDNN, Pythony PyTorchfacilitando un inicio sin problemas.

• Cuadernos gratuitos GPU:
  • 
  • 
  • 
• Plataformas en nube:
  • Google Nube: 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

Estado del proyecto

Este distintivo indica que todas las pruebas de integración continua (IC)de las acciones de GitHub YOLOv5 se están superando con éxito. Estas rigurosas pruebas de integración continua cubren las funcionalidades básicas, como la formación, la validación, la inferencia, la exportación y los puntos de referencia, en los sistemas operativos macOS, Windows y Ubuntu. Las pruebas se ejecutan automáticamente cada 24 horas y en 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 conjunto de datos personalizado?

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

1. Prepare su conjunto de datos: Recoger imágenes y anotarlas. Asegúrese de que las anotaciones YOLO formato. Organizar imágenes y etiquetas en train/ y val/ (y opcionalmente test/). Considere la posibilidad de utilizar modelos como Google Géminis, SAM2o YOLOWorld para ayudar o automatizar el proceso de etiquetado (véase el apartado 1.2).
2. Configure su entorno: Clone el repositorio YOLOv5 e instale las dependencias utilizando pip install -r requirements.txt.

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

3. Crear configuración de conjunto de datos: Defina las rutas de los conjuntos de datos, el número de clases y los nombres de las clases en un dataset.yaml archivo.
4. Iniciar la formación: Ejecutar el train.py proporcionando rutas a sus dataset.yamlpesos preentrenados deseados (por ejemplo, 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 utilizar Ultralytics HUB para formar a mis modelos YOLO ?

Ultralytics HUB es una plataforma integral diseñada para agilizar todo el ciclo de vida de desarrollo del modelo YOLO , a menudo sin necesidad de escribir ningún código. Entre sus principales ventajas se incluyen:

• Formación simplificada: Entrene fácilmente los modelos 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.
• Seguimiento en tiempo real: Siga el progreso de la formación y visualice las métricas de rendimiento utilizando 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 un sencillo uso compartido de modelos.
• Despliegue sin código: Despliegue modelos entrenados directamente en varios objetivos.

Para un recorrido práctico, echa un vistazo a nuestra entrada de blog: Cómo entrenar sus modelos personalizados con Ultralytics HUB.

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

Tanto si realiza las anotaciones manualmente como si utiliza herramientas automatizadas (como las mencionadas en el apartado 1.2), las etiquetas finales deben estar en el formatoYOLO específico que exige YOLOv5:

• Crear uno .txt para cada imagen. El nombre del archivo debe coincidir con el de la imagen (por ejemplo, image1.jpg corresponde a image1.txt). Coloque estos archivos en una carpeta labels/ paralelo a su images/ (por ejemplo ../datasets/mydataset/labels/train/).
• Cada línea dentro de un .txt 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) en relación con las dimensiones de la imagen.
• Los índices de clase son base cero (la primera clase es 0el segundo es 1etc.).

Muchas herramientas de anotación manual ofrecen exportación directa al formato YOLO . Si utiliza modelos automatizados, necesitará secuencias de comandos o procesos para convertir sus resultados (por ejemplo, coordenadas de cuadro delimitador, máscaras de segmentación) a este formato específico de texto normalizado. Asegúrese de que la estructura final del conjunto de datos se ajusta al ejemplo proporcionado en la guía. Para más información, consulte nuestra Guía de recogida y anotación de datos.

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

Ultralytics ofrece licencias flexibles adaptadas a diferentes necesidades:

• LicenciaAGPL-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 se acepta el cumplimiento del código abierto. Obliga a que las modificaciones y obras derivadas sean también de código abierto bajo AGPL-3.0. Consulte los detalles de la licenciaAGPL-3.0 .
• Licencia de empresa: Una licencia comercial diseñada para empresas que integran YOLOv5 en productos o servicios propios. Esta licencia elimina las obligaciones de código abierto de AGPL-3.0, lo que permite una distribución de código cerrado. Visite nuestra página de licencias para obtener más información o solicitar una licencia de empresa.

Seleccione la licencia que mejor se adapte a los requisitos y al modelo de distribución de su proyecto.

Creado hace 1 año ✏️ Actualizado hace 1 mes

Comentarios