Receta de Entrenamiento de YOLO26
Introducción
Esta guía documenta la receta exacta entrenamiento utilizada para producir los YOLO26 puntos de control preentrenados oficiales en COCO. Cada hiperparámetro mostrado aquí ya está incrustado en los pesos .pt liberados y puede inspeccionarse programáticamente.
Comprender cómo se entrenaron los modelos base le ayuda a tomar mejores decisiones al realizar el ajuste fino: qué aumentos de datos mantener, qué pesos de la función de pérdida ajustar y qué configuraciones del optimizador funcionan mejor para el tamaño de su conjunto de datos.
¿A quién va dirigida esta guía?
Esta guía está dirigida a profesionales que desean comprender los detalles de los puntos de control oficiales de YOLO26 — no solo la arquitectura, sino también los programas de tasa de aprendizaje, las tuberías de aumento y los pesos de pérdida que moldearon su rendimiento. Utilice esta información para tomar decisiones informadas al realizar el ajuste fino con sus propios datos.
Inspección de Argumentos de Entrenamiento
Cada punto de control de Ultralytics almacena la configuración de entrenamiento completa utilizada para producirlo. Puede inspeccionar estos ajustes en cualquier momento:
Inspeccionar argumentos de entrenamiento del punto de control
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
print(model.ckpt["train_args"])
import torch
# Load any official checkpoint
ckpt = torch.load("yolo26n.pt", map_location="cpu", weights_only=False)
# Print all training arguments
for k, v in sorted(ckpt["train_args"].items()):
print(f"{k}: {v}")
Esto funciona para cualquier .pt punto de control — tanto para las versiones oficiales como para sus propios modelos ajustados. Para ver la lista completa de argumentos de entrenamiento configurables, consulte la referencia de configuración de entrenamiento.
Visión General del Entrenamiento
Todos los modelos base de YOLO26 se entrenaron en COCO con una resolución de 640x640 utilizando el optimizador MuSGD con un tamaño de lote de 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 la Plataforma Ultralytics:
Decisiones 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 que combina SGD con actualizaciones ortogonalizadas estilo Muon para los pesos de las convoluciones
- Aumento intensivo de mosaico (probabilidad de ~0.9-1.0) desactivado en las últimas 10 épocas (
close_mosaic=10) - Aumento de escala agresivo (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
| Configuración | 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 |
Estrategia de tasa de aprendizaje
El modelo N utilizó una tasa de aprendizaje inicial más alta con una disminución pronunciada (lrf=0.0495), mientras que los modelos S/M/L/X utilizaron una LR inicial mucho más baja con un programa 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 de manera efectiva.
Pesos de pérdida
| Configuración | 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 de cajas delimitadoras. La pérdida de clasificación se mantiene relativamente consistente en todos los tamaños.
Pipeline de Aumento
Para una explicación detallada de cada técnica, consulte la guía de aumento de datos de YOLO.
| Configuración | 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 un aumento más agresivo en general (mayor MixUp, copiar-pegar 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 un aumento significativo de rotación, cizallamiento y BGR.
Parámetros Internos de Entrenamiento
Avanzado: parámetros internos del pipeline
Los puntos de control también contienen parámetros que se utilizaron en el pipeline de entrenamiento interno pero que no están expuestos como configuraciones configurables por el usuario en default.yaml:
| Configuración | Descripción | N | S | M | L | X |
|---|---|---|---|---|---|---|
muon_w | Peso de actualización Muon en MuSGD | 0.528 | 0.436 | 0.436 | 0.436 | 0.436 |
sgd_w | Peso de actualización SGD en MuSGD | 0.674 | 0.479 | 0.479 | 0.479 | 0.479 |
cls_w | Peso de clasificación interno | 2.74 | 3.48 | 3.48 | 3.48 | 3.48 |
o2m | Peso de pérdida de cabezal de 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 la reproducibilidad, pero no necesitan ser configurados durante el ajuste fino. Consulte las Preguntas Frecuentes para más detalles.
Guía de Ajuste Fino
Al realizar el ajuste fino de YOLO26 en su propio conjunto de datos, no es necesario replicar la receta completa de preentrenamiento. Los pesos preentrenados ya codifican el conocimiento de aumento y optimización del entrenamiento con COCO. Para obtener más información sobre las mejores prácticas de entrenamiento general, consulte Consejos para el Entrenamiento de Modelos.
Empezar Sencillo
Ajuste fino con valores predeterminados
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
results = model.train(data="your-dataset.yaml", epochs=100, imgsz=640)
yolo train model=yolo26n.pt data=your-dataset.yaml epochs=100 imgsz=640
El ajuste fino con valores predeterminados es una línea base sólida. Solo ajuste los hiperparámetros si tiene una razón específica para hacerlo.
Cuándo Ajustar
Small datasets (< 1,000 images):
- Reducir la intensidad del aumento:
mosaic=0.5,mixup=0.0,copy_paste=0.0 - Reducir la tasa de aprendizaje:
lr0=0.001 - Usar menos épocas con paciencia:
epochs=50,patience=20 - Considerar congelar las capas del backbone:
freeze=10
Grandes conjuntos de datos (> 50.000 imágenes):
- Ajustarse más a la receta de preentrenamiento
- Considerar
optimizer=MuSGDpara ejecuciones más largas - Aumentar la augmentación:
mosaic=1.0,mixup=0.3,scale=0.9
Imágenes específicas de dominio (aéreas, médicas, subacuáticas):
- Aumentar
flipud=0.5si la orientación vertical varía - Aumentar
degreessi los objetos aparecen con rotaciones arbitrarias - Ajustar
hsv_syhsv_vsi las condiciones de iluminación difieren significativamente de COCO
Para la optimización automatizada de hiperparámetros, consulte la guía de Ajuste de Hiperparámetros.
Elección del Tamaño del Modelo
| Modelo | Ideal para | Guía de Tamaño de Lote |
|---|---|---|
| YOLO26n | Dispositivos de borde, móviles, en tiempo real en CPU | Lotes grandes (64-128) en GPUs de consumo |
| YOLO26s | Velocidad y precisión equilibradas | Tamaños de lote medianos (32-64) |
| YOLO26m | Mayor precisión con un cómputo moderado | Tamaños de lote más pequeños (16-32) |
| YOLO26l | Alta precisión cuando la GPU está disponible | Tamaños de lote pequeños (8-16) o multi-GPU |
| YOLO26x | Máxima precisión, despliegue en servidor | Tamaños de lote pequeños (4-8) o multi-GPU |
Para opciones de exportación y despliegue, consulte la guía de exportación y las Opciones de Despliegue de Modelos.
Preguntas frecuentes
¿Cómo puedo ver los hiperparámetros exactos utilizados para cualquier punto de control?
Cargue el punto de control con torch.load() y acceda a la train_args clave, o utilice model.ckpt["train_args"] con la API de Ultralytics. Consulte Inspección de Argumentos de Entrenamiento para ejemplos completos.
¿Por qué el número de épocas es diferente para cada tamaño de modelo?
Los modelos más grandes convergen más rápido en COCO porque tienen mayor capacidad. El modelo N necesitó 245 épocas, mientras que el modelo X solo necesitó 40. Al ajustar un modelo con su propio conjunto de datos, el número óptimo de épocas depende del tamaño y la complejidad de su conjunto de datos, no del tamaño del modelo. Utilice la parada temprana (patience) para encontrar automáticamente el punto de parada adecuado.
¿Debería usar MuSGD para el ajuste fino?
Cuándo 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. Puede establecer explícitamente optimizer=MuSGD si lo prefiere. Para más información sobre la selección del optimizador, consulte la documentación de entrenamiento.
¿Qué son los muon_w, sgd_w, cls_w, o2m, y topk en el punto de control?
Estos son parámetros internos del pipeline de entrenamiento que produjo los puntos de control base. Se almacenan para la reproducibilidad, pero no son no están configuraciones configurables por el usuario en default.yaml. No es necesario configurarlos al realizar el ajuste fino. Consulte Parámetros Internos de Entrenamiento para obtener más detalles.
¿Puedo replicar el preentrenamiento exacto desde cero?
Los puntos de control se produjeron utilizando una rama de entrenamiento interna con características adicionales no presentes en el código base público (como configurables o2m pesos y cls_w). Se pueden obtener resultados muy similares utilizando los hiperparámetros documentados en esta página con el paquete público de Ultralytics, pero una reproducción exacta requiere la rama interna.