Treina o teu primeiro modelo

Exemplo prático: treinar o detetor de comprimidos#

A caixa de diálogo Train New Model da Ultralytics Platform pede as mesmas opções que o código abaixo — modelo base, conjunto de dados, épocas e tamanho da imagem — e executa-as em GPUs na cloud ou gera o comando local correspondente. Estas definições permitem concluir o treino em cerca de um minuto num CPU de portátil:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")  # pré-treinado em COCO
results = model.train(data="my_dataset/data.yaml", epochs=10, imgsz=320, name="pills_v1")
print(results.save_dir)

CLI e Python são equivalentes. epochs=10 e imgsz=320 mantêm curtas as execuções em CPU; com um GPU, omite ambos e aceita as predefinições (epochs=100, imgsz=640), porque mais épocas e píxeis quase sempre ajudam. O modo Train executa este ciclo por ti:

Lê o registo linha a linha#

Resultado real, reduzido às duas primeiras e às duas últimas épocas:

optimizer: AdamW(lr=0.002, momentum=0.9) with parameter groups ...
Using 92 train, 23 val images for fraction=1.0 at imgsz=320
      Epoch    GPU_mem   box_loss   cls_loss    l1_loss  Instances       Size
       1/10         0G      1.818      3.899   0.008805        206        320: 100% 6/6 3.3s
                   all         23        399      0.957      0.805      0.927      0.548
       2/10         0G      1.434      3.291   0.006285        208        320: 100% 6/6 4.4s
                   all         23        399      0.953      0.911      0.964      0.592
       ...
       9/10         0G      1.121      1.103   0.005143        194        320: 100% 6/6 5.0s
                   all         23        399      0.949      0.957      0.975      0.656
      10/10         0G      1.174      1.125   0.005068        212        320: 100% 6/6 5.1s
                   all         23        399       0.97      0.957      0.977      0.659
10 epochs completed in 0.015 hours.

• optimizer: AdamW(lr=0.002 ...): a predefinição optimizer=auto escolheu o otimizador e a taxa de aprendizagem por ti.
• Using 92 train, 23 val images: confirma que estes valores correspondem ao teu conjunto de dados. Um número mais baixo significa que algumas imagens foram ignoradas.
• GPU_mem 0G: treino no CPU. Num GPU, verias aqui a memória em utilização; 0G numa máquina com GPU significa que o GPU não está a ser utilizado.
• Primeira linha de cada época: as três perdas do conjunto de treino, mais o número de objetos anotados no último lote (Instances) e o tamanho da imagem.
• Linha all de cada época: precisão, revocação, mAP50 e mAP50-95 no conjunto de validação. É esta linha que deves observar.

Neste caso, o mAP50-95 passou da referência de 0.0002 para 0.548 após uma época e 0.659 após dez. A precisão caiu para 0.80 na época 4 e recuperou: os resultados de épocas isoladas são ruidosos com 23 imagens de validação, por isso avalia a tendência, não uma única linha. Regras para tomar decisões enquanto a execução está ativa:

• As perdas diminuem e o mAP aumenta: deixa a execução continuar.
• As perdas mantêm-se estáveis desde a época 1: interrompe com Ctrl+C e verifica os rótulos e o YAML.
• A precisão é muito superior à revocação: o modelo é cauteloso e não deteta alguns objetos. A revocação é muito superior à precisão: o modelo deteta objetos onde não existem.
• O mAP mantém-se estável durante muitas épocas: mais épocas não vão ajudar; altera os dados ou imgsz.

As três perdas são componentes da função de perda de YOLO26; o guia de métricas de desempenho explica cada métrica em detalhe.

Encontra o que a execução gerou#

Tudo fica em runs/detect/pills_v1/:

Abre primeiro train_batch0.jpg. Se as caixas não estiverem sobre os objetos, os rótulos estão errados e nenhuma quantidade de épocas vai corrigir isso.

Altera primeiro estes argumentos#

model.train(data="my_dataset/data.yaml", epochs=200, imgsz=1024, batch=-1, patience=20, name="pills_v1_1024")

A predefinição 100 de patience significa que uma execução de 100 épocas nunca para antecipadamente. Um valor mais baixo termina uma execução estagnada quando as curvas acima indicam que deve parar; best.pt é mantido em qualquer dos casos.

Com vários GPUs, passa uma lista como device=[0, 1, 2, 3]: o Ultralytics inicia o treino distribuído com paralelismo de dados (DDP) por ti, batch corresponde ao total entre os GPUs e o treino utiliza precisão mista por predefinição (amp=True). Quando a execução ultrapassar a capacidade do teu portátil, o mesmo conjunto de dados e os mesmos argumentos podem ser executados em GPUs na cloud através da Ultralytics Platform, como explicado em Treinar, ler e ajustar finamente execuções.

Evita estes erros#

O guia de sugestões para o treino de modelos aborda os restantes argumentos e o guia de ajuste de hiperparâmetros aborda as variações da taxa de aprendizagem e o ajustador genético. O guia de ajuste fino aborda o congelamento de camadas.