Cómo ajustar YOLO en un conjunto de datos personalizado

Ajuste fino (fine-tuning) adapta un modelo preentrenado para reconocer nuevas clases partiendo de pesos ya aprendidos en lugar de una inicialización aleatoria. En lugar de entrenar desde cero durante cientos de épocas, el ajuste fino aprovecha las características COCO preentrenadas y converge en datos personalizados en una fracción del tiempo.

Esta guía cubre el ajuste fino de YOLO26 en conjuntos de datos personalizados, desde el uso básico hasta técnicas avanzadas como congelación de capas y entrenamiento en dos etapas.

Ajuste fino frente a entrenamiento desde cero

Un modelo preentrenado ya ha aprendido características visuales generales (detección de bordes, reconocimiento de texturas, comprensión de formas) a partir de millones de imágenes. Aprendizaje por transferencia mediante el ajuste fino reutiliza ese conocimiento y solo enseña al modelo cómo son las nuevas clases, razón por la cual converge más rápido y requiere menos datos. Entrenar desde cero descarta todo eso y obliga al modelo a aprender todo desde los patrones a nivel de píxel, lo que exige muchos más recursos.

Cómo funciona la transferencia de pesos preentrenados

Cuando un modelo preentrenado se ajusta en un conjunto de datos con un número diferente de clases (por ejemplo, de las 80 clases de COCO a 5 clases personalizadas), Ultralytics realiza una transferencia de pesos consciente de la forma:

1. Transferencia total del backbone y el cuello (neck) - estas capas extraen características visuales generales y sus formas son independientes del número de clases.
2. Reinicio parcial de la cabeza de detección - las capas de salida de clasificación (cv3, one2one_cv3) tienen formas vinculadas al recuento de clases (80 frente a 5), por lo que no pueden transferirse y se inicializan aleatoriamente. Las capas de regresión de cajas (cv2, one2one_cv2) en la cabeza tienen formas fijas independientemente del número de clases, por lo que se transfieren normalmente.
3. La gran mayoría de los pesos se transfieren al cambiar el número de clases. Solo se reinicializan las capas específicas de clasificación en la cabeza de detección; el backbone, el cuello y las ramas de regresión de cajas permanecen intactos.

Para conjuntos de datos con el mismo número de clases que el modelo preentrenado (por ejemplo, ajustar pesos preentrenados en COCO en otro conjunto de datos de 80 clases), el 100% de los pesos se transfieren, incluida la cabeza de detección.

Ejemplo básico de ajuste fino

from ultralytics import YOLO

model = YOLO("yolo26n.pt")  # load pretrained model
model.train(data="path/to/data.yaml", epochs=50, imgsz=640)

Elegir un tamaño de modelo

Los modelos más grandes tienen más capacidad pero también más parámetros que actualizar, lo que puede aumentar el riesgo de sobreajuste cuando los datos de entrenamiento son limitados. Empezar con un modelo más pequeño (YOLO26n o YOLO26s) y escalar solo si las métricas de validación se estancan es un enfoque práctico. El tamaño óptimo del modelo depende de la complejidad de la tarea, el número de clases, la diversidad del conjunto de datos y el hardware disponible para la implementación. Consulta la página del modelo YOLO26 completa para conocer los tamaños disponibles y los puntos de referencia de rendimiento.

Selección de optimizador y tasa de aprendizaje

La configuración predeterminada de optimizer=auto selecciona el optimizador y la tasa de aprendizaje según el número total de iteraciones de entrenamiento:

• < 10.000 iteraciones (conjuntos de datos pequeños o pocas épocas): AdamW con una tasa de aprendizaje baja calculada automáticamente.
• > 10.000 iteraciones (conjuntos de datos grandes): MuSGD (un optimizador híbrido Muon+SGD) con lr=0.01.

Para la mayoría de las tareas de ajuste fino, la configuración predeterminada funciona bien sin ajustes manuales. Considera configurar el optimizador explícitamente cuando:

• El entrenamiento es inestable (la pérdida tiene picos o diverge): prueba optimizer=AdamW, lr0=0.001 para una convergencia más estable.
• Ajuste fino de un modelo grande en un conjunto de datos pequeño: una tasa de aprendizaje más baja como lr0=0.001 ayuda a preservar las características preentrenadas.

Congelación de capas

La congelación evita que capas específicas se actualicen durante el entrenamiento. Esto acelera el entrenamiento y reduce sobreajuste cuando el conjunto de datos es pequeño en relación con la capacidad del modelo.

El método freeze El parámetro acepta un entero o una lista. Un entero freeze=10 congela las primeras 10 capas (de la 0 a la 9, lo que corresponde al backbone en YOLO26). Una lista puede contener índices de capas como freeze=[0, 3, 5] para la congelación parcial del backbone, o nombres de módulos como freeze=["23.cv2"] para un control preciso sobre ramas específicas dentro de una capa.

model.train(data="custom.yaml", epochs=50, freeze=10)

La profundidad de congelación adecuada depende de cuán similar sea el dominio objetivo a los datos preentrenados y de cuántos datos de entrenamiento haya disponibles:

La profundidad de congelación también puede tratarse como un hiperparámetro: probar algunos valores (0, 5, 10) y comparar el mAP de validación es una forma práctica de encontrar la mejor configuración para un conjunto de datos específico.

Hiperparámetros clave para el ajuste fino

El ajuste fino generalmente requiere menos ajustes de hiperparámetros que el entrenamiento desde cero. Los parámetros que más importan son:

• epochs: El ajuste fino converge más rápido que el entrenamiento desde cero. Empieza con un valor moderado y usa patience para detenerte pronto cuando las métricas de validación se estanquen.
• patience: El valor predeterminado de 100 está diseñado para ejecuciones de entrenamiento largas. Reducirlo a 10-20 evita perder tiempo en ejecuciones que ya han convergido.
• warmup_epochs: El calentamiento (warmup) predeterminado (3 épocas) aumenta gradualmente la tasa de aprendizaje desde cero, lo que evita que las actualizaciones grandes de gradiente dañen las características preentrenadas en las iteraciones iniciales. Se recomienda mantener el valor predeterminado incluso para el ajuste fino.

Para ver la lista completa de parámetros de entrenamiento, consulta la referencia de configuración de entrenamiento.

Ajuste fino en dos etapas

El ajuste fino en dos etapas divide el entrenamiento en dos fases. La primera etapa congela el backbone y entrena solo el cuello y la cabeza, permitiendo que las capas de detección se adapten a las nuevas clases sin alterar las características preentrenadas. La segunda etapa descongela todas las capas y entrena el modelo completo con una tasa de aprendizaje más baja para refinar el backbone para el dominio objetivo.

Este enfoque es particularmente útil cuando el dominio objetivo difiere significativamente de COCO (imágenes médicas, imágenes aéreas, microscopía), donde es posible que el backbone necesite adaptación, pero entrenar todo a la vez causa inestabilidad. Para la descongelación automática con un enfoque basado en retrollamadas (callbacks), consulta Congelar y descongelar el backbone.

from ultralytics import YOLO

# Stage 1: freeze backbone, train head and neck
model = YOLO("yolo26n.pt")
model.train(data="custom.yaml", epochs=20, freeze=10, name="stage1", exist_ok=True)

# Stage 2: unfreeze all, fine-tune with lower lr
model = YOLO("runs/detect/stage1/weights/best.pt")
model.train(data="custom.yaml", epochs=30, lr0=0.001, name="stage2", exist_ok=True)

Problemas comunes

El modelo no produce predicciones

• Datos de entrenamiento insuficientes: entrenar con muy pocas muestras es la causa más común; el modelo no puede aprender ni generalizar con muy pocos datos. Asegúrate de tener suficientes ejemplos diversos por clase antes de investigar otras causas.
• Verifica las rutas de los conjuntos de datos: rutas incorrectas en data.yaml producen cero etiquetas silenciosamente. Ejecuta yolo detect val model=yolo26n.pt data=your_data.yaml antes de entrenar para confirmar que las etiquetas se cargan correctamente.
• Reducir el umbral de confianza: si existen predicciones pero se filtran, intenta conf=0.1 durante la inferencia.
• Verificar el recuento de clases: asegúrate de que nc en data.yaml coincida con el número real de clases en los archivos de etiquetas.

El mAP de validación se estanca pronto

• Añadir más datos: el ajuste fino se beneficia significativamente de datos de entrenamiento adicionales, especialmente ejemplos diversos con ángulos, iluminación y fondos variados.
• Comprobar el equilibrio de clases: las clases subrepresentadas tendrán un AP bajo. Usa cls_pw para aplicar ponderación de clase por frecuencia inversa (empieza con cls_pw=0.25 para un desequilibrio moderado, aumenta a 1.0 para un desequilibrio grave).
• Reducir la aumentación: para conjuntos de datos muy pequeños, una aumentación fuerte puede ser más perjudicial que beneficiosa. Prueba mosaic=0.5 o mosaic=0.0.
• Aumentar la resolución: para conjuntos de datos con objetos pequeños, intenta imgsz=1280 para preservar los detalles.

El rendimiento se degrada en las clases originales después del ajuste fino

Esto se conoce como olvido catastrófico: el modelo pierde el conocimiento aprendido previamente cuando se ajusta exclusivamente con nuevos datos. El olvido es casi inevitable si no se incluyen imágenes del conjunto de datos original junto con los nuevos datos. Para mitigar esto:

• Combinar conjuntos de datos: incluye ejemplos de las clases originales junto con las nuevas durante el ajuste fino. Esta es la única forma fiable de prevenir el olvido.
• Congelar backbone y neck: congelar tanto el backbone como el neck para que solo se entrene el detection head ayuda en ejecuciones de ajuste fino cortas con una tasa de aprendizaje muy baja.
• Entrenar durante menos épocas: cuanto más tiempo se entrene el modelo exclusivamente con nuevos datos, mayor será el olvido.

Preguntas frecuentes

¿Cuántas imágenes necesito para ajustar YOLO?

No existe un mínimo fijo: los resultados dependen de la complejidad de la tarea, el número de clases y cuán similar sea el dominio a COCO. Las imágenes más diversas (iluminación, ángulos y fondos variados) importan más que la cantidad bruta. Empieza con lo que tienes y amplía si las métricas de validación son insuficientes.

¿Cómo ajusto YOLO26 en un conjunto de datos personalizado?

Carga un archivo .pt preentrenado y llama a .train() con la ruta a un data.yaml personalizado. Ultralytics gestiona automáticamente la transferencia de pesos, la reinicialización del detection head y la selección del optimizador. Consulta la sección Ajuste fino básico para ver el ejemplo de código completo.

¿Por qué mi modelo YOLO ajustado no detecta nada?

Las causas más comunes son rutas incorrectas en data.yaml (que produce cero etiquetas silenciosamente), una discrepancia entre nc en el YAML y los archivos de etiquetas reales, o un umbral de confianza demasiado alto. Consulta Problemas comunes para obtener una lista completa de verificación de resolución de problemas.

¿Qué capas de YOLO debo congelar para el ajuste fino?

Depende del tamaño del conjunto de datos y de la similitud del dominio. Para conjuntos de datos pequeños con un dominio similar a COCO, congelar el backbone (freeze=10) previene el sobreajuste. Para dominios muy diferentes a COCO, dejar todas las capas sin congelar (freeze=None) permite que el backbone se adapte. Consulta Congelación de capas para obtener recomendaciones detalladas.

¿Cómo evito el olvido catastrófico al ajustar YOLO en nuevas clases?

Incluye ejemplos de las clases originales en los datos de entrenamiento junto con las nuevas clases. Si eso no es posible, congelar más capas (freeze=10 o superior) y usar una tasa de aprendizaje más baja ayuda a preservar el conocimiento preentrenado. Consulta El rendimiento se degrada en las clases originales para más detalles.