Treino na nuvem#
O Ultralytics Platform oferece treino na nuvem com um só clique em GPUs na nuvem, tornando o treino de modelos acessível sem configurações complexas. Treina modelos YOLO com transmissão de métricas em tempo real e gravação automática de checkpoints.
Caixa de diálogo de treino#
Inicia o treino na interface da plataforma clicando em Novo modelo na página de qualquer projeto ou conjunto de dados. A caixa de diálogo de treino tem dois separadores: Treino na nuvem e Treino local. Quando o conjunto de dados selecionado está num anfitrião On Premise, o primeiro separador passa a chamar-se On Premise e o separador Treino local fica oculto — esse conjunto de dados só pode ser usado para treino no respetivo anfitrião, o que requer um plano Enterprise e um worker ligado e online.

A caixa de diálogo memoriza o modelo base e quaisquer parâmetros não predefinidos que estavam definidos quando a fechaste pela última vez, por tarefa do conjunto de dados e espaço de trabalho no navegador atual, e restaura-os na próxima vez que a abrires para essa tarefa. A seleção de GPU não é memorizada, e Repetir treino numa execução falhada restaura os argumentos específicos dessa execução.
Passo 1: selecionar o modelo base#
Escolhe um modelo oficial da Ultralytics ou um dos teus próprios modelos concluídos:
| Separador | Descrição |
|---|---|
| Oficiais | Modelos dos projetos YOLO26 (recomendado), YOLO11, YOLOv8 e YOLOv5 |
| Os meus modelos | Os teus modelos concluídos ou carregados, agrupados por projeto, para ajuste fino |
Em cada separador, os modelos são agrupados por tarefa na ordem canónica e ordenados por tamanho. Ambos os separadores apresentam apenas modelos cuja tarefa permite treinar o conjunto de dados selecionado. O YOLO26 inclui variantes de deteção, segmentação, semântica, profundidade, classificação, pose e OBB, em tamanhos que vão de nano a xlarge.
Os conjuntos de dados de profundidade podem ser carregados com alvos NPY float em metros ou alvos PNG uint16, usando o depth_scale do conjunto de dados. Consulta o formato de conjuntos de dados de profundidade. Os modelos de profundidade usam por predefinição uma receita de ajuste fino (optimizer: AdamW, lr0: 0.0001, warmup_bias_lr: 0.0001), a menos que definas esses parâmetros manualmente.
Passo 2: selecionar o conjunto de dados#
Escolhe um conjunto de dados para treinar (consulta Conjuntos de dados):
| Opção | Descrição |
|---|---|
| Oficiais | Conjuntos de dados selecionados da Ultralytics |
| Os meus conjuntos de dados | Conjuntos de dados no teu espaço de trabalho |
Os conjuntos de dados têm de estar no estado ready, com pelo menos 1 imagem na divisão de treino, 1 imagem na divisão de validação ou teste, pelo menos 1 imagem anotada e pelo menos um nome de classe. Os conjuntos de dados de classificação também exigem que a imagem da divisão de treino esteja anotada, e os conjuntos de dados de pose têm de definir uma forma de pontos-chave. Em vez disso, os conjuntos de dados de profundidade exigem um mapa emparelhado em train e dois em val; as imagens não emparelhadas são excluídas.
É apresentado um aviso de incompatibilidade de tarefa quando o modelo selecionado não consegue treinar a tarefa do conjunto de dados, e Iniciar treino permanece desativado até escolheres um modelo compatível. Um conjunto de dados de segmentação aceita modelos de segmentação ou semânticos; as outras tarefas do conjunto de dados requerem um modelo com a tarefa correspondente. Consulta os guias de tarefas.
Passo 3: configurar os parâmetros#
Define os parâmetros principais do treino:
| Parâmetro | Descrição | Padrão |
|---|---|---|
| Épocas | Número de iterações de treino (1-10000) | 100 |
| Tamanho do lote | Amostras por iteração (-1 ajusta automaticamente à VRAM disponível ou usa uma contagem fixa de imagens) | -1 (automático) |
| Tamanho da imagem | Controlo deslizante da resolução de entrada, de 32 a 1280 em incrementos de 32 | 640 |
| Nome | Nome opcional para a execução de treino | automático |
Os valores introduzidos fora do intervalo de um parâmetro são limitados a esse intervalo quando o campo perde o foco.
O controlo deslizante termina em 1280, mas o editor YAML aceita tamanhos até 4096. É apresentado um aviso acima de 1280 porque as resoluções maiores aumentam substancialmente a utilização de memória da GPU, o tempo de treino e o custo.
Passo 4: definições avançadas (opcional)#
Expande Definições avançadas para aceder ao editor de parâmetros baseado em YAML, com mais de 50 parâmetros de treino nas secções Definições de treino e Aumentos de dados de imagem (consulta a referência de configuração):
| Grupo | Parâmetros |
|---|---|
| Taxa de aprendizagem | lr0, lrf, momentum, weight_decay, warmup_epochs, warmup_momentum, warmup_bias_lr |
| Otimizador | auto (predefinição), SGD, MuSGD, Adam, AdamW, NAdam, RAdam, RMSProp, Adamax |
| Pesos das perdas | box, cls, cls_pw, dfl, pose, kobj, rle, angle, dlog, dgrad, dlam |
| Aumento de dados de cor | hsv_h, hsv_s, hsv_v |
| Aumento de dados geométrico | degrees, translate, scale, shear, perspective |
| Aumento de dados de inversão e mistura | flipud, fliplr, mosaic, mixup, copy_paste, bgr, cutmix, copy_paste_mode, auto_augment, erasing |
| Controlo do treino | 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 dados | fraction, freeze, single_cls, rect, multi_scale, resume |
| Validação | max_det |
Os parâmetros variam consoante a tarefa (por exemplo, copy_paste só aparece para tarefas de segmentação, semânticas e OBB; pose/kobj só aparecem para tarefas de pose; auto_augment/erasing só aparecem para tarefas de classificação). O editor omite device, cache, workers, iou, dropout, val e time, e ignora-os nas configurações coladas ou arrastadas; define-os no teu próprio comando yolo train ao treinar localmente. Um emblema Modificado aparece quando os valores diferem dos valores predefinidos, e podes repor todos os valores predefinidos com o botão de reposição. Apenas os valores avançados não predefinidos são enviados para a tarefa de treino (os parâmetros básicos de épocas, batch e tamanho da imagem são sempre incluídos), para que o comando resultante continue legível.
Exemplo: ajustar a ampliação de dados para conjuntos de dados pequenos
Para conjuntos de dados pequenos (<1000 imagens), aumenta a ampliação de dados para reduzir o 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 a versão do conjunto de dados (opcional)#
Ativa Guardar a versão do conjunto de dados para associar o modelo a uma versão imutável de um conjunto de dados alojado na Platform. A Platform verifica se o conteúdo do conjunto de dados foi alterado, reutiliza uma versão correspondente se não tiver sido alterado e cria uma nova versão numerada apenas quando necessário. O treino utiliza então esse instantâneo NDJSON exato e regista o respetivo número de versão e hash do conteúdo no modelo.
Isto preserva os dados utilizados na execução, mesmo que mais tarde adiciones ou removas imagens, edites anotações ou alteres as divisões do conjunto de dados. Podes encontrar a versão associada nos separadores Modelos e Versões do conjunto de dados.
A opção Guardar a versão do conjunto de dados não está disponível para armazenamento na cloud ligado nem para conjuntos de dados On Premise. Também podes criar instantâneos manualmente no separador Versões.
Passo 5: selecionar a GPU (separador Cloud)#
Escolhe a tua GPU na Ultralytics Cloud:

| GPU | Geração | VRAM | Custo/hora | Ideal para |
|---|---|---|---|---|
| RTX 2000 Ada | Ada | 16 GB | $0.24 | Conjuntos de dados pequenos, testes |
| RTX A4500 | Ampere | 20 GB | $0.25 | Conjuntos de dados pequenos e médios |
| RTX 4000 Ada | Ada | 20 GB | $0.26 | Conjuntos de dados médios |
| RTX A5000 | Ampere | 24 GB | $0.27 | Conjuntos de dados médios |
| L4 | Ada | 24 GB | $0.39 | Otimizada para inferência |
| A40 | Ampere | 48 GB | $0.44 | Tamanhos de lote maiores |
| RTX 3090 | Ampere | 24 GB | $0.46 | Treinamento geral |
| 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 | Ótima relação preço/desempenho |
| RTX 4090 | Ada | 24 GB | $0.69 | Melhor relação preço/desempenho |
| RTX 6000 Ada | Ada | 48 GB | $0.77 | Treinamento com lotes grandes |
| L40S | Ada | 48 GB | $0.86 | Treinamento com lotes grandes |
| RTX PRO 5000 | Blackwell | 48 GB | $0.96 | Treinamento com lotes grandes |
| RTX 5090 | Blackwell | 32 GB | $0.99 | Geração mais recente para consumidores |
| L40 | Ada | 48 GB | $0.99 | Modelos grandes |
| A100 PCIe | Ampere | 80 GB | $1.39 | Treinamento em produção |
| A100 SXM | Ampere | 80 GB | $1.49 | Treinamento em produção |
| RTX PRO 6000 | Blackwell | 96 GB | $2.09 | Padrão recomendado |
| H100 PCIe | Hopper | 80 GB | $2.89 | Treinamento de alto desempenho |
| H100 NVL | Hopper | 94 GB | $3.19 | Desempenho máximo |
| H100 SXM | Hopper | 80 GB | $3.29 | Treinamento mais rápido |
| H200 NVL | Hopper | 143 GB | $3.39 | Memória máxima |
| H200 SXM | Hopper | 141 GB | $4.39 | Desempenho máximo |
| B200 | Blackwell | 180 GB | $5.89 | Modelos grandes (Pro+) |
| B300 | Blackwell | 288 GB | $7.39 | Os maiores modelos (Pro+) |
- RTX PRO 6000: 96 GB Blackwell, opção predefinida recomendada para a maioria das tarefas
- A100 SXM: 80 GB HBM2e — uma excelente opção para tamanhos de batch grandes ou modelos maiores
- H100 PCIe / H100 SXM / H100 NVL: 80–94 GB Hopper para treinos urgentes (disponível em todos os planos)
- H200 NVL / H200 SXM: 141–143 GB Hopper para cargas de trabalho com elevados requisitos de memória (disponível em todos os planos)
- B200 / B300: 180–288 GB NVIDIA Blackwell para cargas de trabalho de ponta — requer Pro ou Enterprise
A janela apresenta o teu saldo atual e um botão Adicionar fundos. O cartão de custos estima a duração total e o preço da tua configuração (tamanho do modelo, imagens do conjunto de dados, épocas, tamanho da imagem, tamanho do batch, otimizador e velocidade da GPU) e também indica os segundos estimados por época e a quantidade de imagens do conjunto de dados.
O seletor de GPU reflete a disponibilidade atual na cloud, pelo que as opções sem capacidade disponível são assinaladas. Se ainda assim não for possível atribuir uma tarefa à GPU que escolheste, a Platform informa-te da falta de capacidade e muda a tua seleção para a GPU disponível mais semelhante — primeiro com base na VRAM, depois na velocidade e, por fim, no preço — indicando a nova VRAM e a tarifa por hora para que possas começar de imediato ou escolher outra opção.
Se selecionares uma GPU mais barata do que a RTX PRO 6000, a tua tarefa poderá utilizar a infraestrutura gerida pela Ultralytics. Quando essa capacidade estiver disponível, a execução é feita numa RTX PRO 6000, mas cobrada à tarifa da GPU selecionada. Assim, a execução pode terminar mais depressa e custar menos do que se fosse feita na GPU selecionada — a atualização nunca torna a execução mais lenta nem mais cara.
Passo 6: iniciar o treino#
Clica em Iniciar treino para iniciar a tarefa. A Platform:
- Resolve a versão imutável do conjunto de dados quando a opção Guardar a versão do conjunto de dados está ativada
- Disponibiliza uma instância de GPU
- Transfere o teu conjunto de dados
- Inicia o treino
- Transmite métricas em tempo real
Ao treinar novamente um modelo existente, reutiliza-se a mesma página do modelo e limpam-se os gráficos, a saída da consola, as métricas do sistema e o estado de erro da execução anterior quando a nova tarefa é criada. Se uma execução falhar antes de os recursos de computação serem disponibilizados, os resultados anteriores não são alterados.
Ciclo de vida da tarefa de treino#
As tarefas de treino passam pelos seguintes estados:
| Status | Descrição |
|---|---|
| Iniciando | Tarefa submetida, a disponibilizar GPU, a transferir o conjunto de dados e o modelo |
| Em execução | Treino em curso, com métricas transmitidas em tempo real |
| Concluído | Treino concluído com êxito |
| Falhou | Falha no treino (consulta os registos da consola para obter detalhes) |
| Cancelado | O utilizador cancelou o treino |
Um erro fatal de Python na transmissão da consola — um traceback, um erro de falta de memória da CUDA ou uma falha na inicialização da CUDA — termina a execução imediatamente, em vez de aguardar por um tempo limite. A mensagem extraída aparece num aviso de erro na página do modelo, com as opções Ver registos completos da consola e Tentar novamente o treino. As execuções que não comunicarem atividade durante 4 horas são automaticamente marcadas como falhadas e os respetivos recursos de computação são libertados.
Para receber os resultados das execuções concluídas e falhadas sem manter esta página aberta, liga os alertas do Slack.
As contas novas recebem créditos de registo — $5 para emails pessoais e $25 para emails de empresa. Consulta o teu saldo em Definições > Faturação.

Acompanha o treinamento#
Consulta o progresso do treino em tempo real no separador Treino da página do modelo:
Subaba Gráficos#

Os gráficos estão agrupados por família de métricas, e os grupos apresentados dependem dos dados comunicados pela execução:
| Grupo | Conteúdo |
|---|---|
| Métricas | Métricas da tarefa — mAP50, mAP50-95, precisão e revocação para deteção; consulta Modelos para outras tarefas |
| Perda | Um gráfico por componente da função de perda, com a série de treino a cheio e a série de validação a tracejado |
| Taxa de aprendizagem | lr/pg0, lr/pg1, lr/pg2 |
Podes recolher cada grupo, ocultar ou mostrar gráficos individuais no menu do grupo e arrastar e redimensionar os gráficos — o esquema fica guardado para a próxima vez.
Subaba Console#
Saída da consola em tempo real com suporte para cores ANSI, barras de progresso e deteção de erros fatais. São mantidas as últimas 2000 linhas, podes ativar os registos de data e hora e copiar todo o registo como texto simples.
Subaba Sistema#
Um cartão do anfitrião em tempo real (nome do anfitrião, CPU, GPU, RAM e capacidade total do disco), além de gráficos por época para utilização de CPU e RAM, utilização e memória da GPU, temperatura da GPU, E/S de rede e E/S de disco.
Pontos de controlo#
O melhor ponto de controlo (best.pt) é carregado para a Platform periodicamente durante o treino e novamente quando a execução termina, para que a transferência, a exportação e a implementação utilizem sempre a melhor época produzida até ao momento. Se a execução for cancelada, mantém-se o ponto de controlo carregado antes do cancelamento.
Cancelar o treino#
Clica em Cancelar no cartão Informações da execução na página do modelo e confirma a ação. No treino na cloud, a Platform interrompe a tarefa, liberta os recursos de computação e cobra o tempo de GPU utilizado até ao cancelamento. No treino local, o cancelamento sinaliza ao processo que deve parar no final da época seguinte e preserva os resultados parciais — a execução carrega o que tiver antes de terminar.
Treino remoto#
Treina no teu próprio hardware e transmite métricas para a plataforma.
A integração com a Platform requer Python>=3.11 e ultralytics>=8.4.120. As versões anteriores não funcionam com a Platform.
pip install -U ultralyticsConfigurar a chave da API#
- Vai a
Settings > API Keys - Cria uma nova chave (ou a plataforma cria uma automaticamente quando abres o separador Treino local)
- Define a variável de ambiente:
export ULTRALYTICS_API_KEY="YOUR_API_KEY"Treinar com transmissão de métricas#
Utiliza os parâmetros project e name para transmitir métricas:
yolo train model=yolo26n.pt data=coco.yaml epochs=100 \
project=username/my-project name=experiment-1O separador Treino local da janela de treino apresenta um comando pré-configurado que inclui a tua chave da API, os parâmetros selecionados e os argumentos avançados.
Utilizar conjuntos de dados da Platform#
Treina com conjuntos de dados guardados na plataforma através do formato URI ul://:
yolo train model=yolo26n.pt data=ul://username/datasets/my-dataset epochs=100 \
project=username/my-project name=exp1O formato URI ul:// transfere e configura automaticamente o teu conjunto de dados. O modelo é associado automaticamente ao conjunto de dados na plataforma (consulta Utilizar conjuntos de dados da Platform).
Faturação#
Os custos do treino baseiam-se na utilização da GPU:
Estimativa de custos#
Antes do início do treino, a plataforma estima a duração e o custo totais com base no tamanho do conjunto de dados, no tamanho do modelo, no tamanho da imagem, no tamanho do batch, no número de épocas e na GPU selecionada. As estimativas são aproximadas; a cobrança baseia-se na utilização real.
Fatores que afetam o custo:
| Fator | Impacto |
|---|---|
| Tamanho do conjunto de dados | Mais imagens = mais tempo de treino (o cálculo aumenta aproximadamente de forma linear com o tamanho do conjunto de dados) |
| Tamanho do modelo | Os modelos maiores (m, l, x) treinam mais lentamente do que os modelos (n, s) |
| Número de épocas | Multiplicador direto do tempo de treino |
| Tamanho da imagem | Um imgsz maior aumenta substancialmente o cálculo — 1280px custa várias vezes mais do que 640px |
| Tamanho do lote | Os batches maiores treinam com mais eficiência do que os pequenos |
| Velocidade da GPU | As GPUs mais rápidas reduzem o tempo de treino, compensando parcialmente a tarifa horária mais elevada |
| Otimizador | MuSGD demora aproximadamente o dobro do tempo dos outros otimizadores |
| Tempo de inicialização | Até 5 minutos para inicializar a instância, transferir os dados e preparar o sistema (o tempo aumenta com o tamanho do conjunto de dados) |
As estimativas baseiam-se em execuções reais de treino na cloud e utilizam sempre a GPU que selecionaste — por isso, uma tarefa encaminhada para uma infraestrutura mais rápida da Ultralytics termina antes do tempo estimado.
Exemplos de custos#
As estimativas de custos são aproximadas e dependem de muitos fatores. A janela de treino apresenta uma estimativa em tempo real antes de iniciares o treino.
| Cenário | GPU | Custo estimado |
|---|---|---|
| 500 imagens, YOLO26n, 50 épocas | RTX 4090 | ~$0.03 |
| 1000 imagens, YOLO26n, 100 épocas | RTX PRO 6000 | ~$0.23 |
| 5000 imagens, YOLO26s, 100 épocas | H100 SXM | ~$1.56 |
Fluxo de faturação#
Fluxo de faturação do treino na nuvem:
- Estimativa: custo calculado antes de o treino começar
- Verificação do saldo: os créditos disponíveis são verificados antes do início
- Treino e contabilização: o trabalho é executado no recurso computacional selecionado, e o tempo de GPU acumulado é debitado do teu saldo em parcelas enquanto decorre
- Acerto: no estado terminal, o tempo restante é debitado e é registada uma única transação de Treino referente a toda a execução
A faturação contabiliza o tempo real de GPU, incluindo execuções parciais que são canceladas ou falham depois de uma GPU na nuvem ter sido iniciada.
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é ao cancelamento |
| Falhou | Sim, quando a computação na nuvem é iniciada — tempo decorrido de GPU utilizado |
| Encravado | Sim — tempo decorrido de GPU até à terminação automática |
Uma execução que deixe de comunicar atividade durante 4 horas é automaticamente marcada como falhada; a instância é terminada e o tempo decorrido de GPU é contabilizado. As execuções remotas no teu próprio hardware são simplesmente marcadas como falhadas, sem qualquer cobrança.
Uma falha de validação ou de inicialização antes de uma GPU na nuvem arrancar não gera utilização de computação a cobrar. Depois de uma GPU estar em execução, os trabalhos concluídos, cancelados, falhados e terminados automaticamente são contabilizados com base no tempo decorrido de GPU em tempo real.
Métodos de pagamento#
O treino na nuvem é pago com o saldo de créditos da tua Platform.
Para iniciar o treino, é necessário ter um saldo disponível positivo e créditos suficientes para o custo estimado do trabalho, sendo que cada estimativa reserva pelo menos 15 minutos de tempo de GPU. Se houver várias execuções ativas em simultâneo, a verificação também tem em conta o saldo não faturado dessas execuções.
Consultar os custos de treino#
Antes de iniciar um trabalho na nuvem, a janela de treino apresenta o teu saldo atual de créditos e estima a duração e o custo do trabalho com base no modelo, no conjunto de dados, nas épocas, no tamanho da imagem e na GPU selecionados. A estimativa é meramente informativa; a utilização real é cobrada com base no tempo de GPU consumido. Depois, consulta a transação de crédito resultante em Definições > Faturação.

Dicas de treino#
Escolhe o tamanho de modelo adequado#
| Modelo | Parâmetros | Ideal para |
|---|---|---|
| YOLO26n | 2.4M | Tempo real, dispositivos de ponta |
| 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 |
Otimiza o tempo de treino#
- Começa com pouco: testa com 10-20 épocas numa GPU económica para verificar se o conjunto de dados e a configuração funcionam
- Usa uma GPU adequada: a RTX PRO 6000 dá conta da maioria das cargas de trabalho
- Valida o conjunto de dados: corrige os problemas de anotação antes de gastar dinheiro no treino
- Acompanha desde cedo: cancela o treino se a perda estabilizar — só pagas pelo tempo de computação utilizado
Solução de problemas#
| Problema | Solução |
|---|---|
| Treino bloqueado em 0% | Verifica o formato do conjunto de dados e tenta novamente |
| Memória insuficiente | Reduz o tamanho do lote ou usa uma GPU maior |
| Precisão baixa | Aumenta o número de épocas e verifica a qualidade dos dados |
| Treinamento lento | Considera usar uma GPU mais rápida |
| Erro de incompatibilidade de tarefa | Garante que as tarefas do modelo e do conjunto de dados correspondem |
Referência dos parâmetros de treino#
| Parâmetro | Tipo | Padrão | Intervalo | Descrição |
|---|---|---|---|---|
epochs | int | 100 | 1-10000 | Número de épocas de treino |
batch | int/float | -1 (automático) | -1, 0-1 ou >=1 | Tamanho do lote (-1 = ajuste automático à VRAM disponível, 0-1 = fração da memória da GPU) |
imgsz | int | 640 | 32-4096 | Tamanho da imagem de entrada |
pretrained | bool | True | - | Começa com pesos pré-treinados em vez de inicialização aleatória |
patience | int | 100 | 0-1000 | Paciência para paragem antecipada (0 desativa) |
time | float | null | 0.1-720 | Limite de treino em horas de tempo real, substitui o número de épocas |
seed | int | 0 | 0-2147483647 | Semente aleatória para reprodutibilidade |
deterministic | bool | True | - | Modo de treino determinístico |
amp | bool/str | True | true/false/fp16/bf16/fp32 | Precisão do treino |
compile | bool | False | - | Compila com torch.compile (a primeira época é mais lenta) |
close_mosaic | int | 10 | >=0 | Desativa o mosaico nas últimas N épocas |
save_period | int | -1 | >=-1 | Guarda um ponto de controlo a cada N épocas |
device | selecionar | automático | auto/0/cpu/mps | Dispositivo de treino |
workers | int | 8 | 0-64 | Processos de trabalho do carregador de dados |
cache | selecionar | false | ram/disk/false | Colocar imagens em cache |
dropout | float | 0.0 | 0.0-1.0 | Dropout da cabeça de classificação (apenas para classificação) |
iou | float | 0.7 | 0.1-0.9 | Limiar de IoU para NMS durante a validação |
max_det | int | 300 | 1-10000 | Número máximo de deteções por imagem |
Alguns parâmetros se aplicam somente a tarefas específicas:
- Detecção, segmentação, pose e OBB:
box,cls,dfl,single_cls,iou,max_det - Todas as tarefas, exceto profundidade e classificação (detecção, segmentação, semântica, pose, obb):
mosaic,mixup,close_mosaic - Todas as tarefas, exceto classificação (detecção, segmentação, semântica, profundidade, pose, obb):
degrees,translate,shear,perspective - Segmentação, semântica e OBB:
copy_paste - Somente profundidade:
dlog,dgrad,dlam - Somente classificação:
dropout - Somente pose:
pose(peso da perda),kobj(objetividade dos pontos-chave),rle - Somente OBB:
angle
Perguntas frequentes#
O tempo de treinamento depende de:
- Tamanho do conjunto de dados
- Tamanho do modelo
- Número de épocas
- GPU selecionada
Tempos típicos (1.000 imagens, 100 épocas):
Modelo RTX PRO 6000 A100 SXM YOLO26n ~6 min ~5 min YOLO26m ~15 min ~12 min YOLO26x ~30 min ~25 min Tempos aproximadosOs tempos de treinamento são aproximados e variam conforme a complexidade do conjunto de dados, as configurações de aumento de dados e o tamanho do lote. Use a estimativa de custo da caixa de diálogo de treinamento para obter previsões mais precisas.
Sim. O treinamento pode ser executado sem supervisão enquanto houver fundos disponíveis, e a Platform registra um evento de conclusão ou falha. Se as cobranças levarem o saldo para um valor negativo, as execuções pagas ativas na nuvem serão interrompidas, e o tempo de GPU já utilizado será cobrado.
O uso da nuvem é cobrado conforme o treinamento avança. Se uma cobrança levar seu saldo para um valor negativo, as execuções ativas de treinamento pago na nuvem serão interrompidas, e o tempo de GPU já utilizado será cobrado. Adicione créditos ou ative a recarga automática para manter os trabalhos longos financiados.
Saldo negativoUm saldo zero ou negativo impede novos trabalhos pagos de treinamento na nuvem. Um saldo negativo decorrente de cobranças por uso também aciona o encerramento das execuções ativas de treinamento pago na nuvem.
As estimativas de custo são aproximadas — o tempo real de treinamento pode variar devido a fatores como a velocidade de carregamento dos dados, o aquecimento da GPU e o comportamento de convergência do modelo. Se o uso real esgotar o saldo disponível, a Platform interromperá as execuções pagas ativas na nuvem depois que o saldo ficar negativo.
Para gerenciar os custos:
- Acompanhe o progresso do treinamento em tempo real e cancele-o antecipadamente, se necessário
- Ative a recarga automática para repor os créditos automaticamente
- Comece com execuções mais curtas (menos épocas) para calibrar as expectativas
Sim, expanda a seção Configurações avançadas na caixa de diálogo de treinamento para acessar um editor YAML com mais de 50 parâmetros configuráveis. Os valores não padrão são incluídos nos comandos de treinamento na nuvem e local.
O editor YAML também permite importar configurações de execuções de treinamento anteriores:
- Copiar de um modelo existente: Na página de qualquer modelo concluído, o cartão Configuração de treinamento tem um menu Exportar dados com a opção Copiar JSON. Cole o JSON diretamente no editor YAML — o formato JSON é detectado automaticamente e todos os parâmetros são importados. O mesmo menu permite baixar a configuração como CSV ou JSON.
- Colar YAML ou JSON: Cole no editor qualquer configuração de treinamento YAML ou JSON válida. Os parâmetros são validados automaticamente, os valores fora do intervalo são ajustados aos limites e avisos são exibidos.
- Arrastar e soltar arquivos: Arraste um arquivo
.yamlou.jsondiretamente para o editor para importar os parâmetros.

Isso facilita reproduzir ou iterar sobre configurações de treinamento anteriores sem precisar inserir cada parâmetro novamente.
Com o
optimizer: autopadrão, o treinamento escolhe o otimizador e a taxa de aprendizado inicial para você e ignora seulr0. Para usar seu própriolr0, escolha um otimizador específico, comoSGDouAdamW, em Configurações avançadas. O console de treinamento registra o otimizador e a taxa de aprendizado selecionados para a execução; o cartão Configuração de treinamento mostra os argumentos que você enviou, portanto, comauto, ele ainda pode listar seulr0.Sim. Um modelo com falha exibe um banner de erro com a ação Tentar treinamento novamente, que reabre a caixa de diálogo de treinamento com o mesmo modelo base, conjunto de dados e parâmetros, para que você possa ajustar um valor e começar novamente. A nova tentativa reutiliza a mesma página do modelo: os gráficos, a saída do console, as métricas do sistema e o erro da execução anterior são apagados quando o novo trabalho é criado, e os pesos são substituídos quando a nova execução produz um checkpoint melhor.
Sim, o botão Novo modelo nas páginas de conjuntos de dados abre a caixa de diálogo de treinamento com o conjunto de dados pré-selecionado e bloqueado. Em seguida, selecione um projeto e um modelo para iniciar o treinamento.