Entrenamiento en la nube#
Ultralytics Platform ofrece entrenamiento en la nube con un solo clic en GPU, para que puedas entrenar modelos sin configuraciones complejas. Entrena modelos YOLO con transmisión de métricas en tiempo real y guardado automático de puntos de control.
graph LR
A[Configure]:::start --> B[Start Training]:::proc
B --> C[Provision GPU]:::proc
C --> D[Download Dataset]:::proc
D --> E[Train]:::proc
E --> F[Stream Metrics]:::proc
F --> G[Save Checkpoints]:::proc
G --> H[Complete]:::out
classDef start fill:#4CAF50,color:#fff
classDef proc fill:#2196F3,color:#fff
classDef out fill:#9C27B0,color:#fffCuadro de diálogo de entrenamiento#
Empieza a entrenar desde la interfaz de la plataforma haciendo clic en Nuevo modelo en cualquier página de proyecto o conjunto de datos. El cuadro de diálogo de entrenamiento tiene dos pestañas: Entrenamiento en la nube y Entrenamiento local. Si el conjunto de datos seleccionado está en un host On Premise, la primera pestaña pasa a llamarse On Premise y la pestaña Entrenamiento local queda oculta: ese conjunto de datos solo se puede usar para entrenar en su propio host, lo que requiere un plan Enterprise y un worker conectado y en línea.

El cuadro de diálogo recuerda, para cada tarea del conjunto de datos y espacio de trabajo en el navegador actual, el modelo base y los parámetros no predeterminados que tenía la última vez que lo cerraste, y los restaura la próxima vez que lo abras para esa tarea. No recuerda la selección de GPU, y Reintentar entrenamiento en una ejecución fallida restaura los argumentos propios de esa ejecución.
Paso 1: selecciona el modelo base#
Elige un modelo oficial de Ultralytics o uno de tus propios modelos completados:
| Pestaña | Descripción |
|---|---|
| Oficiales | Modelos de los proyectos YOLO26 (recomendado), YOLO11, YOLOv8 y YOLOv5 |
| Mis modelos | Tus modelos completados o subidos, agrupados por proyecto, para ajustarlos |
En cada pestaña, los modelos se agrupan por tarea en el orden canónico y se ordenan por tamaño. Ambas pestañas solo muestran los modelos cuya tarea permite entrenar con el conjunto de datos seleccionado. YOLO26 incluye variantes de detección, segmentación, semántica, profundidad, clasificación, pose y OBB, en tamaños desde nano hasta xlarge.
Los conjuntos de datos de profundidad se pueden subir con etiquetas NPY float en metros o etiquetas PNG uint16 usando el depth_scale del conjunto de datos. Consulta el formato de los conjuntos de datos de profundidad. Los modelos de profundidad usan de forma predeterminada una receta de ajuste fino (optimizer: AdamW, lr0: 0.0001, warmup_bias_lr: 0.0001), salvo que configures esos parámetros tú mismo.
Paso 2: selecciona el conjunto de datos#
Elige un conjunto de datos para entrenar (consulta Conjuntos de datos):
| Opción | Descripción |
|---|---|
| Oficiales | Conjuntos de datos seleccionados por Ultralytics |
| Mis conjuntos de datos | Conjuntos de datos de tu espacio de trabajo |
Los conjuntos de datos deben tener el estado ready, incluir al menos 1 imagen en la partición de entrenamiento, 1 imagen en la partición de validación o prueba, al menos 1 imagen etiquetada y al menos un nombre de clase. Además, en los conjuntos de datos de clasificación la imagen de la partición de entrenamiento debe estar etiquetada, y los conjuntos de datos de pose deben definir una forma de puntos clave. En cambio, los conjuntos de datos de profundidad requieren un mapa emparejado en train y dos en val; las imágenes sin emparejar se excluyen.
Aparece una advertencia de incompatibilidad de tareas cuando el modelo seleccionado no puede entrenar con la tarea del conjunto de datos, y Iniciar entrenamiento permanece desactivado hasta que elijas un modelo compatible. Un conjunto de datos de segmentación admite modelos de segmentación o semánticos; las demás tareas de conjuntos de datos requieren un modelo con la tarea correspondiente. Consulta las guías de tareas.
Paso 3: configura los parámetros#
Configura los parámetros básicos del entrenamiento:
| Parámetro | Descripción | Predeterminado |
|---|---|---|
| Épocas | Número de iteraciones de entrenamiento (1-10000) | 100 |
| Tamaño del lote | Muestras por iteración (-1 ajusta automáticamente el valor a la VRAM disponible, o bien indica un número fijo de imágenes) | -1 (automático) |
| Tamaño de imagen | Control deslizante de resolución de entrada, de 32 a 1280 en pasos de 32 | 640 |
| Nombre | Nombre opcional para la ejecución de entrenamiento | automático |
Los valores introducidos fuera del intervalo permitido para un parámetro se limitan a ese intervalo cuando el campo pierde el foco.
El control deslizante llega hasta 1280, pero el editor YAML admite tamaños de hasta 4096. Por encima de 1280 aparece una advertencia, porque las resoluciones mayores aumentan considerablemente el uso de memoria de GPU, el tiempo de entrenamiento y el coste.
Paso 4: configuración avanzada (opcional)#
Despliega Configuración avanzada para acceder al editor de parámetros basado en YAML, con más de 50 parámetros de entrenamiento en las secciones Configuración del entrenamiento y Aumentos de imagen (consulta la referencia de configuración):
| Grupo | Parámetros |
|---|---|
| Tasa de aprendizaje | lr0, lrf, momentum, weight_decay, warmup_epochs, warmup_momentum, warmup_bias_lr |
| Optimizador | auto (predeterminado), SGD, MuSGD, Adam, AdamW, NAdam, RAdam, RMSProp, Adamax |
| Pesos de pérdida | box, cls, cls_pw, dfl, pose, kobj, rle, angle, dlog, dgrad, dlam |
| Aumento de color | hsv_h, hsv_s, hsv_v |
| Aumento geométrico | degrees, translate, scale, shear, perspective |
| Aumento de volteo y mezcla | flipud, fliplr, mosaic, mixup, copy_paste, bgr, cutmix, copy_paste_mode, auto_augment, erasing |
| Control del entrenamiento | epochs, batch, imgsz, pretrained, patience, seed, deterministic, amp, cos_lr, compile, close_mosaic, save_period, nbs, cls_remap, channels_last, profile, overlap_mask, mask_ratio |
| Conjunto de datos | fraction, freeze, single_cls, rect, multi_scale, resume |
| Validación | max_det |
Los parámetros se adaptan a la tarea (p. ej., copy_paste solo se muestra para las tareas de segmentación, semántica y OBB; pose/kobj solo se muestran para las tareas de pose; auto_augment/erasing solo se muestran para las tareas de clasificación). El editor omite device, cache, workers, iou, dropout, val y time, y los ignora en las configuraciones pegadas o arrastradas; configúralos en tu propio comando yolo train cuando entrenes en local. Aparece una insignia Modificado cuando los valores difieren de los predeterminados, y puedes restablecer todos los valores predeterminados con el botón de restablecimiento. Solo se envían al trabajo de entrenamiento los valores avanzados que no sean predeterminados (los parámetros básicos epochs, batch y tamaño de imagen siempre se incluyen), por lo que el comando resultante sigue siendo legible.
Ejemplo: ajustar la aumentación para conjuntos de datos pequeños
Para conjuntos de datos pequeños (<1000 imágenes), aumenta la aumentación para reducir el sobreajuste:
mosaic: 1.0 # Keep mosaic on
mixup: 0.3 # Add mixup blending
copy_paste: 0.3 # Add copy-paste (segment, semantic, OBB)
fliplr: 0.5 # Horizontal flip
degrees: 10.0 # Slight rotation
scale: 0.9 # Aggressive scalingGuardar versión del conjunto de datos (opcional)#
Activa Guardar versión del conjunto de datos para vincular el modelo a una versión inmutable de un conjunto de datos alojado en la plataforma. La plataforma comprueba si el contenido del conjunto de datos ha cambiado, reutiliza una versión coincidente si no ha cambiado y solo crea una nueva versión numerada cuando es necesario. A continuación, el entrenamiento usa esa instantánea exacta en formato NDJSON y registra en el modelo el número de versión y el hash del contenido.
Así se conservan los datos usados en la ejecución aunque más adelante añadas o elimines imágenes, edites anotaciones o cambies las divisiones del conjunto de datos. Puedes encontrar la versión vinculada en las pestañas Modelos y Versiones del conjunto de datos.
Guardar versión del conjunto de datos no está disponible para el almacenamiento en la nube conectado ni para los conjuntos de datos locales. También puedes crear instantáneas manualmente desde la pestaña Versiones.
Paso 5: Selecciona una GPU (pestaña Cloud)#
Elige tu GPU en Ultralytics Cloud:

| GPU | Generación | VRAM | Coste/hora | Ideal para |
|---|---|---|---|---|
| RTX 2000 Ada | Ada | 16 GB | $0.24 | Conjuntos de datos pequeños, pruebas |
| RTX A4500 | Ampere | 20 GB | $0.25 | Conjuntos de datos pequeños o medianos |
| RTX 4000 Ada | Ada | 20 GB | $0.26 | Conjuntos de datos medianos |
| RTX A5000 | Ampere | 24 GB | $0.27 | Conjuntos de datos medianos |
| L4 | Ada | 24 GB | $0.39 | Optimizada para inferencia |
| A40 | Ampere | 48 GB | $0.44 | Tamaños de lote mayores |
| RTX 3090 | Ampere | 24 GB | $0.46 | Entrenamiento general |
| RTX A6000 | Ampere | 48 GB | $0.49 | Modelos grandes |
| RTX PRO 4000 | Blackwell | 24 GB | $0.57 | Blackwell económica |
| RTX PRO 4500 | Blackwell | 32 GB | $0.64 | Excelente relación calidad-precio |
| RTX 4090 | Ada | 24 GB | $0.69 | Mejor relación calidad-precio |
| RTX 6000 Ada | Ada | 48 GB | $0.77 | Entrenamiento con lotes grandes |
| L40S | Ada | 48 GB | $0.86 | Entrenamiento con lotes grandes |
| RTX PRO 5000 | Blackwell | 48 GB | $0.96 | Entrenamiento con lotes grandes |
| RTX 5090 | Blackwell | 32 GB | $0.99 | Última generación de consumo |
| L40 | Ada | 48 GB | $0.99 | Modelos grandes |
| A100 PCIe | Ampere | 80 GB | $1.39 | Entrenamiento en producción |
| A100 SXM | Ampere | 80 GB | $1.49 | Entrenamiento en producción |
| RTX PRO 6000 | Blackwell | 96 GB | $2.09 | Opción predeterminada recomendada |
| H100 PCIe | Hopper | 80 GB | $2.89 | Entrenamiento de alto rendimiento |
| H100 NVL | Hopper | 94 GB | $3.19 | Máximo rendimiento |
| H100 SXM | Hopper | 80 GB | $3.29 | Entrenamiento más rápido |
| H200 NVL | Hopper | 143 GB | $3.39 | Memoria máxima |
| H200 SXM | Hopper | 141 GB | $4.39 | Máximo rendimiento |
| B200 | Blackwell | 180 GB | $5.89 | Modelos grandes (Pro+) |
| B300 | Blackwell | 288 GB | $7.39 | Los modelos más grandes (Pro+) |
- RTX PRO 6000: 96 GB Blackwell, opción predeterminada recomendada para la mayoría de los trabajos
- A100 SXM: 80 GB HBM2e — una buena opción para tamaños de lote grandes o modelos más grandes
- H100 PCIe / H100 SXM / H100 NVL: 80–94 GB Hopper para entrenamientos urgentes (disponible en todos los planes)
- H200 NVL / H200 SXM: 141–143 GB Hopper para cargas de trabajo con grandes necesidades de memoria (disponible en todos los planes)
- B200 / B300: 180–288 GB NVIDIA Blackwell para cargas de trabajo de vanguardia; requiere Pro o Enterprise
El cuadro de diálogo muestra tu saldo actual y un botón Añadir fondos. La tarjeta de costes calcula la duración y el precio totales de tu configuración (tamaño del modelo, imágenes del conjunto de datos, epochs, tamaño de imagen, tamaño del lote, optimizador y velocidad de la GPU) e indica también los segundos estimados por epoch y el número de imágenes del conjunto de datos.
El selector de GPU refleja la disponibilidad actual en la nube, por lo que las opciones sin capacidad disponible aparecen marcadas. Si aun así no se puede asignar un trabajo a la GPU que has elegido, la plataforma indica la falta de capacidad y cambia tu selección a la GPU disponible más parecida —primero según la VRAM, después según la velocidad y, por último, según el precio—, y te informa de la nueva VRAM y la tarifa por hora para que puedas empezar de inmediato o elegir otra opción.
Si seleccionas una GPU más barata que la RTX PRO 6000, tu trabajo puede ejecutarse en la infraestructura gestionada por Ultralytics. Cuando hay capacidad disponible, la ejecución se realiza en una RTX PRO 6000, pero se factura según la tarifa de la GPU que has seleccionado, por lo que puede terminar antes y costar menos que si se ejecutara en la GPU seleccionada; la mejora nunca hace que una ejecución sea más lenta ni más cara.
Paso 6: Inicia el entrenamiento#
Haz clic en Iniciar entrenamiento para lanzar el trabajo. La plataforma:
- Resuelve la versión inmutable del conjunto de datos si está activado Guardar versión del conjunto de datos
- Proporciona una instancia de GPU
- Descarga tu conjunto de datos
- Inicia el entrenamiento
- Transmite las métricas en tiempo real
Al volver a entrenar un modelo existente, se reutiliza la misma página del modelo y se borran los gráficos, la salida de la consola, las métricas del sistema y el estado de error de la ejecución anterior una vez creado el nuevo trabajo. Si una ejecución falla antes de que se aprovisionen los recursos de computación, los resultados anteriores no se modifican.
Ciclo de vida del trabajo de entrenamiento#
Los trabajos de entrenamiento pasan por los siguientes estados:
| Estado | Descripción |
|---|---|
| Iniciándose | Trabajo enviado; aprovisionando la GPU y descargando el conjunto de datos y el modelo |
| En ejecución | Entrenamiento en curso; métricas transmitidas en tiempo real |
| Completado | Entrenamiento completado correctamente |
| Error | Error en el entrenamiento (consulta los registros de la consola para obtener más información) |
| Cancelado | El usuario ha cancelado el entrenamiento |
Un error grave de Python en el flujo de la consola —un traceback, un error de memoria insuficiente de CUDA o un fallo al inicializar CUDA— finaliza la ejecución de inmediato, sin esperar a que se agote el tiempo de espera, y el mensaje extraído aparece en un aviso de error en la página del modelo, con las acciones Ver todos los registros de la consola y Reintentar entrenamiento. Las ejecuciones que no notifican actividad durante 4 horas se marcan automáticamente como fallidas y se liberan sus recursos de computación.
Para recibir los resultados de las ejecuciones completadas y fallidas sin dejar esta página abierta, conecta las alertas de Slack.
Las cuentas nuevas reciben créditos de bienvenida: 5 $ para correos personales y 25 $ para correos de empresa. Consulta tu saldo en Configuración > Facturación.

Supervisa el entrenamiento#
Consulta el progreso del entrenamiento en tiempo real en la pestaña Entrenar de la página del modelo:
Subpestaña Gráficos#

Los gráficos se agrupan por familias de métricas, y los grupos que aparecen dependen de los datos que notifica la ejecución:
| Grupo | Contenido |
|---|---|
| Métricas | Métricas de la tarea: mAP50, mAP50-95, precisión y exhaustividad para detección; consulta Modelos para otras tareas |
| Pérdida | Un gráfico por componente de pérdida, con la serie de entrenamiento en línea continua y la de validación en línea discontinua |
| Tasa de aprendizaje | lr/pg0, lr/pg1, lr/pg2 |
Puedes contraer cada grupo, ocultar o mostrar gráficos individuales desde el menú del grupo y arrastrar y cambiar el tamaño de los gráficos; la próxima vez se conservará la disposición.
Subpestaña de consola#
Salida de la consola en directo con compatibilidad con colores ANSI, barras de progreso y detección de errores graves. Se conservan las últimas 2000 líneas, puedes activar o desactivar las marcas de tiempo y copiar todo el registro como texto sin formato.
Subpestaña del sistema#
Una tarjeta del host en directo (nombre de host, CPU, GPU, RAM y capacidad total del disco), además de gráficos por epoch del uso de CPU y RAM, la utilización y la memoria de la GPU, la temperatura de la GPU, la E/S de red y la E/S de disco.
Puntos de control#
El mejor punto de control (best.pt) se carga periódicamente en la plataforma durante el entrenamiento y de nuevo al finalizar la ejecución, para que las opciones de descarga, exportación e implementación usen siempre el mejor epoch obtenido hasta el momento. Si se cancela la ejecución, se conserva el punto de control cargado antes de la cancelación.
Cancelar el entrenamiento#
Haz clic en Cancelar en la tarjeta Información de la ejecución de la página del modelo y confirma la acción. Para el entrenamiento en la nube, la plataforma detiene el trabajo, libera sus recursos de computación y cobra el tiempo de uso de la GPU transcurrido hasta la cancelación. Para el entrenamiento local, la cancelación indica al proceso que se detenga al final del siguiente epoch y conserva los resultados parciales: la ejecución carga lo que haya generado antes de salir.
Entrenamiento remoto#
graph LR
A[Local GPU]:::start --> B[ultralytics Package]:::proc
B --> C[Train]:::proc
C --> D[Stream Metrics]:::proc
D --> E[Platform Dashboard]:::out
classDef start fill:#4CAF50,color:#fff
classDef proc fill:#2196F3,color:#fff
classDef out fill:#9C27B0,color:#fffEntrena en tu propio hardware y transmite las métricas a la plataforma.
La integración con la plataforma requiere Python>=3.11 y ultralytics>=8.4.120. Las versiones anteriores no funcionan con la plataforma.
pip install -U ultralyticsConfigurar la clave de API#
- Ve a
Settings > API Keys - Crea una clave nueva (o la plataforma creará una automáticamente al abrir la pestaña Entrenamiento local)
- Define la variable de entorno:
export ULTRALYTICS_API_KEY="YOUR_API_KEY"Entrenar con transmisión de métricas#
Usa los parámetros project y name para transmitir métricas:
yolo train model=yolo26n.pt data=coco.yaml epochs=100 \
project=username/my-project name=experiment-1La pestaña Entrenamiento local del cuadro de diálogo de entrenamiento muestra un comando preconfigurado con tu clave de API, los parámetros seleccionados y los argumentos avanzados incluidos.
Usar conjuntos de datos de la plataforma#
Entrena con conjuntos de datos almacenados en la plataforma usando el formato de URI ul://:
yolo train model=yolo26n.pt data=ul://username/datasets/my-dataset epochs=100 \
project=username/my-project name=exp1El formato de URI ul:// descarga y configura automáticamente el conjunto de datos. El modelo se vincula automáticamente al conjunto de datos en la plataforma (consulta Usar conjuntos de datos de la plataforma).
Facturación#
El coste del entrenamiento se calcula según el uso de la GPU:
Estimación de costes#
Antes de que empiece el entrenamiento, la plataforma calcula la duración y el coste totales a partir del tamaño del conjunto de datos, el tamaño del modelo, el tamaño de imagen, el tamaño del lote, los epochs y la GPU seleccionada. Las estimaciones son aproximadas; se factura el uso real.
Factores que afectan al coste:
| Factor | Impacto |
|---|---|
| Tamaño del conjunto de datos | Más imágenes = más tiempo de entrenamiento (el cálculo aumenta aproximadamente de forma lineal con el tamaño del conjunto de datos) |
| Tamaño del modelo | Los modelos más grandes (m, l, x) se entrenan más despacio que los modelos (n, s) |
| Número de epochs | Multiplicador directo del tiempo de entrenamiento |
| Tamaño de imagen | Un imgsz mayor aumenta considerablemente el cálculo: 1280 px cuesta varias veces más que 640 px |
| Tamaño del lote | Los lotes más grandes se entrenan de forma más eficiente que los pequeños |
| Velocidad de la GPU | Las GPU más rápidas reducen el tiempo de entrenamiento y compensan parcialmente su tarifa por hora más alta |
| Optimizador | MuSGD tarda aproximadamente el doble que los demás optimizadores |
| Tiempo de inicio | Hasta 5 minutos para inicializar la instancia, descargar los datos y realizar el calentamiento (el tiempo aumenta con el tamaño del conjunto de datos) |
Las estimaciones se basan en ejecuciones reales de entrenamiento en la nube y siempre usan la GPU que has seleccionado; por eso, un trabajo asignado a una infraestructura de Ultralytics más rápida termina antes de lo previsto.
Ejemplos de costes#
Las estimaciones de costes son aproximadas y dependen de muchos factores. El cuadro de diálogo de entrenamiento muestra una estimación en tiempo real antes de que empieces a entrenar.
| Escenario | GPU | Coste estimado |
|---|---|---|
| 500 imágenes, YOLO26n, 50 epochs | RTX 4090 | ~$0.03 |
| 1000 imágenes, YOLO26n, 100 épocas | RTX PRO 6000 | ~$0.23 |
| 5000 imágenes, YOLO26s, 100 épocas | H100 SXM | ~$1.56 |
Flujo de facturación#
graph LR
A[Estimate Cost]:::start --> B[Balance Check]:::decide
B --> C[Train and Meter GPU Time]:::proc
C --> D[Settle at Terminal State]:::out
classDef start fill:#4CAF50,color:#fff
classDef proc fill:#2196F3,color:#fff
classDef decide fill:#FF9800,color:#fff
classDef out fill:#9C27B0,color:#fffFlujo de facturación del entrenamiento en la nube:
- Estimación: coste calculado antes de que empiece el entrenamiento
- Comprobación del saldo: se comprueba el crédito disponible antes de iniciar el trabajo
- Entrenamiento y medición: el trabajo se ejecuta en los recursos de computación seleccionados y el tiempo de GPU acumulado se descuenta del saldo en intervalos mientras se ejecuta
- Liquidación: al finalizar, se descuenta el tiempo restante y se registra una única transacción de Entrenamiento por toda la ejecución
La facturación contabiliza el tiempo real de GPU, incluidas las ejecuciones parciales que se cancelan o fallan después de que se haya iniciado una GPU en la nube.
Facturación según el estado del trabajo#
| Estado | ¿Se cobra? |
|---|---|
| Completado | Sí: tiempo real de GPU utilizado |
| Cancelado | Sí: tiempo de GPU desde el inicio hasta la cancelación |
| Error | Sí, si se han iniciado los recursos de computación en la nube: tiempo de GPU transcurrido utilizado |
| Bloqueado | Sí: tiempo de GPU transcurrido hasta la terminación automática |
Una ejecución que deje de informar de actividad durante 4 horas se marcará automáticamente como fallida; la instancia se terminará y se liquidará el tiempo de GPU transcurrido. Las ejecuciones remotas en tu propio hardware simplemente se marcarán como fallidas y no se cobrará nada.
Un fallo de validación o de inicio antes de que se ponga en marcha una GPU en la nube no genera ningún uso de recursos de computación que se pueda cobrar. Una vez que la GPU está en funcionamiento, los trabajos completados, cancelados, fallidos o terminados automáticamente se liquidan según el tiempo de GPU transcurrido en tiempo real.
Métodos de pago#
El entrenamiento en la nube se paga con el saldo de crédito de tu plataforma.
Para iniciar el entrenamiento, necesitas tener un saldo disponible positivo y crédito suficiente para cubrir el coste estimado del trabajo; cada estimación reserva al menos 15 minutos de tiempo de GPU. Si hay varias ejecuciones activas a la vez, la comprobación también tiene en cuenta el tiempo aún no facturado de esas ejecuciones.
Consultar los costes de entrenamiento#
Antes de iniciar un trabajo en la nube, el cuadro de diálogo de entrenamiento muestra tu saldo de crédito actual y estima la duración y el coste del trabajo según el modelo, el conjunto de datos, las épocas, el tamaño de imagen y la GPU seleccionados. La estimación es informativa; el uso real se cobra en función del tiempo de GPU consumido. Después, consulta la transacción de crédito resultante en Ajustes > Facturación.

Consejos para el entrenamiento#
Elige el tamaño de modelo adecuado#
| Modelo | Parámetros | Ideal para |
|---|---|---|
| YOLO26n | 2.4M | Tiempo real y dispositivos de borde |
| YOLO26s | 9.5M | Equilibrio entre velocidad y precisión |
| YOLO26m | 20.4M | Mayor precisión |
| YOLO26l | 24.8M | Precisión para producción |
| YOLO26x | 55.7M | Máxima precisión |
Optimiza el tiempo de entrenamiento#
- Empieza con poco: prueba con 10-20 épocas en una GPU económica para comprobar que el conjunto de datos y la configuración funcionan
- Usa una GPU adecuada: la RTX PRO 6000 gestiona bien la mayoría de las cargas de trabajo
- Valida el conjunto de datos: corrige los problemas de etiquetado antes de invertir en entrenamiento
- Supervisa desde el principio: cancela el entrenamiento si la pérdida se estanca; solo pagas por el tiempo de computación utilizado
Solución de problemas#
| Problema | Solución |
|---|---|
| El entrenamiento se queda bloqueado en el 0 % | Comprueba el formato del conjunto de datos y vuelve a intentarlo |
| Memoria insuficiente | Reduce el tamaño del lote o usa una GPU más potente |
| Precisión baja | Aumenta las épocas y comprueba la calidad de los datos |
| Entrenamiento lento | Plantéate usar una GPU más rápida |
| Error de incompatibilidad de tareas | Asegúrate de que las tareas del modelo y del conjunto de datos coincidan |
Referencia de parámetros de entrenamiento#
| Parámetro | Tipo | Predeterminado | Intervalo | Descripción |
|---|---|---|---|---|
epochs | int | 100 | 1-10000 | Número de épocas de entrenamiento |
batch | int/float | -1 (automático) | -1, 0-1 o >=1 | Tamaño del lote (-1 = ajuste automático a la VRAM disponible, 0-1 = fracción de memoria de la GPU) |
imgsz | int | 640 | 32-4096 | Tamaño de la imagen de entrada |
pretrained | bool | True | - | Empezar con pesos preentrenados en lugar de con una inicialización aleatoria |
patience | int | 100 | 0-1000 | Paciencia para la detención temprana (0 la desactiva) |
time | float | null | 0.1-720 | Límite de tiempo de entrenamiento en horas, prevalece sobre las épocas |
seed | int | 0 | 0-2147483647 | Semilla aleatoria para garantizar la reproducibilidad |
deterministic | bool | True | - | Modo de entrenamiento determinista |
amp | bool/str | True | true/false/fp16/bf16/fp32 | Precisión del entrenamiento |
compile | bool | False | - | Compilar con torch.compile (la primera época será más lenta) |
close_mosaic | int | 10 | >=0 | Desactivar mosaic en las últimas N épocas |
save_period | int | -1 | >=-1 | Guardar un punto de control cada N épocas |
device | seleccionar | automático | auto/0/cpu/mps | Dispositivo de entrenamiento |
workers | int | 8 | 0-64 | Procesos del cargador de datos |
cache | seleccionar | false | ram/disk/false | Almacenar imágenes en caché |
dropout | float | 0.0 | 0.0-1.0 | Dropout de la capa de clasificación (solo para clasificación) |
iou | float | 0.7 | 0.1-0.9 | Umbral de IoU para NMS durante la validación |
max_det | int | 300 | 1-10000 | Número máximo de detecciones por imagen |
Algunos parámetros solo se aplican a tareas específicas:
- Detección, segmentación, pose y OBB:
box,cls,dfl,single_cls,iou,max_det - Todas las tareas excepto profundidad y clasificación (detección, segmentación, semántica, pose, OBB):
mosaic,mixup,close_mosaic - Todas las tareas excepto clasificación (detección, segmentación, semántica, profundidad, pose, OBB):
degrees,translate,shear,perspective - Segmentación, semántica y OBB:
copy_paste - Solo profundidad:
dlog,dgrad,dlam - Solo clasificación:
dropout - Solo pose:
pose(peso de la pérdida),kobj(objetividad de los puntos clave),rle - Solo OBB:
angle
Preguntas frecuentes#
La duración del entrenamiento depende de:
- Tamaño del conjunto de datos
- Tamaño del modelo
- El número de épocas
- GPU seleccionada
Tiempos habituales (1000 imágenes, 100 épocas):
Modelo RTX PRO 6000 A100 SXM YOLO26n ~6 min ~5 min YOLO26m ~15 min ~12 min YOLO26x ~30 min ~25 min Tiempos aproximadosLos tiempos de entrenamiento son aproximados y varían según la complejidad del conjunto de datos, los ajustes de aumento y el tamaño del lote. Usa la estimación de costes del cuadro de diálogo de entrenamiento para obtener predicciones más precisas.
Sí. El entrenamiento puede ejecutarse sin supervisión mientras haya fondos disponibles, y la Platform registra un evento de finalización o error. Si la facturación por uso deja el saldo por debajo de cero, las ejecuciones de pago activas en la nube se detienen y se liquida el tiempo de GPU ya utilizado.
El uso de la nube se factura según avanza el entrenamiento. Si un cargo deja el saldo por debajo de cero, las ejecuciones de entrenamiento de pago activas en la nube se detienen y se liquida el tiempo de GPU ya utilizado. Añade créditos o activa la recarga automática para mantener financiados los trabajos de larga duración.
Saldo negativoUn saldo cero o negativo impide iniciar nuevos trabajos de entrenamiento de pago en la nube. Un saldo negativo por uso medido también provoca la detención de las ejecuciones de entrenamiento de pago activas en la nube.
Las estimaciones de costes son aproximadas: el tiempo real de entrenamiento puede variar por factores como la velocidad de carga de datos, el calentamiento de la GPU y el comportamiento de convergencia del modelo. Si el uso real agota el saldo disponible, la Platform detiene las ejecuciones de pago activas en la nube cuando el saldo pasa a ser negativo.
Para gestionar los costes:
- Supervisa el progreso del entrenamiento en tiempo real y cancélalo antes si es necesario
- Activa la recarga automática para reponer créditos automáticamente
- Empieza con ejecuciones más cortas (menos épocas) para ajustar las expectativas
Sí, despliega la sección Advanced Settings del cuadro de diálogo de entrenamiento para acceder a un editor YAML con más de 50 parámetros configurables. Los valores no predeterminados se incluyen tanto en los comandos de entrenamiento en la nube como en local.
El editor YAML también permite importar configuraciones de ejecuciones de entrenamiento anteriores:
- Copiar desde un modelo existente: En la página de cualquier modelo completado, la tarjeta Training Configuration tiene un menú Export data con la opción Copy JSON. Pega el JSON directamente en el editor YAML: detecta automáticamente el formato JSON e importa todos los parámetros. El mismo menú descarga la configuración en formato CSV o JSON.
- Pegar YAML o JSON: Pega en el editor cualquier configuración de entrenamiento válida en YAML o JSON. Los parámetros se validan automáticamente; los valores fuera de rango se limitan y se muestran advertencias.
- Arrastrar y soltar archivos: Arrastra un archivo
.yamlo.jsondirectamente al editor para importar sus parámetros.

Esto facilita reproducir o iterar sobre configuraciones de entrenamiento anteriores sin tener que volver a introducir cada parámetro manualmente.
Sí. Un modelo fallido muestra un aviso de error con la acción Retry Training, que vuelve a abrir el cuadro de diálogo de entrenamiento con el mismo modelo base, conjunto de datos y parámetros, para que puedas ajustar un valor y volver a empezar. Al volver a intentarlo, se reutiliza la misma página del modelo: los gráficos, la salida de la consola, las métricas del sistema y el error de la ejecución anterior se borran cuando se crea el nuevo trabajo, y sus pesos se sustituyen cuando la nueva ejecución genera un punto de control mejor.
Sí, el botón New Model de las páginas de conjuntos de datos abre el cuadro de diálogo de entrenamiento con el conjunto de datos preseleccionado y bloqueado. A continuación, selecciona un proyecto y un modelo para empezar el entrenamiento.