Treinamento de Modelo com Ultralytics YOLO
Introdução
O treinamento de um modelo de aprendizado profundo envolve alimentá-lo com dados e ajustar seus parâmetros para que ele possa fazer previsões precisas. O modo de treinamento no Ultralytics YOLO11 foi projetado para um treinamento eficaz e eficiente de modelos de detecção de objetos, utilizando totalmente os recursos de hardware modernos. Este guia tem como objetivo cobrir todos os detalhes que você precisa para começar a treinar seus próprios modelos usando o conjunto robusto de recursos do YOLO11.
Assista: Como treinar um modelo YOLO em seu conjunto de dados personalizado no Google Colab.
Por que escolher Ultralytics YOLO para Treinamento?
Aqui estão algumas razões convincentes para optar pelo modo de treinamento do YOLO11:
- Eficiência: Aproveite ao máximo seu hardware, seja em uma configuração de GPU única ou escalando em várias GPUs.
- Versatilidade: Treine em conjuntos de dados personalizados, além dos disponíveis como COCO, VOC e ImageNet.
- Fácil de usar: Interfaces CLI e python simples, porém poderosas, para uma experiência de treinamento direta.
- Flexibilidade de Hiperparâmetros: Uma ampla gama de hiperparâmetros personalizáveis para ajustar o desempenho do modelo.
Principais Recursos do Modo Train
A seguir, estão alguns recursos notáveis do modo de treinamento do YOLO11:
- Download Automático de Conjunto de Dados: Conjuntos de dados padrão como COCO, VOC e ImageNet são baixados automaticamente no primeiro uso.
- Suporte Multi-GPU: Escale seus esforços de treinamento perfeitamente em várias GPUs para acelerar o processo.
- Configuração de Hiperparâmetros: A opção de modificar hiperparâmetros por meio de arquivos de configuração YAML ou argumentos de CLI.
- Visualização e Monitoramento: Rastreamento em tempo real de métricas de treinamento e visualização do processo de aprendizado para melhores insights.
Dica
- Conjuntos de dados YOLO11 como COCO, VOC, ImageNet e muitos outros são baixados automaticamente no primeiro uso, ou seja.
yolo train data=coco.yaml
Exemplos de uso
Treine o YOLO11n no conjunto de dados COCO8 para 100 épocas no tamanho de imagem 640. O dispositivo de treinamento pode ser especificado usando o device argumento. Se nenhum argumento for passado, a GPU device=0 será usada se estiver disponível, caso contrário, device='cpu' será usado. Consulte a seção Argumentos abaixo para obter uma lista completa de argumentos de treinamento.
Erro de Multiprocessamento do Windows
No Windows, você pode receber um RuntimeError ao iniciar o treinamento como um script. Adicione um if __name__ == "__main__": bloqueie antes do seu código de treinamento para resolver isso.
Exemplo de Treinamento de GPU Única e CPU
O dispositivo é determinado automaticamente. Se uma GPU estiver disponível, ela será usada (dispositivo CUDA padrão 0), caso contrário, o treinamento será iniciado na CPU.
from ultralytics import YOLO
# Load a model
model = YOLO("yolo11n.yaml") # build a new model from YAML
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
model = YOLO("yolo11n.yaml").load("yolo11n.pt") # build from YAML and transfer weights
# Train the model
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)
# Build a new model from YAML and start training from scratch
yolo detect train data=coco8.yaml model=yolo11n.yaml epochs=100 imgsz=640
# Start training from a pretrained *.pt model
yolo detect train data=coco8.yaml model=yolo11n.pt epochs=100 imgsz=640
# Build a new model from YAML, transfer pretrained weights to it and start training
yolo detect train data=coco8.yaml model=yolo11n.yaml pretrained=yolo11n.pt epochs=100 imgsz=640
Treinamento Multi-GPU
O treinamento multi-GPU permite uma utilização mais eficiente dos recursos de hardware disponíveis, distribuindo a carga de treinamento por várias GPUs. Este recurso está disponível através da API python e da interface de linha de comando. Para habilitar o treinamento multi-GPU, especifique os IDs de dispositivo GPU que você deseja usar.
Exemplo de Treinamento Multi-GPU
Para treinar com 2 GPUs, dispositivos CUDA 0 e 1, use os seguintes comandos. Expanda para GPUs adicionais conforme necessário.
from ultralytics import YOLO
# Load a model
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
# Train the model with 2 GPUs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[0, 1])
# Train the model with the two most idle GPUs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -1])
# Start training from a pretrained *.pt model using GPUs 0 and 1
yolo detect train data=coco8.yaml model=yolo11n.pt epochs=100 imgsz=640 device=0,1
# Use the two most idle GPUs
yolo detect train data=coco8.yaml model=yolo11n.pt epochs=100 imgsz=640 device=-1,-1
Treinamento com GPU Ociosa
O Treinamento com GPU Ociosa permite a seleção automática das GPUs menos utilizadas em sistemas multi-GPU, otimizando o uso de recursos sem seleção manual de GPU. Este recurso identifica as GPUs disponíveis com base nas métricas de utilização e disponibilidade de VRAM.
Exemplo de Treinamento com GPU Ociosa
Para selecionar e usar automaticamente a(s) GPU(s) mais ociosa(s) para treinamento, use o -1 parâmetro device. Isso é particularmente útil em ambientes de computação compartilhada ou servidores com vários usuários.
from ultralytics import YOLO
# Load a model
model = YOLO("yolov8n.pt") # load a pretrained model (recommended for training)
# Train using the single most idle GPU
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=-1)
# Train using the two most idle GPUs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[-1, -1])
# Start training using the single most idle GPU
yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640 device=-1
# Start training using the two most idle GPUs
yolo detect train data=coco8.yaml model=yolov8n.pt epochs=100 imgsz=640 device=-1,-1
O algoritmo de seleção automática prioriza GPUs com:
- Menores percentagens de utilização atuais
- Maior memória disponível (VRAM livre)
- Menor temperatura e consumo de energia
Este recurso é especialmente valioso em ambientes de computação compartilhada ou ao executar vários trabalhos de treinamento em diferentes modelos. Ele se adapta automaticamente às condições variáveis do sistema, garantindo a alocação ideal de recursos sem intervenção manual.
Treinamento MPS em Apple Silicon
Com o suporte para chips de silício da Apple integrados nos modelos Ultralytics YOLO, agora é possível treinar seus modelos em dispositivos que utilizam a poderosa estrutura Metal Performance Shaders (MPS). O MPS oferece uma maneira de alto desempenho de executar tarefas de computação e processamento de imagem no silício personalizado da Apple.
Para ativar o treinamento em chips de silício da Apple, você deve especificar 'mps' como seu dispositivo ao iniciar o processo de treinamento. Abaixo está um exemplo de como você pode fazer isso em python e através da linha de comando:
Exemplo de Treinamento com MPS
from ultralytics import YOLO
# Load a model
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
# Train the model with MPS
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")
# Start training from a pretrained *.pt model using MPS
yolo detect train data=coco8.yaml model=yolo11n.pt epochs=100 imgsz=640 device=mps
Ao aproveitar o poder computacional dos chips de silício da Apple, isso permite um processamento mais eficiente das tarefas de treinamento. Para obter orientações mais detalhadas e opções de configuração avançadas, consulte a documentação do PyTorch MPS.
Retomada de Treinamentos Interrompidos
Retomar o treinamento de um estado previamente salvo é um recurso crucial ao trabalhar com modelos de aprendizado profundo. Isso pode ser útil em vários cenários, como quando o processo de treinamento foi inesperadamente interrompido ou quando você deseja continuar treinando um modelo com novos dados ou por mais épocas.
Quando o treinamento é retomado, o Ultralytics YOLO carrega os pesos do último modelo salvo e também restaura o estado do otimizador, o planejador de taxa de aprendizado e o número da época. Isso permite que você continue o processo de treinamento perfeitamente de onde parou.
Você pode facilmente retomar o treinamento no Ultralytics YOLO definindo o argumento resume para True ao chamar o método train e especificando o caminho para o arquivo .pt contendo os pesos do modelo parcialmente treinado.
Abaixo está um exemplo de como retomar um treinamento interrompido usando python e através da linha de comando:
Exemplo de Retomada de Treinamento
from ultralytics import YOLO
# Load a model
model = YOLO("path/to/last.pt") # load a partially trained model
# Resume training
results = model.train(resume=True)
# Resume an interrupted training
yolo train resume model=path/to/last.pt
Ao definir resume=True, a função train continuará o treinamento de onde parou, usando o estado armazenado no arquivo 'path/to/last.pt'. Se o argumento resume for omitido ou definido como False, a função train , a função iniciará uma nova sessão de treinamento.
Lembre-se de que os checkpoints são salvos no final de cada época por padrão, ou em intervalos fixos usando o argumento save_period , então você deve completar pelo menos 1 época para retomar uma execução de treinamento.
Configurações de Treinamento
As configurações de treinamento para modelos YOLO abrangem vários hiperparâmetros e configurações usadas durante o processo de treinamento. Essas configurações influenciam o desempenho, a velocidade e a precisão do modelo. As principais configurações de treinamento incluem tamanho do lote, taxa de aprendizado, momentum e decaimento de peso. Além disso, a escolha do otimizador, da função de perda e da composição do conjunto de dados de treinamento pode impactar o processo de treinamento. O ajuste cuidadoso e a experimentação com essas configurações são cruciais para otimizar o desempenho.
| Argumento | Tipo | Padrão | Descrição |
|---|---|---|---|
model |
str |
None |
Especifica o arquivo do modelo para treinamento. Aceita um caminho para um .pt modelo pré-treinado ou um .yaml arquivo de configuração. Essencial para definir a estrutura do modelo ou inicializar os pesos. |
data |
str |
None |
Caminho para o arquivo de configuração do conjunto de dados (por exemplo, coco8.yaml). Este arquivo contém parâmetros específicos do conjunto de dados, incluindo caminhos para treinamento e dados de validaçãovalidação, nomes de classes e número de classes. |
epochs |
int |
100 |
Número total de épocas de treinamento. Cada época representa uma passagem completa por todo o conjunto de dados. Ajustar este valor pode afetar a duração do treinamento e o desempenho do modelo. |
time |
float |
None |
Tempo máximo de treinamento em horas. Se definido, isso substitui o epochs argumento, permitindo que o treinamento pare automaticamente após a duração especificada. Útil para cenários de treinamento com restrição de tempo. |
patience |
int |
100 |
Número de épocas a esperar sem melhorias nas métricas de validação antes de interromper o treinamento precocemente. Ajuda a prevenir overfitting ao interromper o treinamento quando o desempenho estabiliza. |
batch |
int ou float |
16 |
Tamanho do lote (Batch size), com três modos: definido como um inteiro (por exemplo, batch=16auto mode para 60% de utilização da memória da GPU (batch=-1auto mode com fração de utilização especificada (batch=0.70). |
imgsz |
int ou list |
640 |
Tamanho da imagem alvo para treinamento. Todas as imagens são redimensionadas para esta dimensão antes de serem inseridas no modelo. Afeta a precisão do modelo e a complexidade computacional. |
save |
bool |
True |
Permite salvar checkpoints de treinamento e pesos do modelo final. Útil para retomar o treinamento ou para o implantação do modelo. |
save_period |
int |
-1 |
Frequência de salvamento dos checkpoints do modelo, especificada em épocas. Um valor de -1 desativa este recurso. Útil para salvar modelos provisórios durante longas sessões de treinamento. |
cache |
bool |
False |
Permite o armazenamento em cache de imagens do conjunto de dados na memória (True/ramarmazenamento em disco (diskou desativa (False). Melhora a velocidade de treinamento, reduzindo as operações de E/S no disco, ao custo de maior uso de memória. |
device |
int ou str ou list |
None |
Especifica o(s) dispositivo(s) computacional(is) para treinamento: uma única GPU (device=0várias GPUs (device=[0,1]CPU (device=cpu), MPS para Apple silicon (device=mps), ou seleção automática da GPU mais ociosa (device=-1) ou várias GPUs ociosas (device=[-1,-1]) |
workers |
int |
8 |
Número de threads de trabalho para carregamento de dados (por RANK se treinamento Multi-GPU). Influencia a velocidade do pré-processamento de dados e alimentação no modelo, especialmente útil em configurações multi-GPU. |
project |
str |
None |
Nome do diretório do projeto onde as saídas de treinamento são salvas. Permite o armazenamento organizado de diferentes experimentos. |
name |
str |
None |
Nome da execução de treinamento. Usado para criar um subdiretório dentro da pasta do projeto, onde os logs e saídas de treinamento são armazenados. |
exist_ok |
bool |
False |
Se True, permite sobrescrever um diretório de projeto/nome existente. Útil para experimentação iterativa sem a necessidade de limpar manualmente as saídas anteriores. |
pretrained |
bool ou str |
True |
Determina se o treinamento deve começar a partir de um modelo pré-treinado. Pode ser um valor booleano ou um caminho de string para um modelo específico do qual carregar os pesos. Melhora a eficiência do treinamento e o desempenho do modelo. |
optimizer |
str |
'auto' |
Escolha do otimizador para treinamento. As opções incluem SGD, Adam, AdamW, NAdam, RAdam, RMSProp etc., ou auto para seleção automática com base na configuração do modelo. Afeta a velocidade e a estabilidade da convergência. |
seed |
int |
0 |
Define a semente aleatória para o treinamento, garantindo a reprodutibilidade dos resultados em execuções com as mesmas configurações. |
deterministic |
bool |
True |
Força o uso de algoritmo determinístico, garantindo a reprodutibilidade, mas pode afetar o desempenho e a velocidade devido à restrição de algoritmos não determinísticos. |
single_cls |
bool |
False |
Trata todas as classes em conjuntos de dados multiclasse como uma única classe durante o treinamento. Útil para tarefas de classificação binária ou ao focar na presença do objeto em vez da classificação. |
classes |
list[int] |
None |
Especifica uma lista de IDs de classe para treinar. Útil para filtrar e focar apenas em certas classes durante o treinamento. |
rect |
bool |
False |
Ativa o treinamento retangular, otimizando a composição do lote para preenchimento mínimo. Pode melhorar a eficiência e a velocidade, mas pode afetar a precisão do modelo. |
multi_scale |
bool |
False |
Ativa o treinamento multi-escala aumentando/diminuindo imgsz por até um fator de 0.5 durante o treinamento. Treina o modelo para ser mais preciso com múltiplos imgsz durante a inferência. |
cos_lr |
bool |
False |
Utiliza um planejador de taxa de aprendizado de cosseno, ajustando a taxa de aprendizado seguindo uma curva de cosseno ao longo das épocas. Ajuda no gerenciamento da taxa de aprendizado para uma melhor convergência. |
close_mosaic |
int |
10 |
Desativa o aumento de dados de mosaico nas últimas N épocas para estabilizar o treinamento antes da conclusão. Definir como 0 desativa este recurso. |
resume |
bool |
False |
Retoma o treinamento a partir do último checkpoint salvo. Carrega automaticamente os pesos do modelo, o estado do otimizador e a contagem de épocas, continuando o treinamento perfeitamente. |
amp |
bool |
True |
Ativa o treinamento de Precisão Mista Automática (AMP), reduzindo o uso de memória e possivelmente acelerando o treinamento com impacto mínimo na precisão. |
fraction |
float |
1.0 |
Especifica a fração do conjunto de dados a ser usada para treinamento. Permite o treinamento em um subconjunto do conjunto de dados completo, útil para experimentos ou quando os recursos são limitados. |
profile |
bool |
False |
Permite a criação de perfis das velocidades ONNX e TensorRT durante o treinamento, útil para otimizar a implantação do modelo. |
freeze |
int ou list |
None |
Congela as primeiras N camadas do modelo ou as camadas especificadas por índice, reduzindo o número de parâmetros treináveis. Útil para ajuste fino ou transfer learning. |
lr0 |
float |
0.01 |
Taxa de aprendizado inicial (ou seja, SGD=1E-2, Adam=1E-3). Ajustar este valor é crucial para o processo de otimização, influenciando a rapidez com que os pesos do modelo são atualizados. |
lrf |
float |
0.01 |
Taxa de aprendizado final como uma fração da taxa inicial = (lr0 * lrf), usada em conjunto com os schedulers para ajustar a taxa de aprendizado ao longo do tempo. |
momentum |
float |
0.937 |
Fator de momentum para SGD ou beta1 para otimizadores Adam, influenciando a incorporação de gradientes passados na atualização atual. |
weight_decay |
float |
0.0005 |
Termo de regularização L2, penalizando pesos grandes para evitar overfitting. |
warmup_epochs |
float |
3.0 |
Número de épocas para aquecimento da taxa de aprendizado, aumentando gradualmente a taxa de aprendizado de um valor baixo para a taxa de aprendizado inicial para estabilizar o treinamento no início. |
warmup_momentum |
float |
0.8 |
Momentum inicial para a fase de aquecimento, ajustando-se gradualmente ao momentum definido durante o período de aquecimento. |
warmup_bias_lr |
float |
0.1 |
Taxa de aprendizado para parâmetros de bias durante a fase de aquecimento, ajudando a estabilizar o treinamento do modelo nas épocas iniciais. |
box |
float |
7.5 |
Peso do componente de perda da caixa na função de perda, influenciando quanta ênfase é colocada na previsão precisa das coordenadas da caixa delimitadora. |
cls |
float |
0.5 |
Peso da perda de classificação na função de perda total, afetando a importância da previsão correta da classe em relação a outros componentes. |
dfl |
float |
1.5 |
Peso da perda focal de distribuição, usado em certas versões do YOLO para classificação refinada. |
pose |
float |
12.0 |
Peso da perda de pose em modelos treinados para estimativa de pose, influenciando a ênfase na previsão precisa dos pontos-chave da pose. |
kobj |
float |
2.0 |
Peso da perda de objetividade do ponto-chave em modelos de estimativa de pose, equilibrando a confiança da detecção com a precisão da pose. |
nbs |
int |
64 |
Tamanho nominal do lote para normalização da perda. |
overlap_mask |
bool |
True |
Determina se as máscaras de objeto devem ser mescladas em uma única máscara para treinamento ou mantidas separadas para cada objeto. Em caso de sobreposição, a máscara menor é sobreposta à máscara maior durante a mesclagem. |
mask_ratio |
int |
4 |
Taxa de subamostragem para máscaras de segmentação, afetando a resolução das máscaras usadas durante o treinamento. |
dropout |
float |
0.0 |
Taxa de dropout para regularização em tarefas de classificação, prevenindo o sobreajuste ao omitir aleatoriamente unidades durante o treinamento. |
val |
bool |
True |
Ativa a validação durante o treinamento, permitindo a avaliação periódica do desempenho do modelo em um conjunto de dados separado. |
plots |
bool |
False |
Gera e salva gráficos das métricas de treinamento e validação, bem como exemplos de previsão, fornecendo insights visuais sobre o desempenho do modelo e a progressão do aprendizado. |
Nota sobre as configurações de tamanho do lote (Batch-size)
O batch O argumento pode ser configurado de três maneiras:
- Tamanho Fixo do Lote: Defina um valor inteiro (por exemplo,
batch=16), especificando o número de imagens por lote diretamente. - Modo Automático (60% de Memória da GPU): Use
batch=-1para ajustar automaticamente o tamanho do lote para aproximadamente 60% de utilização da memória CUDA. - Modo Automático com Fração de Utilização: Defina um valor de fração (por exemplo,
batch=0.70) para ajustar o tamanho do lote com base na fração especificada de uso da memória da GPU.
Configurações de Aumento de Dados e Hiperparâmetros
As técnicas de aumento são essenciais para melhorar a robustez e o desempenho dos modelos YOLO, introduzindo variabilidade nos dados de treinamento, ajudando o modelo a generalizar melhor para dados não vistos. A tabela a seguir descreve o propósito e o efeito de cada argumento de aumento:
| Argumento | Tipo | Padrão | Intervalo | Descrição |
|---|---|---|---|---|
hsv_h |
float |
0.015 |
0.0 - 1.0 |
Ajusta a tonalidade da imagem por uma fração da roda de cores, introduzindo variabilidade de cor. Ajuda o modelo a generalizar em diferentes condições de iluminação. |
hsv_s |
float |
0.7 |
0.0 - 1.0 |
Altera a saturação da imagem por uma fração, afetando a intensidade das cores. Útil para simular diferentes condições ambientais. |
hsv_v |
float |
0.4 |
0.0 - 1.0 |
Modifica o valor (brilho) da imagem por uma fração, ajudando o modelo a ter um bom desempenho em várias condições de iluminação. |
degrees |
float |
0.0 |
0.0 - 180 |
Gira a imagem aleatoriamente dentro do intervalo de graus especificado, melhorando a capacidade do modelo de reconhecer objetos em várias orientações. |
translate |
float |
0.1 |
0.0 - 1.0 |
Translação da imagem horizontal e verticalmente por uma fração do tamanho da imagem, auxiliando no aprendizado para detectar objetos parcialmente visíveis. |
scale |
float |
0.5 |
>=0.0 |
Dimensiona a imagem por um fator de ganho, simulando objetos a diferentes distâncias da câmera. |
shear |
float |
0.0 |
-180 - +180 |
Cisalha a imagem por um grau especificado, imitando o efeito de objetos sendo visualizados de diferentes ângulos. |
perspective |
float |
0.0 |
0.0 - 0.001 |
Aplica uma transformação de perspectiva aleatória à imagem, aprimorando a capacidade do modelo de entender objetos no espaço 3D. |
flipud |
float |
0.0 |
0.0 - 1.0 |
Inverte a imagem de cabeça para baixo com a probabilidade especificada, aumentando a variabilidade dos dados sem afetar as características do objeto. |
fliplr |
float |
0.5 |
0.0 - 1.0 |
Inverte a imagem da esquerda para a direita com a probabilidade especificada, útil para aprender objetos simétricos e aumentar a diversidade do conjunto de dados. |
bgr |
float |
0.0 |
0.0 - 1.0 |
Inverte os canais de imagem de RGB para BGR com a probabilidade especificada, útil para aumentar a robustez a ordenação incorreta de canais. |
mosaic |
float |
1.0 |
0.0 - 1.0 |
Combina quatro imagens de treino em uma, simulando diferentes composições de cena e interações de objetos. Altamente eficaz para a compreensão de cenas complexas. |
mixup |
float |
0.0 |
0.0 - 1.0 |
Mistura duas imagens e seus rótulos, criando uma imagem composta. Melhora a capacidade do modelo de generalizar, introduzindo ruído de rótulo e variabilidade visual. |
cutmix |
float |
0.0 |
0.0 - 1.0 |
Combina porções de duas imagens, criando uma mistura parcial enquanto mantém regiões distintas. Melhora a robustez do modelo, criando cenários de oclusão. |
copy_paste |
float |
0.0 |
0.0 - 1.0 |
Apenas Segmentação. Copia e cola objetos entre imagens para aumentar as instâncias de objetos. |
copy_paste_mode |
str |
flip |
- | Apenas segmentação. Especifica o copy-paste estratégia a ser usada. As opções incluem 'flip' e 'mixup'. |
auto_augment |
str |
randaugment |
- | Apenas classificação. Aplica uma política de aumento predefinida ('randaugment', 'autoaugment', ou 'augmix') para melhorar o desempenho do modelo através da diversidade visual. |
erasing |
float |
0.4 |
0.0 - 0.9 |
Apenas Classificação. Apaga aleatoriamente regiões da imagem durante o treinamento para incentivar o modelo a se concentrar em recursos menos óbvios. |
Essas configurações podem ser ajustadas para atender aos requisitos específicos do conjunto de dados e da tarefa em questão. Experimentar com diferentes valores pode ajudar a encontrar a estratégia de aumento ideal que leva ao melhor desempenho do modelo.
Informação
Para obter mais informações sobre as operações de aumento de treinamento, consulte a seção de referência.
Logging
Ao treinar um modelo YOLO11, pode ser valioso acompanhar o desempenho do modelo ao longo do tempo. É aqui que o registro entra em jogo. O Ultralytics YOLO oferece suporte para três tipos de loggers - Comet, ClearML e TensorBoard.
Para usar um logger, selecione-o no menu suspenso no trecho de código acima e execute-o. O logger escolhido será instalado e inicializado.
Comet
Comet é uma plataforma que permite que cientistas de dados e desenvolvedores rastreiem, comparem, expliquem e otimizem experimentos e modelos. Ele fornece funcionalidades como métricas em tempo real, diffs de código e rastreamento de hiperparâmetros.
Para usar o Comet:
Exemplo
# pip install comet_ml
import comet_ml
comet_ml.init()
Lembre-se de iniciar sessão na sua conta Comet no site deles e obter a sua chave de API. Você precisará adicionar isso às suas variáveis de ambiente ou ao seu script para registrar suas experiências.
ClearML
ClearML é uma plataforma de código aberto que automatiza o rastreamento de experimentos e ajuda no compartilhamento eficiente de recursos. Ele é projetado para ajudar as equipes a gerenciar, executar e reproduzir seu trabalho de ML de forma mais eficiente.
Para usar o ClearML:
Exemplo
# pip install clearml
import clearml
clearml.browser_login()
Depois de executar este script, você precisará iniciar sessão na sua conta ClearML no navegador e autenticar a sua sessão.
TensorBoard
TensorBoard é um kit de ferramentas de visualização para TensorFlow. Ele permite que você visualize seu gráfico TensorFlow, plote métricas quantitativas sobre a execução do seu gráfico e mostre dados adicionais, como imagens que passam por ele.
Para usar o TensorBoard no Google Colab:
Exemplo
load_ext tensorboard
tensorboard --logdir ultralytics/runs # replace with 'runs' directory
Para usar o TensorBoard localmente, execute o comando abaixo e veja os resultados em http://localhost:6006/.
Exemplo
tensorboard --logdir ultralytics/runs # replace with 'runs' directory
Isso carregará o TensorBoard e o direcionará para o diretório onde seus logs de treinamento estão salvos.
Depois de configurar seu logger, você pode prosseguir com o treinamento do seu modelo. Todas as métricas de treinamento serão registradas automaticamente na plataforma escolhida, e você pode acessar esses logs para monitorar o desempenho do seu modelo ao longo do tempo, comparar diferentes modelos e identificar áreas para melhorias.
FAQ
Como faço para treinar um modelo de detecção de objetos usando o Ultralytics YOLO11?
Para treinar um modelo de detecção de objetos usando o Ultralytics YOLO11, você pode usar a API python ou a CLI. Abaixo está um exemplo para ambos:
Exemplo de Treinamento de GPU Única e CPU
from ultralytics import YOLO
# Load a model
model = YOLO("yolo11n.pt") # load a pretrained model (recommended for training)
# Train the model
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)
yolo detect train data=coco8.yaml model=yolo11n.pt epochs=100 imgsz=640
Para mais detalhes, consulte a seção Configurações de Treinamento.
Quais são os principais recursos do modo Train do Ultralytics YOLO11?
Os principais recursos do modo de Treinamento do Ultralytics YOLO11 incluem:
- Download Automático de Dataset: Faz o download automático de datasets padrão como COCO, VOC e ImageNet.
- Suporte Multi-GPU: Escala o treinamento em várias GPUs para um processamento mais rápido.
- Configuração de Hiperparâmetros: Personalize os hiperparâmetros através de arquivos YAML ou argumentos de CLI.
- Visualização e Monitoramento: Rastreamento em tempo real das métricas de treinamento para melhores insights.
Esses recursos tornam o treinamento eficiente e personalizável às suas necessidades. Para mais detalhes, consulte a seção Principais Recursos do Modo de Treinamento.
Como faço para retomar o treinamento de uma sessão interrompida no Ultralytics YOLO11?
Para retomar o treinamento de uma sessão interrompida, defina o resume para True e especifique o caminho para o último checkpoint salvo.
Exemplo de Retomada de Treinamento
from ultralytics import YOLO
# Load the partially trained model
model = YOLO("path/to/last.pt")
# Resume training
results = model.train(resume=True)
yolo train resume model=path/to/last.pt
Verifique a seção sobre Retomada de Treinamentos Interrompidos para obter mais informações.
Posso treinar modelos YOLO11 em chips de silício da Apple?
Sim, o Ultralytics YOLO11 suporta treinamento em chips de silício da Apple utilizando a estrutura Metal Performance Shaders (MPS). Especifique 'mps' como seu dispositivo de treinamento.
Exemplo de Treinamento com MPS
from ultralytics import YOLO
# Load a pretrained model
model = YOLO("yolo11n.pt")
# Train the model on Apple silicon chip (M1/M2/M3/M4)
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device="mps")
yolo detect train data=coco8.yaml model=yolo11n.pt epochs=100 imgsz=640 device=mps
Para mais detalhes, consulte a seção Treinamento MPS em Apple Silicon.
Quais são as configurações de treinamento comuns e como as configuro?
O Ultralytics YOLO11 permite que você configure uma variedade de configurações de treinamento, como tamanho do lote, taxa de aprendizado, épocas e muito mais por meio de argumentos. Aqui está uma breve visão geral:
| Argumento | Padrão | Descrição |
|---|---|---|
model |
None |
Caminho para o arquivo do modelo para treinamento. |
data |
None |
Caminho para o arquivo de configuração do conjunto de dados (por exemplo, coco8.yaml). |
epochs |
100 |
Número total de épocas de treinamento. |
batch |
16 |
Tamanho do lote, ajustável como um número inteiro ou no modo automático. |
imgsz |
640 |
Tamanho da imagem alvo para treinamento. |
device |
None |
Dispositivo(s) computacional(is) para treinamento, como cpu, 0, 0,1, ou mps. |
save |
True |
Permite salvar checkpoints de treinamento e pesos finais do modelo. |
Para um guia detalhado sobre as configurações de treinamento, consulte a seção Configurações de Treinamento.
