Receta de entrenamiento para YOLO26
Introducción
Esta guía documenta la entrenamiento receta exacta utilizada para producir los YOLO26 puntos de control preentrenados oficiales en COCO. Cada hiperparámetro mostrado aquí ya está integrado en los .pt pesos publicados y puede inspeccionarse mediante programación.
Entender cómo se entrenaron los modelos base te ayuda a tomar mejores decisiones al o enfoques de : qué aumentaciones de datos mantener, qué loss function pesos ajustar y qué configuraciones del optimizador funcionan mejor para el tamaño de tu conjunto de datos.
Esta guía es para profesionales que desean entender qué se incluyó en los puntos de control oficiales de YOLO26: no solo la arquitectura, sino los learning rate calendarios, los pipelines de aumentación y los pesos de pérdida que dieron forma a su rendimiento. Usa esta información para tomar decisiones informadas al realizar un ajuste fino en tus propios datos.
Inspeccionar los argumentos de entrenamiento
Cada punto de control de Ultralytics almacena la configuración de entrenamiento completa utilizada para producirlo. Puedes inspeccionar estos ajustes en cualquier momento:
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
print(model.ckpt["train_args"])Esto funciona para cualquier punto de control de .pt: lanzamientos oficiales y tus propios modelos ajustados por igual. Para ver la lista completa de argumentos de entrenamiento configurables, consulta la referencia de configuración de entrenamiento.
Descripción general del entrenamiento
Todos los modelos base de YOLO26 se entrenaron en COCO a una resolución de 640x640 utilizando el optimizador MuSGD con batch size 128. Los modelos se inicializaron a partir de pesos preentrenados intermedios y se refinaron con hiperparámetros encontrados mediante búsqueda evolutiva. Los registros de entrenamiento completos y las métricas para cada tamaño de modelo están disponibles en Ultralytics Platform:
Opciones clave de diseño en todos los tamaños:
- Entrenamiento de extremo a extremo (
end2end=True) con cabezal uno a uno sin NMS - optimizador MuSGD combinando SGD con actualizaciones ortogonalizadas estilo Muon para pesos de conv
- Fuerte mosaic aumentación (~0.9-1.0 de probabilidad) desactivada en las últimas 10 épocas (
close_mosaic=10) - Aumentación de escala agresiva (0.56-0.95) para manejar objetos de diferentes tamaños
- Rotación/cizallamiento mínimo para la mayoría de los tamaños, manteniendo baja la distorsión geométrica
Hiperparámetros por tamaño de modelo
Optimizador y tasa de aprendizaje
| Ajuste | N | S | M | L | X |
|---|---|---|---|---|---|
optimizer | MuSGD | MuSGD | MuSGD | MuSGD | MuSGD |
lr0 | 0.0054 | 0.00038 | 0.00038 | 0.00038 | 0.00038 |
lrf | 0.0495 | 0.882 | 0.882 | 0.882 | 0.882 |
momentum | 0.947 | 0.948 | 0.948 | 0.948 | 0.948 |
weight_decay | 0.00064 | 0.00027 | 0.00027 | 0.00027 | 0.00027 |
warmup_epochs | 0.98 | 0.99 | 0.99 | 0.99 | 0.99 |
epochs | 245 | 70 | 80 | 60 | 40 |
batch | 128 | 128 | 128 | 128 | 128 |
imgsz | 640 | 640 | 640 | 640 | 640 |
El modelo N utilizó una tasa de aprendizaje inicial más alta con una caída pronunciada (lrf=0.0495), mientras que los modelos S/M/L/X utilizaron una tasa de aprendizaje inicial mucho más baja con un calendario más suave (lrf=0.882). Esto refleja las diferentes dinámicas de convergencia de los modelos más pequeños frente a los más grandes: los modelos más pequeños necesitan actualizaciones más agresivas para aprender eficazmente.
Pesos de pérdida
| Ajuste | N | S | M | L | X |
|---|---|---|---|---|---|
box | 5.63 | 9.83 | 9.83 | 9.83 | 9.83 |
cls | 0.56 | 0.65 | 0.65 | 0.65 | 0.65 |
dfl | 9.04 | 0.96 | 0.96 | 0.96 | 0.96 |
El modelo N prioriza la pérdida DFL, mientras que los modelos S/M/L/X cambian el énfasis a la regresión coordenadas de la bbox. La pérdida de clasificación permanece relativamente consistente en todos los tamaños.
Pipeline de aumentación
Para una explicación detallada de cada técnica, consulta la guía de aumentación de datos de YOLO.
| Ajuste | N | S | M | L | X |
|---|---|---|---|---|---|
mosaic | 0.909 | 0.992 | 0.992 | 0.992 | 0.992 |
mixup | 0.012 | 0.05 | 0.427 | 0.427 | 0.427 |
copy_paste | 0.075 | 0.404 | 0.304 | 0.404 | 0.404 |
scale | 0.562 | 0.9 | 0.95 | 0.95 | 0.95 |
fliplr | 0.606 | 0.304 | 0.304 | 0.304 | 0.304 |
degrees | 1.11 | ~0 | ~0 | ~0 | ~0 |
shear | 1.46 | ~0 | ~0 | ~0 | ~0 |
translate | 0.071 | 0.275 | 0.275 | 0.275 | 0.275 |
hsv_h | 0.014 | 0.013 | 0.013 | 0.013 | 0.013 |
hsv_s | 0.645 | 0.353 | 0.353 | 0.353 | 0.353 |
hsv_v | 0.566 | 0.194 | 0.194 | 0.194 | 0.194 |
bgr | 0.106 | 0.0 | 0.0 | 0.0 | 0.0 |
Los modelos más grandes utilizan una aumentación más agresiva en general (mayor mixup, copy-paste, y escala), ya que tienen mayor capacidad y se benefician de una regularización más fuerte. El modelo N es el único tamaño con rotación, significativa, cizallamiento, y BGR aumentación.
Parámetros de entrenamiento internos
Avanzado: parámetros internos de la canalización
Los puntos de control (checkpoints) también contienen parámetros que se utilizaron en la canalización de entrenamiento interna, pero que no no se exponen como ajustes configurables por el usuario en default.yaml:
| Ajuste | Descripción | N | S | M | L | X |
|---|---|---|---|---|---|---|
muon_w | Peso de actualización de Muon en MuSGD | 0.528 | 0.436 | 0.436 | 0.436 | 0.436 |
sgd_w | Peso de actualización de SGD en MuSGD | 0.674 | 0.479 | 0.479 | 0.479 | 0.479 |
cls_w | Peso de clasificación interna | 2.74 | 3.48 | 3.48 | 3.48 | 3.48 |
o2m | Peso de pérdida de cabecera uno-a-muchos | 1.0 | 0.705 | 0.705 | 0.705 | 0.705 |
topk | Asignación de etiquetas Top-k | 8 | 5 | 5 | 5 | 5 |
Estos se registran para garantizar la reproducibilidad, pero no es necesario configurarlos al realizar un ajuste fino (fine-tuning). Consulta la Preguntas frecuentes para más detalles.
Guía de ajuste fino (Fine-Tuning)
Al realizar un ajuste fino de YOLO26 en tu propio conjunto de datos, no necesitas replicar la receta completa de preentrenamiento. Los pesos preentrenados ya codifican el conocimiento de aumentación y optimización del entrenamiento en COCO. Para conocer las mejores prácticas de entrenamiento general, consulta Consejos para el entrenamiento de modelos.
Empieza de forma sencilla
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
results = model.train(data="your-dataset.yaml", epochs=100, imgsz=640)El ajuste fino con valores predeterminados es una base sólida. Solo ajusta los hiperparámetros si tienes una razón específica para hacerlo.
Cuándo ajustar
Conjuntos de datos pequeños (< 1.000 imágenes):
- Reduce la intensidad de la aumentación:
mosaic=0.5,mixup=0.0,copy_paste=0.0 - Reduce la tasa de aprendizaje:
lr0=0.001 - Usa menos epochs con paciencia:
epochs=50,patience=20 - Considera congelar las capas del backbone:
freeze=10
Conjuntos de datos grandes (> 50.000 imágenes):
- Iguala la receta de preentrenamiento más de cerca
- Considera
optimizer=MuSGDpara ejecuciones más largas - Aumenta la aumentación:
mosaic=1.0,mixup=0.3,scale=0.9
Imágenes específicas de dominio (aéreas, médicas, submarinas):
- Aumenta
flipud=0.5si la orientación vertical varía - Aumenta
degreessi los objetos aparecen con rotaciones arbitrarias - Ajusta
hsv_syhsv_vsi las condiciones de iluminación difieren significativamente de COCO
Para la optimización automatizada de hiperparámetros, consulta la guía de ajuste de hiperparámetros.
Elegir un tamaño de modelo
| Modelo | Ideal para | Guía de tamaño de lote (batch size) |
|---|---|---|
| YOLO26n | Dispositivos Edge, móviles, tiempo real en CPU | Lotes grandes (64-128) en GPUs de consumo |
| YOLO26s | Velocidad y precisión equilibradas | Lotes medianos (32-64) |
| YOLO26m | Mayor precisión con cómputo moderado | Lotes más pequeños (16-32) |
| YOLO26l | Alta precisión cuando hay GPU disponible | Lotes pequeños (8-16) o multi-GPU |
| YOLO26x | Máxima precisión, despliegue en servidor | Lotes pequeños (4-8) o multi-GPU |
Para opciones de exportación y despliegue, consulta la Guía de exportación y Opciones de despliegue de modelos.
Preguntas frecuentes
¿Cómo veo los hiperparámetros exactos utilizados para cualquier punto de control?
Carga el punto de control con torch.load() y accede a la clave train_args, o usa model.ckpt["train_args"] con la API de Ultralytics. Consulta Inspeccionar los argumentos de entrenamiento para ejemplos completos.
¿Por qué los recuentos de épocas son diferentes para cada tamaño de modelo?
Los modelos más grandes convergen más rápido en COCO porque tienen más capacidad. El modelo N necesitó 245 épocas, mientras que el modelo X solo necesitó 40. Al realizar un ajuste fino en tu propio conjunto de datos, el número óptimo de épocas depende del tamaño y la complejidad de tu conjunto de datos, no del tamaño del modelo. Usa la parada temprana (early stopping) (patience) para encontrar el punto de parada correcto automáticamente.
¿Debería usar MuSGD para el ajuste fino?
Cuando se utiliza optimizer=auto (el valor predeterminado), Ultralytics selecciona automáticamente MuSGD para ejecuciones de entrenamiento más largas (>10,000 iteraciones) y AdamW para las más cortas. Puedes establecer explícitamente optimizer=MuSGD si lo prefieres. Para más información sobre la selección del optimizador, consulta la documentación de entrenamiento.
¿Qué son muon_w, sgd_w, cls_w, o2m, y topk en el punto de control?
Estos son parámetros internos de la canalización de entrenamiento que produjo los puntos de control base. Se almacenan para la reproducibilidad, pero no son configurables por el usuario en default.yaml. No necesitas configurarlos al realizar el ajuste fino. Consulta Parámetros de entrenamiento internos para más detalles.
¿Puedo replicar el preentrenamiento exacto desde cero?
Los puntos de control se produjeron utilizando una rama de entrenamiento interna con funciones adicionales que no están en la base de código pública (como pesos o2m configurables y cls_w). Puedes obtener resultados muy cercanos usando los hiperparámetros documentados en esta página con el paquete público de Ultralytics, pero una reproducción exacta requiere la rama interna.