Entrenamiento de modelos con Ultralytics YOLO
Introducción#
El entrenamiento de un modelo de aprendizaje profundo consiste en proporcionarle datos y ajustar sus parámetros para que pueda hacer predicciones precisas. El modo Train de Ultralytics YOLO26 entrena de forma eficiente modelos de detección de objetos y de otras tareas de visión en hardware moderno. Esta guía explica lo que necesitas para empezar a entrenar tus propios modelos con YOLO26. Si aún no has instalado Ultralytics, empieza por la guía de inicio rápido.
Consulta la versión preliminar no publicada de YOLO27 para ver los ejemplos de entrenamiento previstos.
Ver: Cómo entrenar un modelo YOLO con tu conjunto de datos personalizado en Google Colab.
¿Por qué elegir Ultralytics YOLO para entrenar?#
Motivos para utilizar el modo Train de YOLO26:
- Eficiencia: Aprovecha al máximo tu hardware, tanto si utilizas un único equipo con GPU como si escalas a varias GPU.
- Versatilidad: Entrena con conjuntos de datos personalizados, además de con conjuntos disponibles fácilmente, como COCO, VOC e ImageNet.
- Facilidad de uso: Interfaces sencillas pero potentes de CLI y Python para que entrenar sea fácil.
- Flexibilidad de los hiperparámetros: Dispones de una amplia variedad de hiperparámetros personalizables para ajustar el rendimiento del modelo. Para tener un control más preciso, puedes personalizar el entrenador.
- Entrenamiento en la nube: Entrena en GPU en la nube a través de Ultralytics Platform, con métricas en tiempo real y guardado automático de checkpoints.
Funciones clave del modo de entrenamiento#
Estas son algunas de las funciones más destacadas del modo de entrenamiento de YOLO26:
- Descarga automática de conjuntos de datos: Las configuraciones de conjuntos de datos que incluyen una fuente de descarga se descargan automáticamente la primera vez que se utilizan; por ejemplo,
yolo train data=coco8.yaml. Consulta la descripción general de los conjuntos de datos para ver los formatos y conjuntos de datos compatibles. - Compatibilidad con varias GPU: Escala el entrenamiento a varias GPU para reducir su duración.
- Configuración de hiperparámetros: Puedes modificar los hiperparámetros mediante archivos de configuración YAML o argumentos de CLI.
- Visualización y supervisión: Seguimiento en tiempo real de las métricas de entrenamiento y visualización del proceso de aprendizaje para obtener información más útil.
Ejemplos de uso#
Entrena YOLO26n con el conjunto de datos COCO8 durante 100 épocas con un tamaño de imagen de 640. Puedes especificar el dispositivo de entrenamiento con el argumento device. Si no se pasa ningún argumento, se utilizará la GPU device=0 cuando esté disponible; de lo contrario, se utilizará device='cpu'.
En Windows, puede aparecer un RuntimeError al iniciar el entrenamiento como script. Añade un bloque if __name__ == "__main__": antes del código de entrenamiento para solucionarlo.
El dispositivo se determina automáticamente. Si hay una GPU disponible, se utilizará (dispositivo CUDA 0 de forma predeterminada); de lo contrario, el entrenamiento se iniciará en la CPU.
from ultralytics import YOLO
# Cargar un modelo
model = YOLO("yolo26n.yaml") # Crea un modelo nuevo a partir de YAML
model = YOLO("yolo26n.pt") # Carga un modelo preentrenado (recomendado para el entrenamiento)
model = YOLO("yolo26n.yaml").load("yolo26n.pt") # Crea el modelo a partir de YAML y transfiere los pesos
# Entrenar el modelo
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)Entrenamiento con varias GPU#
El entrenamiento con varias GPU aprovecha mejor el hardware disponible al distribuir la carga de entrenamiento entre varias GPU. Esta función está disponible tanto a través de la API de Python como de la interfaz de línea de comandos. Para activar el entrenamiento con varias GPU, especifica los ID de las GPU que quieras utilizar.
Para entrenar con 2 GPU (dispositivos CUDA 0 y 1), utiliza los siguientes comandos. Añade más GPU según sea necesario.
from ultralytics import YOLO
# Cargar un modelo
model = YOLO("yolo26n.pt") # Carga un modelo preentrenado (recomendado para el entrenamiento)
# Entrena el modelo con 2 GPU
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[0, 1])
# Entrena el modelo con las dos GPU más inactivas
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -1])El entrenamiento con varias GPU no funciona en Windows con las versiones oficiales de PyTorch para torch>=2.4. Ultralytics inicia DDP mediante torch.distributed.run, cuyo paso de encuentro crea un TCPStore que utiliza el backend libuv de forma predeterminada desde PyTorch 2.4; las versiones oficiales de PyTorch para Windows se compilan sin libuv. El entrenamiento se cierra inmediatamente con:
RuntimeError: use_libuv was requested but PyTorch was built without libuv support
Establecer USE_LIBUV=0 no lo soluciona, porque el proceso de encuentro crea directamente TCPStore y esa ruta de código nunca lee la variable. Entrena en Linux o WSL2 para usar varias GPU, o entrena con una sola GPU usando device=0 en Windows.
Al especificar varios dispositivos (por ejemplo, device=[0, 1]), Ultralytics inicia internamente una nueva instancia del entrenador y ejecuta torch.distributed.run en segundo plano. Esto funciona con el uso estándar de CLI y con scripts de Python sin modificar.
Sin embargo, si tu script contiene componentes personalizados, como un entrenador, un validador, un conjunto de datos o una canalización de aumento de datos personalizados, estos objetos no se pueden serializar y transferir automáticamente a los subprocesos de DDP. En ese caso, debes iniciar el script directamente con torch.distributed.run:
python -m torch.distributed.run --nproc_per_node 2 your_training_script.pyEl entrenamiento en GPU AMD utiliza una compilación de PyTorch con ROCm y la sintaxis estándar device=0 o device=cuda:0. Consulta la guía de integración de AMD para obtener información sobre la instalación de ROCm, el entrenamiento con varias GPU, las notas sobre AMP y la inferencia con MIGraphX de los modelos exportados.
El entrenamiento en GPU Intel utiliza device=xpu:0 o varios ID de XPU con una compilación de PyTorch que incluya XCCL.
Entrenamiento en NPU Huawei Ascend#
Ultralytics permite entrenar y validar en NPU Huawei Ascend mediante torch_npu. Instala versiones compatibles entre sí de CANN, PyTorch y torch_npu siguiendo la guía de instalación de Ascend Extension for PyTorch y, a continuación, activa el entorno de CANN antes de iniciar Ultralytics:
source /usr/local/Ascend/ascend-toolkit/set_env.shfrom ultralytics import YOLO
model = YOLO("yolo26n.pt")
# Entrena en una NPU Ascend
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="npu:0")
# Entrena en dos NPU Ascend mediante HCCL
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="npu:0,1")Las funciones de entrenamiento estándar, como AMP, la validación, los checkpoints y la reanudación, utilizan la NPU activa. AutoBatch está disponible para el entrenamiento con una sola NPU, mientras que varios ID de NPU inician el entrenamiento distribuido mediante HCCL. Consulta la guía de integración de Huawei Ascend para exportar y desplegar el modelo después del entrenamiento.
Entrenamiento en GPU inactivas#
El entrenamiento con GPU inactivas selecciona automáticamente las GPU menos utilizadas en sistemas con varias GPU, para que no tengas que elegir los dispositivos manualmente. Clasifica las GPU disponibles según su utilización y la VRAM libre.
Para seleccionar y utilizar automáticamente la GPU o las GPU más inactivas para el entrenamiento, usa el parámetro de dispositivo -1. Esto resulta especialmente útil en entornos de computación compartidos o servidores con varios usuarios.
from ultralytics import YOLO
# Cargar un modelo
model = YOLO("yolo26n.pt") # Carga un modelo preentrenado (recomendado para el entrenamiento)
# Entrena con la GPU más inactiva
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=-1)
# Entrena con las dos GPU más inactivas
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -1])El algoritmo de selección automática da prioridad a las GPU con:
- Menores porcentajes de utilización actual
- Más memoria disponible (VRAM libre)
Esto resulta especialmente útil en entornos de computación compartidos o al ejecutar varios trabajos de entrenamiento a la vez, ya que los dispositivos se seleccionan según las condiciones actuales cada vez que empieza una ejecución.
Entrenamiento con MPS en Apple Silicon#
Los modelos Ultralytics YOLO pueden entrenarse en Apple silicon mediante el framework Metal Performance Shaders (MPS), que ejecuta tareas de cálculo y procesamiento de imágenes en las GPU diseñadas por Apple.
Para entrenar en Apple silicon, especifica mps como dispositivo al iniciar el entrenamiento, ya sea en Python o en la línea de comandos:
from ultralytics import YOLO
# Cargar un modelo
model = YOLO("yolo26n.pt") # Carga un modelo preentrenado (recomendado para el entrenamiento)
# Entrena el modelo con MPS
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")Reanudación de entrenamientos interrumpidos#
Reanudar el entrenamiento desde un punto de control guardado resulta útil si una ejecución se interrumpió inesperadamente o si quieres seguir entrenando un modelo con datos nuevos o durante más épocas.
Al reanudar el entrenamiento, Ultralytics YOLO carga los pesos del último modelo guardado y también restaura el estado del optimizador, el programador de la tasa de aprendizaje, el número de época y el conjunto de datos. El entrenamiento continúa entonces desde el punto en que se detuvo. Pasa explícitamente data= junto con resume para continuar con otro conjunto de datos en lugar del del punto de control.
Para reanudar el entrenamiento en Ultralytics YOLO, establece el argumento resume en True al llamar al método train y especifica la ruta al archivo .pt que contiene los pesos del modelo parcialmente entrenado.
Para reanudar una ejecución de entrenamiento interrumpida en Python o en la línea de comandos:
from ultralytics import YOLO
# Cargar un modelo
model = YOLO("path/to/last.pt") # cargar un modelo entrenado parcialmente
# Reanudar el entrenamiento
results = model.train(resume=True)Al establecer resume=True, la función train continuará el entrenamiento desde donde se detuvo, utilizando el estado almacenado en el archivo path/to/last.pt. Si se omite el argumento resume o se establece en False, la función train iniciará una nueva sesión de entrenamiento. Al reanudar una ejecución que transmite datos a Ultralytics Platform, se continúa con el mismo modelo de Platform.
Recuerda que, de forma predeterminada, los puntos de control se guardan al final de cada época, o a intervalos fijos mediante el argumento save_period, por lo que debes completar al menos 1 época para reanudar una ejecución de entrenamiento.
Ajustes de entrenamiento#
Los ajustes de entrenamiento de los modelos YOLO incluyen varios hiperparámetros y configuraciones utilizados durante el proceso de entrenamiento. Estos ajustes influyen en el rendimiento, la velocidad y la precisión del modelo. Entre los principales ajustes de entrenamiento están el tamaño del lote, la tasa de aprendizaje, el momento y la disminución de pesos. Además, la elección del optimizador, la función de pérdida y la composición del conjunto de datos de entrenamiento pueden afectar al proceso. Ajustar y probar estos parámetros cuidadosamente es fundamental para optimizar el rendimiento.
Optimizador MuSGD#
En YOLO26, MuSGD es un optimizador híbrido que combina las actualizaciones estándar de SGD con las actualizaciones ortogonalizadas al estilo de Muon.
Se recomienda para entrenamientos prolongados de YOLO26 y conjuntos de datos más grandes, donde las actualizaciones ortogonalizadas de Muon pueden ayudar a estabilizar la optimización.
Solo los pesos lineales 2D y los filtros convolucionales 4D (reformados a 2D) reciben la actualización al estilo de Muon junto con SGD; el resto de los parámetros, como los pesos de normalización por lotes y los términos de sesgo, siguen utilizando SGD estándar.
Cuando se usa optimizer=auto, Ultralytics selecciona automáticamente MuSGD para los entrenamientos prolongados (normalmente cuando iterations > 10000). En las ejecuciones más cortas, el entrenador recurre a AdamW. En el modo auto, el entrenador también selecciona la tasa de aprendizaje, por lo que se ignora cualquier lr0 proporcionado por el usuario. Para controlar estos ajustes manualmente, selecciona un optimizador explícitamente, por ejemplo, optimizer=AdamW lr0=0.001.
Ejemplo de uso:
yolo train model=yolo26n.pt data=coco8.yaml optimizer=MuSGDConsulta la implementación en ultralytics/optim/muon.py y la lógica de selección automática del optimizador en BaseTrainer.build_optimizer.
| Argumento | Tipo | Predeterminado | Descripción |
|---|---|---|---|
model | str | None | Especifica el archivo del modelo para el entrenamiento. Acepta la ruta a un modelo preentrenado .pt o a un archivo de configuración .yaml. Es esencial para definir la estructura del modelo o inicializar los pesos. |
data | str | None | Ruta al YAML del conjunto de datos (p. ej., coco8.yaml), que contiene las rutas a los datos de entrenamiento y validación, los nombres de las clases y el número de clases. Para la clasificación, se usa en su lugar un directorio del conjunto de datos o el nombre de un conjunto de datos integrado (p. ej., imagenet10). |
epochs | int | 100 | Número total de épocas de entrenamiento. Cada época representa una pasada completa por todo el conjunto de datos. Ajustar este valor puede afectar a la duración del entrenamiento y al rendimiento del modelo. |
time | float | None | Duración máxima del entrenamiento en horas. Si se establece, prevalece sobre el argumento epochs y permite que el entrenamiento se detenga automáticamente al cumplirse el tiempo especificado. Es útil cuando el tiempo de entrenamiento es limitado. |
patience | int | 100 | Número de épocas que se espera sin mejoras en las métricas de validación antes de detener el entrenamiento de forma anticipada. Ayuda a evitar el sobreajuste deteniendo el entrenamiento cuando el rendimiento se estabiliza. |
batch | int o float | 16 | Tamaño del lote, con tres modos: establecer un número entero (p. ej., batch=16), modo automático para el 60 % de la memoria GPU disponible (batch=-1) o modo automático con una fracción especificada de la memoria GPU disponible (batch=0.70). |
imgsz | int | 640 | Tamaño objetivo de las imágenes para el entrenamiento. Las imágenes se redimensionan a cuadrados cuyos lados tienen el valor especificado (si rect=False); los modelos YOLO conservan la relación de aspecto, pero RT-DETR no. Afecta a la precisión del modelo y a la complejidad computacional. |
save | bool | True | Activa el guardado de los puntos de control del entrenamiento y de los pesos finales del modelo. Es útil para reanudar el entrenamiento o para la implementación del modelo. |
save_period | int | -1 | Frecuencia de guardado de los puntos de control del modelo, especificada en épocas. Un valor de -1 desactiva esta función. Es útil para guardar modelos intermedios durante sesiones de entrenamiento largas. |
cache | bool o str | False | Activa el almacenamiento en caché de las imágenes del conjunto de datos en memoria (True/ram), en disco (disk) o lo desactiva (False). Aumenta la velocidad del entrenamiento al reducir las operaciones de E/S de disco, a costa de un mayor uso de memoria. |
tile | bool o int | False | Expande cada imagen de origen en teselas de entrenamiento fijas con etiquetas recortadas y ventanas negativas conservadas. True usa imgsz; un entero positivo establece el tamaño de las teselas. Consulta Teselado de alta resolución. |
device | int o str o list | None | Especifica el dispositivo o los dispositivos de cálculo para el entrenamiento: una sola GPU (device=0), varias GPU (device=[0,1]), CPU (device=cpu), MPS para Apple silicon (device=mps), NPU Huawei Ascend (device=npu:0 o device=npu:0,1), Intel XPU (device=xpu:0), selección automática de una GPU inactiva (device=-1) o de varias GPU inactivas (device=[-1,-1]). |
workers | int | 8 | Número de hilos de trabajo para cargar datos (por cada RANK si se entrena con varias GPU). Influye en la velocidad del preprocesamiento de datos y de su suministro al modelo; resulta especialmente útil en configuraciones con varias GPU. |
project | str | None | Nombre del directorio del proyecto donde se guardan los resultados del entrenamiento. Una ruta relativa se coloca dentro de runs_dir/<task>, mientras que una ruta absoluta se usa tal cual. |
name | str | None | Nombre de la ejecución de entrenamiento. Se usa para crear un subdirectorio dentro de la carpeta del proyecto donde se almacenan los registros y los resultados del entrenamiento. |
exist_ok | bool | False | Si es True, permite sobrescribir un directorio de proyecto/nombre existente. Es útil para experimentar de forma iterativa sin tener que eliminar manualmente los resultados anteriores. |
save_dir | str | None | Especifica el directorio exacto donde se guardan los resultados de la ejecución y prevalece sobre la combinación project/name. La ruta se usa tal cual, sin incrementar automáticamente el nombre; por tanto, las ejecuciones consecutivas reutilizan el mismo directorio. |
pretrained | bool o str | True | Determina si se empieza el entrenamiento con pesos preentrenados. Puede ser un valor booleano o una ruta de cadena a los pesos que se cargarán. pretrained=False entrena con pesos inicializados aleatoriamente y mantiene la arquitectura del modelo. |
cls_remap | bool | True | Al ajustar el modelo con distintos conjuntos de datos, copia al nuevo modelo las filas de la cabeza de clasificación preentrenada correspondientes a las clases con nombres coincidentes. Así, las clases coincidentes conservan los sesgos aprendidos y también los pesos si el ancho de la cabeza no cambia. Se aplica tanto si el número de clases varía como si coincide pero el orden es distinto. |
optimizer | str | 'auto' | Elección del optimizador para el entrenamiento. Entre las opciones se incluyen SGD, MuSGD, Adam, Adamax, AdamW, NAdam, RAdam, RMSProp o auto, para elegir AdamW o MuSGD según el número de iteraciones de entrenamiento. Afecta a la velocidad y la estabilidad de la convergencia. |
seed | int | 0 | Establece la semilla aleatoria del entrenamiento para garantizar que los resultados sean reproducibles en ejecuciones con las mismas configuraciones. |
deterministic | bool | True | Fuerza el uso de algoritmos deterministas, lo que garantiza la reproducibilidad, pero puede afectar al rendimiento y la velocidad debido a la restricción de los algoritmos no deterministas. |
verbose | bool | True | Activa una salida detallada durante el entrenamiento, que muestra barras de progreso, métricas por época e información adicional sobre el entrenamiento en la consola. |
single_cls | bool | False | Trata todas las clases de los conjuntos de datos multiclase como una sola clase durante el entrenamiento. Es útil para tareas de clasificación binaria o cuando interesa detectar la presencia de objetos en lugar de clasificarlos. |
classes | list[int] | None | Especifica una lista de ID de clase con los que entrenar. Es útil para filtrar las clases y centrarse únicamente en algunas durante el entrenamiento. |
rect | bool | False | Activa la estrategia de relleno mínimo: las imágenes de un lote reciben el relleno mínimo necesario para alcanzar un tamaño común, con el lado más largo igual a imgsz. Puede mejorar la eficiencia y la velocidad, pero afectar a la precisión del modelo. El entrenador estándar de YOLO usa rect=True para la validación de detección, segmentación, pose y OBB, independientemente de este ajuste. |
multi_scale | float | 0.0 | Varía aleatoriamente imgsz en cada lote en +/- multi_scale (p. ej., de 0.25 a 0.75x y 1.25x), redondeando a múltiplos del stride del modelo; 0.0 desactiva el entrenamiento multiescala. |
cos_lr | bool | False | Usa un programador cosenoidal de la tasa de aprendizaje, que la ajusta siguiendo una curva cosenoidal a lo largo de las épocas. Ayuda a gestionar la tasa de aprendizaje para lograr una mejor convergencia. |
close_mosaic | int | 10 | Desactiva la aumentación de datos mosaico durante las últimas N épocas para estabilizar el entrenamiento antes de que termine. Si se establece en 0, se desactiva esta función. |
resume | bool | False | Reanuda el entrenamiento desde el último punto de control guardado. Carga automáticamente los pesos del modelo, el estado del optimizador y el número de época, y continúa el entrenamiento desde donde se interrumpió. |
amp | bool o str | True | Establece la precisión del entrenamiento: True o "fp16" usa FP16, "bf16" usa BF16 en los dispositivos CUDA compatibles y False o "fp32" usa FP32. |
quantize | int o str | None | Establece 8 (o "int8") para el entrenamiento con cuantización INT8 consciente de la cuantización (QAT), que ajusta el modelo con cuantización simulada durante el proceso para que los pesos admitan la exportación a INT8. Consulta Entrenamiento con cuantización consciente. |
fraction | float, int o list | 1.0 | Subconjunto del conjunto de datos expresado como proporción, recuento o lista [train, val, test]. 1 indica que se usa toda la partición; los enteros superiores a 1 representan cantidades de imágenes, y solo la entrada de prueba opcional acepta 0/0.0 para indicar que no se usa ninguna. Las listas de dos elementos mantienen completa la partición de prueba. |
profile | bool | False | Activa la elaboración de perfiles de velocidad de ONNX y TensorRT durante el entrenamiento, útil para optimizar la implementación del modelo. |
freeze | int o list | None | Congela las primeras N capas del modelo o capas específicas por índice o nombre de módulo (23.cv2, sin el model. inicial), lo que reduce el número de parámetros entrenables. Es útil para el ajuste fino o el aprendizaje por transferencia. |
lr0 | float | 0.01 | Tasa de aprendizaje inicial (p. ej., SGD=1E-2, Adam=1E-3). Se ignora con el valor predeterminado optimizer='auto'; especifica un optimizador de forma explícita para usarla. |
lrf | float | 0.01 | Tasa de aprendizaje final como fracción de la tasa inicial = (lr0 * lrf); se usa junto con los programadores para ajustar la tasa de aprendizaje con el tiempo. |
momentum | float | 0.937 | Momentum de SGD/MuSGD o beta1 para los optimizadores Adam. Con optimizer=auto, AdamW usa 0.9; MuSGD empieza en 0.9 y, después, el calentamiento interpola desde warmup_momentum hasta momentum. Sin calentamiento, MuSGD automático se mantiene en 0.9. |
weight_decay | float | 0.0005 | Término de regularización L2 que penaliza los pesos grandes para evitar el sobreajuste. |
warmup_epochs | float | 3.0 | Épocas de calentamiento (se permiten fracciones), limitadas para que la última época quede sin calentamiento. La tasa de aprendizaje aumenta linealmente desde 0 (sesgo de warmup_bias_lr) hasta el valor programado, el momentum desde warmup_momentum hasta momentum y la acumulación de gradientes desde 1 lote hasta su valor nominal (consulta nbs); todos alcanzan sus valores objetivo al terminar el calentamiento. |
warmup_momentum | float | 0.8 | Momentum inicial para optimizadores con un término de momentum (SGD, MuSGD, RMSprop), que aumenta linealmente hasta momentum al terminar el calentamiento. beta1 de la familia Adam no se calienta. |
warmup_bias_lr | float | 0.1 | Tasa de aprendizaje de los parámetros de sesgo durante la fase de calentamiento, que ayuda a estabilizar el entrenamiento del modelo en las primeras épocas. Se establece automáticamente en 0.0 con el valor predeterminado optimizer='auto'; indica un optimizador explícitamente para usarla. |
distill_model | str | None | Ruta a un punto de control del modelo profesor (p. ej., yolo26x.pt) para la destilación de conocimiento. Al establecerla, el modelo alumno se entrena con una pérdida de destilación adicional guiada por el modelo profesor congelado. |
dis | float | 6.0 | Peso de la pérdida de destilación que se añade a las pérdidas de detección estándar. Los valores más altos aumentan la influencia de la orientación basada en las características del modelo profesor. |
box | float | 7.5 | Peso del componente de pérdida de cuadros en la función de pérdida, que determina la importancia de predecir con precisión las coordenadas del cuadro delimitador. |
cls | float | 0.5 | Peso de la pérdida de clasificación en la función de pérdida total, que determina la importancia de predecir correctamente la clase respecto a los demás componentes. |
cls_pw | float | 0.0 | Potencia para ponderar las clases y gestionar el desequilibrio entre ellas mediante la frecuencia inversa de clase. 0.0 desactiva la ponderación de clases; 1.0 aplica la ponderación completa por frecuencia inversa. Los valores entre 0 y 1 aplican una ponderación parcial. |
dfl | float | 1.5 | Peso del término de regresión de la distancia de los cuadros: pérdida focal de distribución (DFL) cuando la cabeza de detección usa reg_max > 1; pérdida L1 sobre distancias de cuadros normalizadas en YOLO26 sin DFL (reg_max: 1). |
pose | float | 12.0 | Peso de la pérdida de pose en los modelos entrenados para estimar poses, que determina la importancia de predecir con precisión los puntos clave de la pose. |
kobj | float | 1.0 | Peso de la pérdida de objetividad de los puntos clave en los modelos de estimación de pose, que equilibra la confianza de detección y la precisión de la pose. |
rle | float | 1.0 | Peso de la pérdida de estimación residual de log-verosimilitud en los modelos de estimación de pose, que afecta a la precisión de la localización de los puntos clave. |
angle | float | 1.0 | Peso de la pérdida del ángulo en los modelos OBB, que afecta a la precisión de las predicciones del ángulo de los cuadros delimitadores orientados. |
dlog | float | 1.0 | Peso de la pérdida logarítmica invariante a la escala (SILog) en los modelos de estimación de profundidad; es el término principal que determina la precisión de la profundidad. |
dgrad | float | 0.5 | Peso de la pérdida de gradiente en los modelos de estimación de profundidad, que penaliza los errores en los bordes de profundidad y favorece límites de superficie más definidos. |
dlam | float | 1.0 | Factor de énfasis de la varianza de la pérdida SILog en los modelos de estimación de profundidad. 1.0 hace que la pérdida sea totalmente invariante a la escala, mientras que 0.0 la reduce a un RMSE logarítmico simple. |
nbs | int | 64 | Tamaño de lote nominal. Los gradientes se acumulan durante round(nbs / batch) lotes por paso del optimizador (como mínimo 1 y, fuera del modo time, como máximo el número total de lotes de la ejecución), y weight_decay se escala mediante batch * accumulate / nbs para ajustarse. |
overlap_mask | bool | True | Determina si las máscaras de los objetos deben combinarse en una sola máscara para el entrenamiento o mantenerse separadas para cada objeto. Si hay solapamiento, al combinarlas se superpone la máscara más pequeña sobre la más grande. |
mask_ratio | int | 4 | Proporción de submuestreo de las máscaras de segmentación, que afecta a la resolución de las máscaras usadas durante el entrenamiento. No modifica la resolución de las máscaras predichas. |
dropout | float | 0.0 | Tasa de abandono para la regularización en tareas de clasificación; evita el sobreajuste omitiendo unidades aleatoriamente durante el entrenamiento. |
val | bool | True | Activa la validación durante el entrenamiento para evaluar periódicamente el rendimiento del modelo con un conjunto de datos independiente. |
split | str | 'val' | Conjunto de datos usado para la validación durante el entrenamiento: val, test o train. Sus métricas seleccionan best.pt y activan la parada temprana. |
nms | bool, opcional | None | Selecciona la cabeza de inferencia que se usa para validar cada época, seleccionar puntos de control y detener el entrenamiento de forma anticipada. None o True usa una relación uno-a-muchos con NMS; False usa la cabeza sin NMS cuando está disponible. Ambas cabezas conservan sus pérdidas de entrenamiento. |
plots | bool | True | Genera y guarda gráficos de las métricas de entrenamiento y validación, así como ejemplos de predicciones, para ofrecer una visión visual del rendimiento del modelo y de su evolución durante el aprendizaje. |
compile | bool o str | False | Activa la compilación de grafos torch.compile de PyTorch 2.x con backend='inductor'. Acepta True → "default" para activarla, False → para desactivarla o un modo de cadena como "default", "reduce-overhead", "max-autotune-no-cudagraphs". Si no es compatible, vuelve al modo eager y muestra una advertencia. |
channels_last | bool | None | Usa el formato de memoria channels_last (NHWC) para las convoluciones durante el entrenamiento. None lo activa automáticamente en CUDA con PyTorch 1.11 o versiones posteriores, excepto en Windows, donde se ha medido un rendimiento más lento. False lo desactiva y True lo solicita explícitamente. El entrenamiento en CPU o MPS siempre mantiene el formato NCHW (True se ignora y se muestra una advertencia). |
max_det | int | 300 | Número máximo de detecciones por imagen durante la validación del entrenamiento. Para detect, segment, pose y OBB, el valor predeterminado de 300 aumenta hasta el número más alto de objetos etiquetados en train/val solo cuando ese número supera 300. Los demás valores permanecen fijos; si se supera el límite, se muestra una advertencia. |
El argumento batch admite tres tipos de valores, y el entrenador añade dos medidas de protección:
- Tamaño fijo de tamaño de lote: Establece un valor entero (p. ej.,
batch=16) que especifique directamente el número de imágenes por lote. El entrenamiento con varias GPU divide este lote global equitativamente entre las GPU, por lo que debe ser como mínimo igual al número de GPU; el resto se descarta (p. ej., conbatch=15en 2 GPU, se entrenan 7 imágenes por GPU). - Modo automático (60 % de la memoria GPU): Usa
batch=-1para ajustar automáticamente el tamaño del lote a aproximadamente el 60 % de la memoria CUDA disponible para el entrenamiento. - Modo automático con una fracción de uso: Establece un valor de fracción (p. ej.,
batch=0.70) para ajustar el tamaño del lote según la fracción especificada de la memoria GPU disponible. - Reintento automático por falta de memoria (OOM): si se produce un error de falta de memoria de CUDA durante la primera época, el entrenador reduce automáticamente a la mitad el tamaño del lote y vuelve a intentarlo (hasta 3 veces). Esto solo se aplica al entrenamiento con una sola GPU; el entrenamiento con varias GPU (DDP) generará el error inmediatamente.
- No se encuentra un tamaño adecuado: Si ningún tamaño de lote candidato genera un perfil válido, AutoBatch produce un
RuntimeErrorclaro en lugar de recurrir silenciosamente a un valor predeterminado no relacionado.
Ajustes y hiperparámetros de aumento de datos#
Las técnicas de aumento de datos son esenciales para mejorar la robustez y el rendimiento de los modelos YOLO, ya que introducen variabilidad en los datos de entrenamiento y ayudan al modelo a generalizar mejor ante datos no vistos. En la tabla siguiente se describe el propósito y el efecto de cada argumento de aumento:
| Argumento | Tipo | Predeterminado | Tareas compatibles | Intervalo | Descripción |
|---|---|---|---|---|---|
hsv_h | float | 0.015 | detect, segment, semantic, depth, classify, pose, obb | 0.0 - 1.0 | Ajusta el tono de la imagen en una fracción de la rueda de color, lo que introduce variabilidad cromática. Ayuda al modelo a generalizar en distintas condiciones de iluminación. Para classify, solo se aplica cuando auto_augment=None. |
hsv_s | float | 0.7 | detect, segment, semantic, depth, classify, pose, obb | 0.0 - 1.0 | Modifica la saturación de la imagen en una fracción, lo que afecta a la intensidad de los colores. Es útil para simular distintas condiciones ambientales. Para classify, solo se aplica cuando auto_augment=None. |
hsv_v | float | 0.4 | detect, segment, semantic, depth, classify, pose, obb | 0.0 - 1.0 | Modifica el valor (brillo) de la imagen en una fracción, lo que ayuda al modelo a funcionar bien en distintas condiciones de iluminación. Para classify, solo se aplica cuando auto_augment=None. |
degrees | float | 0 | detect, segment, semantic, depth, pose, obb | 0.0 - 180 | Gira la imagen aleatoriamente dentro del intervalo de grados especificado, lo que mejora la capacidad del modelo para reconocer objetos en distintas orientaciones. |
translate | float | 0.1 | detect, segment, semantic, depth, pose, obb | 0.0 - 1.0 | Desplaza la imagen horizontal y verticalmente en una fracción de su tamaño, lo que ayuda al modelo a aprender a detectar objetos parcialmente visibles. |
scale | float | tuple | 0.5 | detect, segment, semantic, depth, classify, pose, obb | 0 - 1 o una tupla (min, max) explícita (no para classify). | Escala la imagen mediante un factor de ampliación, lo que simula objetos situados a distintas distancias de la cámara. |
shear | float | 0 | detect, segment, semantic, depth, pose, obb | -180 - +180 | Cizalla la imagen en los grados especificados, lo que imita el efecto de observar objetos desde distintos ángulos. |
perspective | float | 0 | detect, segment, semantic, depth, pose, obb | 0.0 - 0.001 | Aplica una transformación de perspectiva aleatoria a la imagen, lo que mejora la capacidad del modelo para comprender los objetos en un espacio 3D. |
flipud | float | 0 | detect, segment, semantic, depth, classify, pose, obb | 0.0 - 1.0 | Invierte la imagen verticalmente con la probabilidad especificada, lo que aumenta la variabilidad de los datos sin afectar a las características del objeto. |
fliplr | float | 0.5 | detect, segment, semantic, depth, classify, pose, obb | 0.0 - 1.0 | Invierte la imagen de izquierda a derecha con la probabilidad especificada; es útil para aprender a reconocer objetos simétricos y aumentar la diversidad del conjunto de datos. |
bgr | float | 0 | detect, segment, semantic, depth, pose, obb | 0.0 - 1.0 | Invierte los canales de la imagen de RGB a BGR con la probabilidad especificada; es útil para aumentar la robustez ante un orden incorrecto de los canales. |
mosaic | float | 1 | detect, segment, semantic, pose, obb | 0.0 - 1.0 | Combina cuatro imágenes de entrenamiento en una para simular distintas composiciones de escena e interacciones entre objetos. Es eficaz para comprender escenas complejas. |
mixup | float | 0 | detect, segment, semantic, pose, obb | 0.0 - 1.0 | Mezcla dos imágenes y sus etiquetas para crear una imagen compuesta. Mejora la capacidad del modelo para generalizar al introducir ruido en las etiquetas y variabilidad visual. |
cutmix | float | 0 | detect, segment, semantic, pose, obb | 0.0 - 1.0 | Combina partes de dos imágenes para crear una mezcla parcial que mantiene regiones diferenciadas. Mejora la robustez del modelo al crear situaciones de oclusión. |
copy_paste | float | 0 | segment, semantic, obb | 0.0 - 1.0 | Fracción de objetos aptos que se pegan; flip los refleja dentro de la imagen, mientras que mixup también utiliza el valor como probabilidad de aplicación entre imágenes. |
copy_paste_mode | str | flip | segment, semantic, obb | - | Especifica la estrategia de copy-paste que se va a utilizar. Las opciones incluyen 'flip' y 'mixup'. |
auto_augment | str | randaugment | classify | - | Aplica una política de aumento predefinida ('randaugment', 'autoaugment' o 'augmix') para mejorar el rendimiento del modelo mediante la diversidad visual. |
erasing | float | 0.4 | classify | 0.0 - 1.0 | Borra aleatoriamente regiones de la imagen durante el entrenamiento para animar al modelo a centrarse en características menos evidentes. |
augmentations | list | None | detect, segment, semantic, depth, pose, obb | - | Transformaciones personalizadas de Albumentations para el aumento de datos avanzado (solo API de Python). Acepta una lista de objetos de transformación para necesidades de aumento especializadas. |
Puedes ajustar estos parámetros para adaptarlos a los requisitos específicos del conjunto de datos y de la tarea. Probar distintos valores puede ayudarte a encontrar la mejor estrategia de aumento.
Para obtener más información sobre las operaciones de aumento de datos durante el entrenamiento, consulta la sección de referencia.
Registro#
Las métricas, los gráficos y los puntos de control del entrenamiento siempre se escriben en el directorio de ejecución. Además, Ultralytics también los transmite a cualquier sistema de seguimiento de experimentos que tengas instalado y activado: Comet, ClearML, TensorBoard, MLflow, Weights & Biases y DVCLive. Cada registrador se activa o desactiva desde los ajustes de Ultralytics, por ejemplo, con yolo settings tensorboard=True. A continuación se muestran las tres configuraciones más habituales.
Comet#
Comet es una plataforma que permite a científicos de datos y desarrolladores hacer un seguimiento de los experimentos y modelos, compararlos, explicarlos y optimizarlos. Proporciona métricas en tiempo real, diferencias de código y seguimiento de hiperparámetros.
Para usar Comet:
# pip install comet_ml
import comet_ml
comet_ml.login()Recuerda iniciar sesión en tu cuenta de Comet en su sitio web y obtener tu clave API. Tendrás que añadirla a las variables de entorno o al script para registrar tus experimentos.
ClearML#
ClearML es una plataforma de código abierto que automatiza el seguimiento de experimentos y facilita el uso compartido eficiente de recursos. Está diseñada para ayudar a los equipos a gestionar, ejecutar y reproducir su trabajo de aprendizaje automático de forma más eficiente.
Para usar ClearML:
# pip install clearml
import clearml
clearml.browser_login()Después de ejecutar este script, tendrás que iniciar sesión en tu cuenta de ClearML desde el navegador y autenticar la sesión.
TensorBoard#
TensorBoard es un conjunto de herramientas de visualización para TensorFlow. Te permite visualizar tu grafo de TensorFlow, representar métricas cuantitativas sobre la ejecución del grafo y mostrar datos adicionales, como las imágenes que lo atraviesan.
Para usar TensorBoard en Google Colab:
%load_ext tensorboard
tensorboard --logdir ultralytics/runs # replace with 'runs' directoryPara utilizar TensorBoard localmente, ejecuta el comando siguiente y consulta los resultados en localhost:6006.
tensorboard --logdir ultralytics/runs # replace with 'runs' directoryEsto cargará TensorBoard y lo dirigirá al directorio donde se guardan los registros de entrenamiento.
Después de configurar el registrador, inicia el entrenamiento como de costumbre. Las métricas se registran automáticamente en la plataforma que hayas elegido, donde puedes supervisar el rendimiento a lo largo del tiempo, comparar modelos e identificar aspectos que mejorar.
Qué hacer a continuación#
Valida tu modelo entrenado con datos reservados para comprobar su precisión en condiciones reales y, después, expórtalo a ONNX, TensorRT u otro formato de implementación. ¿Vas a entrenar con tus propios datos en lugar de COCO8? Dales formato primero con la guía de conjuntos de datos.
Preguntas frecuentes#
Sí. El entrenamiento en la nube de Ultralytics Platform incluye créditos gratuitos para empezar. Sube tu conjunto de datos, elige un modelo y una GPU, y entrena directamente desde el navegador.
Para entrenar un modelo de detección de objetos con Ultralytics YOLO26, puedes usar la API de Python o la CLI. A continuación se muestra un ejemplo de cada opción:
Ejemplo de entrenamiento con una sola GPU y con CPUfrom ultralytics import YOLO # Cargar un modelo model = YOLO("yolo26n.pt") # Carga un modelo preentrenado (recomendado para el entrenamiento) # Entrenar el modelo results = model.train(data="coco8.yaml", epochs=100, imgsz=640)Para obtener más información, consulta la sección Ajustes de entrenamiento.
Entre las principales características del modo Train de Ultralytics YOLO26 se incluyen:
- Descarga automática de conjuntos de datos: descarga automáticamente conjuntos de datos estándar como COCO, VOC e ImageNet.
- Compatibilidad con varias GPU: amplía el entrenamiento a varias GPU para procesarlo más rápido.
- Configuración de hiperparámetros: personaliza los hiperparámetros mediante archivos YAML o argumentos de la CLI.
- Visualización y supervisión: seguimiento en tiempo real de las métricas de entrenamiento para obtener información más útil.
Estas funciones hacen que el entrenamiento sea eficiente y se pueda adaptar a tus necesidades. Para obtener más información, consulta la sección Características principales del modo Train.
Para reanudar el entrenamiento desde una sesión interrumpida, establece el argumento
resumeenTruey especifica la ruta al último punto de control guardado.Ejemplo de reanudación del entrenamientofrom ultralytics import YOLO # Cargar el modelo entrenado parcialmente model = YOLO("path/to/last.pt") # Reanudar el entrenamiento results = model.train(resume=True)Consulta la sección sobre cómo reanudar entrenamientos interrumpidos para obtener más información.
El desequilibrio de clases se produce cuando algunas clases tienen muchos menos ejemplos que otras en los datos de entrenamiento. Esto puede hacer que el modelo tenga un rendimiento deficiente con las clases poco frecuentes. Ultralytics YOLO admite la ponderación de clases mediante el argumento
cls_pwpara resolver este problema. La ponderación de la pérdida funciona mejor como último paso, después de recopilar y sobremuestrear las clases poco frecuentes, tal como se describe en Cómo gestionar el desequilibrio de clases.El argumento
cls_pwcontrola el grado de ponderación de clases según la frecuencia inversa de cada clase:cls_pw=0.0(valor predeterminado): desactiva la ponderación de clasescls_pw=1.0: aplica una ponderación completa según la frecuencia inversa- Los valores entre
0.0y1.0proporcionan una ponderación parcial para desequilibrios moderados
Los pesos de clase se calculan como
(1.0 / class_counts) ^ cls_pwy se normalizan para que su media sea igual a 1.0.class_countses el número de objetos etiquetados por clase, o el número de imágenes de entrenamiento por clase en tareas de clasificación, y las clases sin etiquetas de entrenamiento, como las excluidas porclasses=, reciben un peso de 1.0. En la segmentación semántica, los pesos se calculan a partir de la frecuencia de píxeles, como(1.0 / ln(1.02 + p)) ^ cls_pw, dondepes la proporción de píxeles de entrenamiento etiquetados de cada clase, por lo que una clase sin píxeles etiquetados recibe el peso más alto.Entrenamiento con un conjunto de datos desequilibradofrom ultralytics import YOLO # Cargar un modelo preentrenado model = YOLO("yolo26n.pt") # Entrenar con ponderación completa de clases para datos muy desequilibrados results = model.train(data="custom.yaml", epochs=100, imgsz=640, cls_pw=1.0) # O usar ponderación parcial (0.25) para un desequilibrio moderado results = model.train(data="custom.yaml", epochs=100, imgsz=640, cls_pw=0.25)ConsejoEmpieza con
cls_pw=0.25para conjuntos de datos moderadamente desequilibrados y aumenta el valor a1.0si las clases poco frecuentes siguen teniendo un rendimiento deficiente. Puedes consultar los pesos de clase calculados en los registros de entrenamiento para verificar la distribución de pesos.Sí, Ultralytics YOLO26 admite el entrenamiento en chips Apple silicon mediante el framework Metal Performance Shaders (MPS). Especifica
mpscomo dispositivo de entrenamiento.Ejemplo de entrenamiento con MPSfrom ultralytics import YOLO # Cargar un modelo preentrenado model = YOLO("yolo26n.pt") # Entrenar el modelo en un chip Apple silicon (M1/M2/M3/M4) results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")Para obtener más información, consulta la sección Entrenamiento con Apple Silicon y MPS.
Ultralytics YOLO26 te permite configurar diversos ajustes de entrenamiento mediante argumentos, como el tamaño del lote, la tasa de aprendizaje, las épocas y otros. Aquí tienes un breve resumen:
Argumento Predeterminado Descripción modelNoneRuta al archivo del modelo que se va a entrenar. dataNoneRuta al archivo YAML del conjunto de datos (p. ej., coco8.yaml) o un directorio o nombre de conjunto de datos (p. ej.,imagenet10) para clasificación.epochs100Número total de épocas de entrenamiento. batch16Tamaño del lote, que se puede ajustar con un valor entero o en modo automático. imgsz640Tamaño objetivo de las imágenes para el entrenamiento. deviceNoneDispositivo o dispositivos para el entrenamiento, como cpu,0,0,1omps.saveTrueActiva el guardado de los puntos de control del entrenamiento y de los pesos del modelo final. Para obtener una guía detallada sobre los ajustes de entrenamiento, consulta la sección Ajustes de entrenamiento.
Comentarios1074
Haz una pregunta, comparte tus resultados o ayuda a otra persona.
drcosimo
Hi there, I' m new to this field and I'm trying to train a YOLO model for detection and tracking of video streams for security.
Until now I have managed to create my pipeline for training and I want to understand if it's a correct/possible approach:
-
Load a pretrained model from yolo
-
transfer learning with my custom dataset that possibly can focus on just some classes(person,car,truck,bus,bycicle)
-
Validate model to see how it performs
-
Operate a tuning with the custom best model and using my custom dataset
-
Retrain the initial pretrained model with my custom dataset and the best hyperparameters found in the tuning process.
-
Validate final model
The questions are several:
- The above approach is logically correct or it has flaws?
- Is it correct to narrow the detected classes? Or it isn't crucial to the precision of the model?
- When tuning(if its a correct approach) should i use my dataset or try the coco dataset to keep generalization?
- When tuning should i specify the classes to detect?
- When retraining should I use the first pretrained model or it is better to use my custom trained model?
- In the final training am I using the correct parameters?
Here the code of the pipeline:
from ultralytics import YOLO import yaml
load pretrained model from coco dataset
model:YOLO = YOLO('yolov8n.yaml').load('yolov8n.pt')
train_classes = []
NOTE if you're using COCO format, the new dataset should also be in COCO format.
operate transfer learning with my custom dataset, narrowing the classes to the ones I want to detect
model.train(data='custom_data.yaml',classes=train_classes,epochs=200,imgsz=640,optimizer='AdamW',device=[0,1],augment=True,name='custom_model')
load custom model
custom_model = YOLO('path/to/best.pt')
validate custom model
custom_model.val()
try tuning to find the best hyperparameters for my custom model
custom_model.tune(data='custom_data.yaml', epochs=50, iterations=100,optimizer="AdamW", plots=True,save=True,val=True)
load best hyperparameters
cfg = yaml.load(open('path/to/best_hyperparameters.yaml'))
retrain custom model from pretrained on coco with best hyperparameters
model.train(data='custom_data.yaml',classes=train_classes,epochs=200,imgsz=640,device=[0,1],name='custom_model',exist_ok=True,optimizer='AdamW',**cfg)
load and validate
tuned_custom_model = YOLO('path/to/best.pt')
tuned_custom_model.val()
Thank you for your effort and time in this project!
3
Paula DerrengerUltralytics(editado)Hello,
Your approach to training a YOLO model for detection and tracking is well-thought-out and mostly aligns with best practices. Here are some insights and answers to your questions:
-
Approach Validity: Your steps are logically sound. Starting with a pretrained model and applying transfer learning to your specific classes is a recommended strategy. Validating and tuning based on the performance helps refine the model further.
-
Narrowing Detected Classes: It's perfectly fine to focus on specific classes if those are the only ones relevant to your use case. This can help improve the model's performance by reducing the complexity of the problem it needs to solve.
-
Dataset for Tuning: Use your custom dataset for tuning. This ensures that the hyperparameters are optimized for the specific characteristics of your data rather than the general characteristics of the COCO dataset.
-
Specifying Classes During Tuning: When tuning, you should specify the classes if your dataset is a subset of the original classes used in the pretrained model. This helps in focusing the model’s learning and evaluation on relevant classes.
-
Model for Retraining: Tuning only finds hyperparameters, so the usual practice is to train again from the original pretrained model with the best hyperparameters, as in your step 5. Continuing from the already fine-tuned model is also possible, but then it effectively trains for longer, which makes the result harder to compare with the tuning runs.
-
Parameters for Final Training: The parameters should be chosen based on the results of your tuning. Ensure that they are the ones that gave the best validation performance during the tuning phase.
Keep up the great work, and don't hesitate to reach out if you have more questions!
-
drcosimo
Thank you very much for you response. I adjusted my script to follow your insights. I have another question regarding transfer learning. The normal approach in transfer learning is to freeze the first n layers to preserve the more generic feature extraction properties of an already trained model and then it is retrained letting only the remaining layers update. I found the callback function to achieve this. My question is, applying the fine-tuning as specified by ultralytics documentation has the same effect? What I mean is: executing the train method again on a pretrained model changing the dataset causes the underlying library to execute the freeze automatically? If it isn't the case it is not clear to me why the fine-tuning is said to have the same effect as applying transfer learning.
Another question is: it is useful to take a pretrained model from ultralytics and train it with the coco dataset? Because from what I know the pretrained model is already trained using coco dataset. Doing such a thing following the logic you provide for fine-tuning would be essentially the same as resuming a training / do the same train with more epochs?
Thank you again for your time.
Paula DerrengerUltralyticsHello,
Thank you for your follow-up questions. Let's address each of them:
-
Freezing Layers in Transfer Learning: The Ultralytics YOLO framework does not automatically freeze any layers when you initiate training, even if you're using a pretrained model. If you want to freeze the first N layers (common in transfer learning to preserve learned features), you must explicitly specify this in your training script. This is different from some other frameworks that might automate this aspect of transfer learning.
-
Training on COCO Dataset with a Pretrained Model: If the pretrained model you are using was already trained on the COCO dataset, retraining it on the same dataset without significant changes or additional data might not yield substantial improvements. It could be beneficial for fine-tuning if you've made modifications to the model architecture or if you're using a significantly altered version of the dataset. However, generally, this approach would indeed be akin to simply extending the training duration.
For fine-tuning and transfer learning, it's crucial to tailor the approach based on what changes you've made to the dataset or model and your specific goals (e.g., improving accuracy, adapting to new classes, etc.).
I hope this clarifies your queries! If you have more questions or need further assistance, feel free to ask.
-
-
wangztao
这个翻译太那啥了吧, train翻译成火车?
3
Paula DerrengerUltralytics哈哈,确实,“train”翻译成“火车”听起来很有趣 😄。这里的“train”应该翻译为“训练”,指的是在机器学习中对模型进行训练,以提高其准确性和效率。感谢您指出这个问题,我们会尽快修正翻译错误。如果您有任何其他建议或问题,欢迎随时告诉我们!🚀
2
Syedshajib55
Hi, does platform.ultralytics currently support using custom PyTorch modules directly via a YAML configuration without modifying tasks.py or the core source code? We are attempting to train a custom architecture (e.g., YOLO26) and want to know if there is an existing feature for dynamic module registration.
1Muh-7
Hi, As far as I know, not at the moment. Ultralytics doesn't seem to have a built-in dynamic registration system where you can define a custom PyTorch module outside the repo and then use it directly in the YAML.
Usually, the custom module still needs to be imported/registered in
tasks.pyso thatparse_model()can resolve it from the YAML.It would be really useful if Ultralytics added something like a
register_module()API for this, though.
Murat Raimbekov@Syedshajib55 @Muh-7 Platform can train any model that the
ultralyticsPython package can build, including custom architectures from a modified package or fork. The custom code runs on your own hardware; Platform receives real-time metrics, console and system logs, plots, and the final weights.There is no dynamic registration API.
parse_model()resolves layer names from theultralytics.nn.tasksnamespace, so a name in your YAML must exist there. You don't need to edittasks.pyfor that — expose the class from your own package before building the model:import ultralytics.nn.tasks as tasks from my_custom_package import MyBlock tasks.MyBlock = MyBlock # now `[-1, 1, MyBlock, [...]]` resolves in the YAMLFull local training with metric streaming to Platform:
pip install "ultralytics>=8.4.120" export ULTRALYTICS_API_KEY="YOUR_API_KEY"import ultralytics.nn.tasks as tasks from my_custom_package import MyBlock from ultralytics import YOLO tasks.MyBlock = MyBlock model = YOLO("custom-model.yaml") # YAML referencing MyBlock model.train( data="ul://username/datasets/my-dataset", epochs=100, project="username/my-project", name="custom-architecture", )projectandnameenable the Platform integration automatically; nothing else is required. Verified on 8.4.157 with a customnn.Moduleinserted into a YOLO26n YAML: the model builds, trains, and appears on Platform as a completed run with weights and train args.One caveat: the saved
.ptpickles the class by import path (my_custom_package.MyBlock), so any environment that loads it needs that package importable — otherwise loading fails withModuleNotFoundError. That includes Platform-side features that load the uploaded weights with the stock package (Predict, Export, Deploy); local training and streaming are unaffected. Setup details: https://docs.ultralytics.com/platform/train/cloud-training/#remote-training
RussellLee12345
Hello all,
I want my training images to rotate 360 degrees randomly. How do I set the hyper-parameter: degrees?
Thanks a lot.
1
Glenn JocherUltralytics@RussellLee12345 to rotate your training images randomly up to 360 degrees, set the
degreesparameter to180in your training configuration. This allows for rotations within the range of -180 to +180 degrees. For more details, see the augmentation settings in the Train Settings documentation.
GKYoffice
Please tell me how to set imgsz when I use the yolo11 model for training. Can it only be an integer (this means that the final input is a square)? After I modify this parameter, will the input interface of the network change the input of data? There are corresponding transformations, such as imgsz=1280, does it mean that my input data will be resized to 1280*1280 and input into the network for training?
Thanks!
1
Glenn JocherUltralytics@GKYoffice when using the YOLO11 model,
imgszcan be set as an integer, which resizes the input data to a square of that size (e.g.,1280x1280). This parameter adjusts the input dimensions for training. For more details, please visit the training documentation.
IruhDegSet
hi, I'm just wondering if yolov8 accepts class weights, in the data.yaml file:
names: ['class 1', 'class 2', 'class 3'] classes_weights: [c1_weight, c2_weight, c3_weight]if no how to incorpoorate wighted loss in yolov8 THX
1IruhDegSet
I forgot to mention that the task is segmentation not bb detection
1
Glenn JocherUltralytics@IruhDegSet yOLOv8 does not directly support class weights in the
data.yamlfile. To incorporate weighted loss, you can modify the loss function in the training script to apply different weights to each class. For more details, you might explore custom loss implementations in PyTorch.IruhDegSet
@glenn-jocher thank you for your reply, does this apply on yolo v 11 too?
Glenn JocherUltralytics(editado)Yes, YOLO11 supports similar features, including training and hyperparameter customization. For specific details on YOLO11, please refer to the documentation or the relevant sections in the repository.
UserDear author, how are the weights of these three losses set: box: 7.5, cls: 0.5, dfl: 1.5? Are they adjusted on the COCO validation, manually adjusted, or obtained through hyperparameter search? For the model I trained, the output confidence scores are very low. I directly increased the weight of cls by 10 times, but the effect did not improve. What other methods can I take?
1
Glenn JocherUltralytics@Stephen-Hao the weights for the
box,cls, anddfllosses in YOLOv8 are typically set based on empirical results and fine-tuning on standard datasets like COCO. These values are chosen to balance the contributions of each loss component to the overall training process. If increasing theclsweight did not improve your model's performance, consider the following approaches:- Hyperparameter Tuning: Experiment with other hyperparameters such as learning rate, batch size, and augmentation settings.
- Data Quality: Ensure your dataset is well-labeled and balanced. Poor quality data can significantly affect model performance.
- Training Duration: Increase the number of epochs to allow the model more time to learn.
- Validation: Regularly validate your model to monitor overfitting and adjust training strategies accordingly.
For more detailed guidance, you can refer to the Ultralytics YOLO training documentation.
UserThank you a lot!
Glenn JocherUltralytics@Stephen-Hao thank you for your question! The weights for
box,cls, anddfllosses are typically set based on empirical results and fine-tuning on standard datasets like COCO. If increasing theclsweight didn't improve your model's performance, consider experimenting with other hyperparameters such as learning rate, batch size, and augmentation settings. Additionally, ensure your dataset is well-labeled and balanced. For more detailed guidance, you can refer to the Ultralytics YOLO training documentation.
karthikUthaman
how to train a trained model again with new dataset
1
Glenn JocherUltralytics(editado)Hey there! 🙌 It's awesome that you're looking to further improve your model with new data. To re-train a pre-trained model on a new dataset, you can simply follow these steps:
-
Make sure your new dataset is prepared in the same YOLO format as your initial training (a dataset YAML plus one
.txtlabel file per image). -
Load your pre-trained model using the
YOLOloading method, then specify your new dataset in thetrainmethod. Here's a quick code snippet for clarity:from ultralytics import YOLO # Load your pre-trained model model = YOLO('path/to/your/pretrained/model.pt') # Start training on the new dataset results = model.train(data='path/to/your/new/dataset.yaml', epochs=50, imgsz=640)
Just replace
'path/to/your/pretrained/model.pt'and'path/to/your/new/dataset.yaml'with the actual paths to your model and new dataset config file, respectively. Adjust theepochsandimgsz(image size) to suit your needs. 🛠️That's it! Your model will now continue training on the new dataset. If you have any further questions or run into issues, feel free to ask. Happy training! 🚀
-
songziang182
谢谢你们开发了这么完善的 yolov8🙏, 我想问一下,这两种训练方式的区别 model = YOLO('yolov8n.pt') model = YOLO('yolov8n.yaml').load('yolov8n.pt') model.train(.........)
1
Paula DerrengerUltralyticsHello there! 😊
The main difference between the two training methods you've mentioned:
-
model = YOLO('yolov8n.pt'): This directly loads a pretrained YOLOv8n model. It's the simplest way to load a model that has already been trained, making it ready for further training, evaluation, or inference right away. -
model = YOLO('yolov8n.yaml').load('yolov8n.pt'): This approach builds a new model from the YAML configuration file and then transfers the weights from the pretrained.ptmodel. It's a two-step process, where the model is first constructed based on the architecture defined in the YAML file, and then the weights from a pretrained model are loaded. This method is useful when you want to customize the model architecture before loading the weights.
Both methods ultimately get you to a similar starting point for continuing training or making predictions. The choice depends on whether you need to customize the model architecture as defined in the YAML file before applying the pretrained weights.
Let me know if this helps or if you have more questions!
-
songziang182
Thank you for answering me. I find it very useful. I have another question, which is the configuration file yolov8n.yaml. I didn’t find where it is. Can I adjust the scale of the model, for example, n, s, m, l, etc., is this the case?
Paula DerrengerUltralytics(editado)Hey! 😊 Thank you for your kind words, and I'm glad the information was helpful to you!
Regarding the
yolov8n.yamlconfiguration file, it defines the architecture for YOLOv8 models. All scales share one model file (yolov8.yaml) that contains ascalessection mapping each letter to[depth, width, max_channels]; the letter in the name you load (yolov8n.yaml,yolov8s.yaml, ...) selects the scale:scales: n: [0.33, 0.25, 1024] s: [0.33, 0.50, 1024]To create or modify a model, copy the YAML from the Ultralytics GitHub repository, edit the layers or scales, then load it together with the pretrained weights as you mentioned:
model = YOLO('path/to/custom_yolov8.yaml').load('yolov8n.pt') model.train(.........)Model changes can require a solid understanding of the network architecture to be effective.
I hope this clarifies your question! Feel free to reach out if you have further queries or need more examples. 😊
vonzo
So, imgsz works different when training than when predicting?
For train: if it's an
intthe ratio will be kept and the train function will take care of that (can't be atuple). For predict: if it's anintthe image will be resized as a square of sizeimgsz x imgsz, if it's atuplethe image will be resized usingHxWand the user has to take care of the ratio andstride.Is this right? I would add a comment in the doc to avoid confusions
1
Paula DerrengerUltralytics(editado)You've got it mostly right! 👍 For training (
train),imgszis anint, the aspect ratio is maintained and resizing is handled internally. It can't be atuple. For prediction (predict), anintimgszresizes the longest side toimgszwhile keeping the aspect ratio, with padding only up to a multiple of the model stride (so the image is not forced into a square), and a[h, w]list sets the size explicitly.Great suggestion on the documentation comment – clarity is key! If you have any more questions or need further examples, feel free to ask. 😊
