Treinamento na Nuvem
Ultralytics Platform Cloud Training oferece treinamento com um clique em GPUs em nuvem, tornando o treinamento de modelos acessível sem configurações complexas. Treine modelos YOLO com transmissão de métricas em tempo real e salvamento automático de checkpoints.
graph LR
A[Configure] --> B[Start Training]
B --> C[Provision GPU]
C --> D[Download Dataset]
D --> E[Train]
E --> F[Stream Metrics]
F --> G[Save Checkpoints]
G --> H[Complete]
style A fill:#2196F3,color:#fff
style B fill:#FF9800,color:#fff
style E fill:#9C27B0,color:#fff
style H fill:#4CAF50,color:#fff
Diálogo de Treinamento
Inicie o treinamento a partir da UI da plataforma clicando em Novo Modelo em qualquer página de projeto (ou em Treinar a partir de uma página de conjunto de dados). O diálogo de treinamento possui duas abas: Treinamento na Nuvem e Treinamento Local.

Passo 1: Selecionar Modelo Base
Escolha entre os modelos oficiais YOLO26 ou seus próprios modelos treinados:
| Categoria | Descrição |
|---|---|
| Oficial | Todos os 25 modelos YOLO26 (5 tamanhos x 5 tarefas) |
| Seus Modelos | Seus modelos concluídos para ajuste fino |
Os modelos oficiais são organizados por tipo de tarefa (Detect, Segment, Pose, OBB, Classify) com tamanhos de nano a xlarge.
Passo 2: Selecionar Conjunto de Dados
Escolha um conjunto de dados para treinar (veja Conjuntos de Dados):
| Opção | Descrição |
|---|---|
| Oficial | Conjuntos de dados selecionados da Ultralytics |
| Seus Conjuntos de Dados | Conjuntos de dados que você carregou |
Requisitos do Conjunto de Dados
Conjuntos de dados devem estar em ready status com pelo menos 1 imagem na divisão de treinamento, 1 imagem na divisão de validação ou teste, e pelo menos 1 imagem rotulada.
Incompatibilidade de Tarefa
Um aviso de incompatibilidade de tarefa aparece se a tarefa do modelo (por exemplo, detect) não corresponder à tarefa do conjunto de dados (por exemplo, segment). O treino falhará se prosseguir com tarefas incompatíveis. Certifique-se de que tanto o modelo quanto o conjunto de dados usam o mesmo tipo de tarefa, conforme descrito nos guias de tarefas.
Passo 3: Configurar Parâmetros
Definir os parâmetros centrais de treinamento:
| Parâmetro | Descrição | Padrão |
|---|---|---|
| Épocas | Número de iterações de treinamento | 100 |
| Tamanho do Lote (Batch Size) | Amostras por iteração | 16 |
| Tamanho da Imagem | Resolução de entrada (menu suspenso 320/416/512/640/1280, ou 32-4096 no editor YAML) | 640 |
| Nome da Execução | Nome opcional para a execução do treinamento | automático |
Passo 4: Configurações Avançadas (Opcional)
Expanda Configurações Avançadas para acessar o editor de parâmetros completo baseado em yaml com mais de 40 parâmetros de treinamento organizados por grupo (consulte a referência de configuração):
| Grupo | Parâmetros |
|---|---|
| Taxa de Aprendizado | lr0, lrf, momentum, weight_decay, warmup_epochs, warmup_momentum, warmup_bias_lr |
| Otimizador | SGD, MuSGD, Adam, AdamW, NAdam, RAdam, RMSProp, Adamax |
| Pesos de Perda | caixa, classe, DFL, pose, kobj, suavização de rótulos |
| Aumento de Cor | hsv_h, hsv_s, hsv_v |
| Aumento Geométrico. | graus, transladar, escalar, cisalhar, perspectiva |
| Aumento por Inversão e Mistura. | flipud, fliplr, mosaic, mixup, copy_paste |
| Controle de Treinamento | patience, seed, deterministic, amp, cos_lr, close_mosaic, save_period |
| Conjunto de dados | fração, congelar, single_cls, ret, multi-escala, retomar |
Os parâmetros são sensíveis à tarefa (por exemplo, copy_paste mostra apenas para tarefas de segmentação, pose/kobj apenas para tarefas de pose). A Modificado o badge aparece quando os valores diferem dos padrões, e você pode redefinir todos para os padrões com o botão de reset.
Exemplo: Ajuste de Aumento para Pequenos Conjuntos de Dados
For small datasets (<1000 images), increase augmentation to reduce overfitting:
mosaic: 1.0 # Keep mosaic on
mixup: 0.3 # Add mixup blending
copy_paste: 0.3 # Add copy-paste (segment only)
fliplr: 0.5 # Horizontal flip
degrees: 10.0 # Slight rotation
scale: 0.9 # Aggressive scaling
Passo 5: Selecionar GPU (Aba Nuvem)
Escolha sua GPU na Ultralytics Cloud:

| GPU | VRAM | Custo/Hora |
|---|---|---|
| RTX 2000 Ada | 16 GB | $0.24 |
| RTX A4500 | 20 GB | $0.24 |
| RTX A5000 | 24 GB | $0.26 |
| RTX 4000 Ada | 20 GB | $0.38 |
| L4 | 24 GB | $0.39 |
| A40 | 48 GB | $0.40 |
| RTX 3090 | 24 GB | $0.46 |
| RTX A6000 | 48 GB | $0.49 |
| RTX 4090 | 24 GB | $0.59 |
| RTX 6000 Ada | 48 GB | $0.77 |
| L40S | 48 GB | $0.86 |
| RTX 5090 | 32 GB | $0.89 |
| L40 | 48 GB | $0.99 |
| A100 PCIe | 80 GB | $1.39 |
| A100 SXM | 80 GB | $1.49 |
| RTX PRO 6000 | 96 GB | $1.89 |
| H100 PCIe | 80 GB | $2.39 |
| H100 SXM | 80 GB | $2.69 |
| H100 NVL | 94 GB | $3.07 |
| H200 NVL | 143 GB | $3.39 |
| H200 SXM | 141 GB | $3.59 |
| B200 | 180 GB | $4.99 |
Seleção de GPU
- RTX PRO 6000: 96 GB de geração Blackwell, padrão recomendado para a maioria dos trabalhos
- A100 SXM: Necessário para grandes tamanhos de lote ou modelos grandes
- H100/H200: Máximo desempenho para treino em que o tempo é um fator determinante (o H200 requer a versão Pro ou Enterprise)
- B200: Arquitetura NVIDIA para cargas de trabalho de ponta (requer a versão Pro ou Enterprise)
O diálogo mostra seu saldo atual e um botão de Recarga. Um custo e duração estimados são calculados com base na sua configuração (tamanho do modelo, imagens do dataset, épocas, velocidade da GPU).
Passo 6: Iniciar Treinamento
Clique em Iniciar Treinamento para iniciar seu trabalho. A Plataforma:
- Provisiona uma instância de GPU
- Baixa seu conjunto de dados
- Inicia o treinamento
- Transmite métricas em tempo real
Ciclo de Vida do Trabalho de Treinamento
Os trabalhos de treinamento progridem pelos seguintes status:
| Status | Descrição |
|---|---|
| Pendente | Tarefa enviada, aguardando alocação de GPU |
| Iniciando | GPU provisionada, baixando conjunto de dados e modelo |
| Em execução | Treinamento em andamento, métricas sendo transmitidas em tempo real |
| Concluído | Treinamento concluído com sucesso |
| Falhou | Treinamento falhou (ver logs do console para detalhes) |
| Cancelado | O treino foi cancelado pelo utilizador |
Créditos Gratuitos
Novas contas recebem créditos de inscrição — $5 para e-mails pessoais e $25 para e-mails corporativos. Verifique seu saldo em Configurações > Cobrança.

Monitorar Treinamento
Visualize o progresso do treinamento em tempo real na guia Train da página do modelo:
Subguia de Gráficos

| Métrica | Descrição |
|---|---|
| Perda | Perda de treinamento e validação |
| mAP | Precisão Média Média |
| Precisão | Previsões positivas corretas |
| Recall | Verdades fundamentais detectadas |
Subguia do Console
Saída do console ao vivo com suporte a cores ANSI, barras de progresso e detecção de erros.
Subguia Sistema
Utilização da GPU, memória, temperatura, CPU e uso de disco em tempo real.
Pontos de Controlo
Os checkpoints são salvos automaticamente:
- A cada época: Pesos mais recentes salvos
- Melhor modelo: Checkpoint com o maior mAP preservado
- Modelo final: Pesos ao término do treinamento
Cancelar Treinamento
Clique em Cancelar Treinamento na página do modelo para interromper um trabalho em execução:
- A instância de computação é encerrada
- Os créditos param de ser cobrados
- Os checkpoints salvos até aquele ponto são preservados
Treinamento Remoto
graph LR
A[Local GPU] --> B[Train]
B --> C[ultralytics Package]
C --> D[Stream Metrics]
D --> E[Platform Dashboard]
style A fill:#FF9800,color:#fff
style C fill:#2196F3,color:#fff
style E fill:#4CAF50,color:#fff
Treinar em seu próprio hardware enquanto transmite métricas para a plataforma.
Requisito de Versão do Pacote
A integração com a Plataforma requer ultralytics>=8.4.14. Versões anteriores NÃO funcionarão com a Plataforma.
pip install -U ultralytics
Configurar Chave API
- Ir para
Settings > Profile(seção Chaves de API) - Crie uma nova chave (ou a plataforma cria uma automaticamente quando você abre a aba Treinamento Local)
- Defina a variável de ambiente:
export ULTRALYTICS_API_KEY="your_api_key"
Treinar com Streaming
Use o comando project e name parâmetros para transmitir métricas:
yolo train model=yolo26n.pt data=coco.yaml epochs=100 \
project=username/my-project name=experiment-1
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
model.train(
data="coco.yaml",
epochs=100,
project="username/my-project",
name="experiment-1",
)
A aba Treinamento Local na caixa de diálogo de treinamento mostra um comando pré-configurado com sua chave de API, parâmetros selecionados e argumentos avançados incluídos.
Utilizar Conjuntos de Dados da Plataforma
Treinar com conjuntos de dados armazenados na plataforma usando o ul:// Formato URI:
yolo train model=yolo26n.pt data=ul://username/datasets/my-dataset epochs=100 \
project=username/my-project name=exp1
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
model.train(
data="ul://username/datasets/my-dataset",
epochs=100,
project="username/my-project",
name="exp1",
)
O ul:// O formato URI baixa e configura automaticamente seu conjunto de dados. O modelo é automaticamente vinculado ao conjunto de dados na plataforma (ver Utilizar Conjuntos de Dados da Plataforma).
Faturamento
Os custos de treinamento são baseados no uso da GPU:
Estimativa de custos
Antes do início do treinamento, a plataforma estima o custo total por meio de:
- Estimando segundos por época a partir do tamanho do conjunto de dados, complexidade do modelo, tamanho da imagem, tamanho do lote e velocidade da GPU
- Calculando o tempo total de treinamento multiplicando segundos por época pelo número de épocas, e depois adicionando a sobrecarga de inicialização
- Calculando o custo estimado a partir do total de horas de treinamento multiplicado pela taxa horária da GPU
Fatores que afetam o custo:
| Fator | Impacto |
|---|---|
| Tamanho do conjunto de dados | Mais imagens = maior tempo de treinamento (linha de base: ~2,8s de computação por 1000 imagens em RTX 4090) |
| Tamanho do Modelo | Modelos maiores (m, l, x) treinam mais lentamente do que (n, s) |
| Número de épocas | Multiplicador direto no tempo de formação |
| Tamanho da Imagem | Um imgsz maior aumenta o custo computacional: 320px=0.25x, 640px=1.0x (referência), 1280px=4.0x |
| Tamanho do Lote (Batch Size) | Lotes maiores são mais eficientes (lote 32 = ~0.85x tempo, lote 8 = ~1.2x tempo vs linha de base do lote 16) |
| GPU | GPUs mais rápidas reduzem o tempo de treinamento (por exemplo, H100 SXM = ~3.4x mais rápido que RTX 4090) |
| Sobrecarga de Inicialização | Até 5 minutos para inicialização da instância, download de dados e aquecimento (escala com o tamanho do conjunto de dados) |
Exemplos de custos
Estimativas
As estimativas de custo são aproximadas e dependem de muitos fatores. O diálogo de treinamento mostra uma estimativa em tempo real antes de você iniciar o treinamento.
| Cenário | GPU | Custo Estimado |
|---|---|---|
| 500 imagens, YOLO26n, 50 épocas | RTX 4090 | ~$0,50 |
| 1000 imagens, YOLO26n, 100 épocas | RTX PRO 6000 | ~$5 |
| 5000 imagens, YOLO26s, 100 épocas | H100 SXM | ~$23 |
Fluxo de Faturação
graph LR
A[Estimate Cost] --> B[Balance Check]
B --> C[Train]
C --> D[Charge Actual Runtime]
style A fill:#2196F3,color:#fff
style B fill:#FF9800,color:#fff
style C fill:#9C27B0,color:#fff
style D fill:#4CAF50,color:#fff
Fluxo de cobrança do treinamento na nuvem:
- Estimativa: Custo calculado antes do início da formação
- Verificação de Saldo: Os créditos disponíveis são verificados antes do lançamento
- Treinar: O trabalho é executado no recurso de computação selecionado
- Cobrança: O custo final é baseado no tempo de execução real
Proteção ao Consumidor
A faturação rastreia o uso real de computação, incluindo execuções parciais que são canceladas. Nunca lhe são cobradas execuções de treino falhadas.
Faturação por Estado do Trabalho
| Status | Cobrado? |
|---|---|
| Concluído | Sim — tempo real de GPU utilizado |
| Cancelado | Sim — tempo de GPU desde o início até o cancelamento |
| Falhou | Não — execuções falhas não são cobradas |
| Preso | Parcial — apenas o tempo real de treinamento é cobrado |
Sem Cobrança por Erros
Se uma execução de treinamento falhar devido a um erro de configuração, problema de falta de memória ou qualquer outra falha, você não será cobrado. Apenas o tempo de computação bem-sucedido é faturado. Trabalhos travados (sem atividade por mais de 4 horas) são automaticamente encerrados e cobrados apenas pelo tempo em que a GPU esteve ativamente treinando, e não pelo tempo ocioso.
Métodos de Pagamento
| Método | Descrição |
|---|---|
| Saldo da Conta | Créditos pré-carregados |
| Pagamento por Tarefa | Cobrança na conclusão da tarefa |
Saldo Mínimo
O início do treino requer um saldo disponível positivo e créditos suficientes para o custo estimado da tarefa.
Ver Custos de Treino
Após o treinamento, visualize os custos detalhados na aba Faturamento:
- Detalhamento de custo por época
- Tempo total de GPU
- Baixar relatório de custos

Dicas de Treino
Escolher o Tamanho Certo do Modelo
| Modelo | Parâmetros | Ideal Para |
|---|---|---|
| YOLO26n | 2.4M | Dispositivos de borda em tempo real |
| YOLO26s | 9.5M | Equilíbrio entre velocidade e precisão |
| YOLO26m | 20.4M | Maior precisão |
| YOLO26l | 24.8M | Precisão para produção |
| YOLO26x | 55.7M | Precisão máxima |
Otimizar Tempo de Treino
Estratégias de Economia de Custos
- Comece pequeno: Teste com 10-20 épocas em uma GPU de baixo custo para verificar o funcionamento do seu conjunto de dados e configuração.
- Use a GPU apropriada: A RTX PRO 6000 lida bem com a maioria das cargas de trabalho
- Valide o conjunto de dados: Corrija problemas de rotulagem antes de gastar com o treinamento
- Monitorar precocemente: Cancele o treinamento se a perda estabilizar — você só paga pelo tempo de computação utilizado
Resolução de Problemas
| Problema | Solução |
|---|---|
| Treinamento travado em 0% | Verifique o formato do conjunto de dados, tente novamente |
| Memória insuficiente | Reduza o tamanho do lote ou use uma GPU maior |
| Precisão baixa | Aumente as épocas, verifique a qualidade dos dados |
| Treinamento lento | Considere uma GPU mais rápida |
| Erro de incompatibilidade de tarefa | Garanta que as tarefas do modelo e do conjunto de dados correspondam |
FAQ
Quanto tempo leva o treinamento?
O tempo de treinamento depende de:
- Tamanho do dataset
- Tamanho do modelo
- Número de épocas
- GPU selecionada
Tempos típicos (1000 imagens, 100 épocas):
| Modelo | RTX PRO 6000 | A100 |
|---|---|---|
| YOLO26n | 20 min | 20 min |
| YOLO26m | 40 min | 40 min |
| YOLO26x | 80 min | 80 min |
Posso treinar durante a noite?
Sim, o treinamento continua até a conclusão. Você receberá uma notificação quando o treinamento terminar. Certifique-se de que sua conta tenha saldo suficiente para o treinamento baseado em épocas.
O que acontece se eu ficar sem créditos?
Se o seu saldo de créditos chegar a zero durante uma execução de treinamento, o treinamento continua até a conclusão e seu saldo fica negativo. Isso garante que seu trabalho de treinamento nunca seja interrompido no meio da execução.
Após a conclusão do treinamento, você precisará adicionar créditos para que seu saldo volte a ser positivo antes de iniciar novos trabalhos de treinamento. Seu modelo concluído, checkpoints e todos os artefatos de treinamento são totalmente preservados, independentemente do saldo.
Saldo Negativo
Um saldo negativo apenas impede o início de novos trabalhos de treino. As implementações existentes e outras funcionalidades da plataforma continuam a funcionar normalmente. Adicione créditos através de Definições > Faturação ou ative o carregamento automático para evitar interrupções.
O que acontece se meu treinamento custar mais do que o estimado?
As estimativas de custo são aproximadas — o tempo real de treinamento pode variar devido a fatores como velocidade de carregamento de dados, aquecimento da GPU e comportamento de convergência do modelo. Se o custo real exceder a estimativa, seu saldo pode ficar negativo (veja acima). A plataforma não interrompe o treinamento com base na estimativa.
Para gerir custos:
- Monitorar o progresso do treinamento em tempo real e cancelar antecipadamente, se necessário
- Ativar recarga automática para reabastecer créditos automaticamente
- Comece com execuções mais curtas (menos épocas) para calibrar as expectativas
Posso usar argumentos de treino personalizados?
Sim, expanda a secção Definições Avançadas na caixa de diálogo de treino para aceder a um editor yaml com mais de 40 parâmetros configuráveis. Os valores não predefinidos são incluídos nos comandos de treino na cloud e local.
O editor YAML também suporta importar configurações de execuções de treinamento anteriores:
- Copiar de modelo existente: Na página de qualquer modelo concluído, o cartão de Configuração de Treinamento possui um botão Copiar como JSON. Copie o JSON e cole-o diretamente no editor YAML — ele detecta automaticamente o formato JSON e importa todos os parâmetros.
- Colar YAML ou JSON: Cole qualquer configuração de treinamento YAML ou JSON válida no editor. Os parâmetros são validados automaticamente, com valores fora do intervalo sendo ajustados e avisos exibidos.
- Arrastar e soltar arquivos: Arraste um
.yamlou.jsonarquivo diretamente no editor para importar seus parâmetros.

Isso facilita a reprodução ou iteração em configurações de treinamento anteriores sem a necessidade de reinserir manualmente cada parâmetro.
Posso treinar a partir de uma página de conjunto de dados?
Sim, o botão Treinar nas páginas de conjuntos de dados abre a caixa de diálogo de treino com o conjunto de dados pré-selecionado e bloqueado. Em seguida, seleciona um projeto e um modelo para iniciar o treino.
Referência de Parâmetros de Treinamento
| Parâmetro | Tipo | Padrão | Intervalo | Descrição |
|---|---|---|---|---|
epochs | int | 100 | 1-10000 | Número de épocas de treino |
batch | int | 16 | 1-512 | Tamanho do lote (Batch size) |
imgsz | int | 640 | 32-4096 | Tamanho da imagem de entrada |
patience | int | 100 | 1-1000 | Paciência para early stopping |
seed | int | 0 | 0-2147483647 | Semente aleatória para reprodutibilidade |
deterministic | booleano | Verdadeiro | - | Modo de treinamento determinístico |
amp | booleano | Verdadeiro | - | Precisão mista automática |
close_mosaic | int | 10 | 0-50 | Desativar mosaico nas N épocas finais |
save_period | int | -1 | -1-100 | Salvar checkpoint a cada N épocas |
workers | int | 8 | 0-64 | Workers do dataloader |
cache | selecionar | falso | RAM/disco/falso | Cachear imagens |
| Parâmetro | Tipo | Padrão | Intervalo | Descrição |
|---|---|---|---|---|
lr0 | float | 0.01 | 0.0001-0.1 | Taxa de aprendizado inicial |
lrf | float | 0.01 | 0.01-1.0 | Fator LR final |
momentum | float | 0.937 | 0.6-0.98 | Momento SGD |
weight_decay | float | 0.0005 | 0.0-0.001 | Regularização L2 |
warmup_epochs | float | 3.0 | 0-5 | Épocas de aquecimento |
warmup_momentum | float | 0.8 | 0.5-0.95 | Momento de aquecimento |
warmup_bias_lr | float | 0.1 | 0.0-0.2 | LR de bias de aquecimento |
cos_lr | booleano | Falso | - | Scheduler de LR cosseno |
| Parâmetro | Tipo | Padrão | Intervalo | Descrição |
|---|---|---|---|---|
hsv_h | float | 0.015 | 0.0-0.1 | Aumento de matiz HSV |
hsv_s | float | 0.7 | 0.0-1.0 | Saturação HSV |
hsv_v | float | 0.4 | 0.0-1.0 | Valor HSV |
degrees | float | 0.0 | -45-45 | Graus de rotação |
translate | float | 0.1 | 0.0-1.0 | Fração de translação |
scale | float | 0.5 | 0.0-1.0 | Fator de escala |
shear | float | 0.0 | -10-10 | Graus de cisalhamento |
perspective | float | 0.0 | 0.0-0.001 | Transformação de perspectiva |
fliplr | float | 0.5 | 0.0-1.0 | Probabilidade de inversão horizontal |
flipud | float | 0.0 | 0.0-1.0 | Probabilidade de inversão vertical |
mosaic | float | 1.0 | 0.0-1.0 | Aumento de mosaico |
mixup | float | 0.0 | 0.0-1.0 | Aumento Mixup |
copy_paste | float | 0.0 | 0.0-1.0 | Copiar-colar (segment) |
| Parâmetro | Tipo | Padrão | Intervalo | Descrição |
|---|---|---|---|---|
fraction | float | 1.0 | 0.1-1.0 | Fração do dataset a utilizar |
freeze | int | nulo | 0-100 | Número de camadas a congelar |
single_cls | booleano | Falso | - | Tratar todas as classes como uma única classe |
rect | booleano | Falso | - | Treinamento retangular |
multi_scale | float | 0.0 | 0.0-1.0 | Intervalo de treinamento multi-escala |
val | booleano | Verdadeiro | - | Executar validação durante o treinamento |
resume | booleano | Falso | - | Retomar o treinamento a partir de um checkpoint |
| Valor | Descrição |
|---|---|
auto | Seleção automática (padrão) |
SGD | Descida do Gradiente Estocástico |
MuSGD | Otimizador Muon SGD |
Adam | Otimizador Adam |
AdamW | Adam com decaimento de peso |
NAdam | Otimizador NAdam |
RAdam | Otimizador RAdam |
RMSProp | Otimizador RMSProp |
Adamax | Otimizador Adamax |
| Parâmetro | Tipo | Padrão | Intervalo | Descrição |
|---|---|---|---|---|
box | float | 7.5 | 1-50 | Peso da perda da caixa |
cls | float | 0.5 | 0.2-4 | Peso da perda de classificação |
dfl | float | 1.5 | 0.4-6 | Perda focal de distribuição |
pose | float | 12.0 | 1-50 | Peso da perda de pose (somente pose) |
kobj | float | 1.0 | 0.5-10 | Objetividade do ponto-chave (pose) |
label_smoothing | float | 0.0 | 0.0-0.1 | Fator de suavização de rótulos |
Parâmetros Específicos da Tarefa
Alguns parâmetros aplicam-se apenas a tarefas específicas:
- Apenas tarefas de detecção (detect, segment, pose, OBB — não classify):
box,dfl,degrees,translate,shear,perspective,mosaic,mixup,close_mosaic - segment apenas:
copy_paste - Somente pose:
pose(peso da perda),kobj(objectness de keypoint)