Configurar o YOLOv8 para GPU: Acelerar a Detecção de Objetos

Introdução

YOLOv8, desenvolvido pela Ultralytics em 2023, surgiu como um dos algoritmos de detecção de objetos únicos na série YOLO e traz melhorias significativas em termos arquitetônicos e de desempenho em relação aos seus antecessores, como YOLOv5. Essas melhorias incluem uma espinha dorsal CSPNet para melhor extração de características, um pescoço FPN+PAN para uma detecção de objetos em várias escalas aprimorada, e uma mudança para uma abordagem livre de âncoras. Essas mudanças melhoram significativamente a precisão, eficiência e usabilidade do modelo para detecção de objetos em tempo real.

O uso de uma GPU com YOLOv8 pode impulsionar significativamente o desempenho para tarefas de detecção de objetos, proporcionando treinamento e inferência mais rápidos. Este guia irá orientá-lo na configuração do YOLOv8 para uso de GPU, incluindo configuração, solução de problemas e dicas de otimização.

YOLOv8

O YOLOv8 se baseia em seus predecessores com design avançado de rede neural e técnicas de treinamento para melhorar o desempenho na detecção de objetos. Ele unifica a localização e classificação de objetos em um único framework eficiente, equilibrando velocidade e precisão. A arquitetura é composta por três componentes principais:

1. Backbone: Uma espinha dorsal de CNN altamente otimizada, potencialmente baseada no CSPDarknet, extrai características em várias escalas usando camadas eficientes como convoluções separáveis em profundidade, garantindo alto desempenho com sobrecarga computacional mínima.
2. Neck: Uma Rede de Agregação de Caminho (PANet) aprimorada refina e integra características em várias escalas para detectar melhor objetos de diversos tamanhos. É otimizado para eficiência e uso de memória.
3. Head: A cabeça sem âncora prevê caixas delimitadoras, scores de confiança e rótulos de classe, simplificando previsões e melhorando a adaptabilidade a formas e escalas de objetos diversas.

Essas inovações tornam o YOLOv8 mais rápido, preciso e versátil para tarefas modernas de detecção de objetos. Além disso, o YOLOv8 introduz uma abordagem sem âncoras para previsão de caixas delimitadoras, afastando-se dos métodos baseados em âncoras das versões anteriores.

Por que usar uma GPU com o YOLOv8?

O YOLOv8 (You Only Look Once, Versão 8) é um poderoso framework de detecção de objetos. Enquanto ele funciona em CPUs, utilizar uma GPU oferece alguns benefícios chave, tais como:

• Velocidade: GPUs lidam com cálculos paralelos de forma mais eficiente, reduzindo os tempos de treinamento e inferência.
• Escala: Conjuntos de dados e modelos maiores são gerenciáveis com GPUs.
• Desempenho Aprimorado: A detecção de objetos em tempo real se torna viável, possibilitando aplicações como veículos autônomos, vigilância e processamento de vídeo ao vivo.

As GPUs são a escolha clara para obter resultados mais rápidos e lidar com tarefas mais complexas com o YOLOv8.

CPU vs. GPU

Ao trabalhar com YOLOv8 ou qualquer modelo de detecção de objetos, a escolha entre CPU e GPU pode impactar significativamente o desempenho do modelo tanto para treinamento quanto para inferência. CPUs, como sabemos, são ótimas para fins gerais e podem lidar eficientemente com tarefas menores. No entanto, as CPUs falham quando a tarefa se torna computacionalmente cara. Tarefas como detecção de objetos requerem velocidade e computação paralela, e as GPUs são projetadas para lidar com tarefas de processamento paralelo de alto desempenho. Portanto, elas são ideais para executar modelos de aprendizado profundo como YOLO. Por exemplo, treinamento e inferência em uma GPU podem ser 10 a 50 vezes mais rápidos do que em uma CPU, dependendo do hardware e do tamanho do modelo.

A diferença se torna ainda mais pronunciada durante o treinamento, onde as GPUs encurtam dramaticamente as épocas em comparação com as CPUs. Esse aumento de velocidade permite que as GPUs processem conjuntos de dados maiores e realizem detecção de objetos em tempo real de forma mais eficiente.

Pré-requisitos para usar o YOLOv8 com GPU

Antes de configurar o YOLOv8 para GPU, certifique-se de atender aos seguintes requisitos:

1. Requisitos de Hardware

• GPU NVIDIA: O YOLOv8 depende do CUDA para aceleração da GPU, então você precisará de uma GPU NVIDIA com uma Capacidade de Computação CUDA de 6.0 ou superior.
• Memória: Recomenda-se pelo menos 8GB de memória de GPU para conjuntos de dados moderados. Para conjuntos de dados maiores, é preferível 16GB ou mais.

2. Requisitos de Software

• Python: Versão 3.8 ou posterior.
• PyTorch: Instalado com suporte para GPU (via CUDA). Preferencialmente GPU NVIDIA.
• CUDA Toolkit e cuDNN: Certifique-se de que estão compatíveis com a sua versão do PyTorch.
• YOLOv8: Instalável a partir do repositório Ultralytics.

3. Requisitos de Driver

• Download e instale os drivers mais recentes da NVIDIA no site da NVIDIA.
• Verifique a disponibilidade da sua GPU usando nvidia-smi após a instalação do driver.

Guia Passo a Passo para Configurar YOLOv8 para GPU

1. Instalar Drivers da NVIDIA

Para instalar os drivers da NVIDIA:

• Identifique sua GPU usando o código abaixo:

nvidia-smi

• Visite a página de Download de Drivers NVIDIA e faça o download do driver apropriado.
• Siga as instruções de instalação para o seu sistema operacional.
• Reinicie o seu computador para aplicar as alterações.
• Verifique a instalação executando:

nvidia-smi

• Este comando exibe informações da GPU e confirma a funcionalidade do driver.

2. Instale o CUDA Toolkit e cuDNN

Para usar o YOLOv8, precisamos selecionar a versão apropriada do PyTorch, que por sua vez requer a versão do CUDA.

Passos para Instalar o CUDA Toolkit

1. Faça o download da versão apropriada do CUDA Toolkit no site do Desenvolvedor NVIDIA.
2. Instale o CUDA Toolkit e defina as variáveis de ambiente (por exemplo, PATH, LD_LIBRARY_PATH).
3. Verifique a instalação executando:

nvcc --version

Assegurar que você tem a versão mais recente do CUDA permitirá que o PyTorch utilize a GPU de forma eficaz

Passos para Instalar o cuDNN

1. Baixe o cuDNN do site Desenvolvedor NVIDIA.
2. Extraia o conteúdo e copie para os diretórios CUDA correspondentes (por exemplo, bin, include, lib).
3. Assegure que a versão do cuDNN corresponda à sua instalação do CUDA.

3. Instale o PyTorch com Suporte para GPU

Para instalar o PyTorch com suporte para GPU, visite a página Início do PyTorch e selecione o comando de instalação apropriado. Por exemplo:

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu117

4. Instale e Execute o YOLOv8

Instale o YOLOv8 seguindo estes passos:

• Instale Ultralytics para trabalhar com yolov8 e importe as bibliotecas necessárias

pip install ultralytics

• Exemplo de Script Python:

from Ultralytics import YOLO
# Carregue um modelo YOLOv8n pré-treinado no COCO

model = YOLO("yolov8n.pt")

# Exiba informações do modelo (opcional)
model.info()

# Treine o modelo no conjunto de dados de exemplo COCO8 por 100 épocas
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device = ‘cuda’)

# Execute inferência com o modelo YOLOv8n na imagem 'bus.jpg'
results = model("path/to/image.jpg")

• Exemplo para Linha de Comando:

# use os comandos da CLI para executar o modelo diretamente:
from Ultralytics import YOLO

# Carregar um modelo YOLOv8n pré-treinado no COCO
model = YOLO("yolov8n.pt")

# Exibir informações do modelo (opcional)
model.info()

# Treinar o modelo no conjunto de dados de exemplo COCO8 por 100 épocas
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)

# Executar inferência com o modelo YOLOv8n na imagem 'bus.jpg'
results = model("path/to/image.jpg")

5. Verificar Configuração da GPU no YOLOv8

Use o seguinte comando Python para verificar se sua GPU está sendo detectada e se o CUDA está habilitado:

import torch
# Verificar se a GPU está disponível
print("CUDA Available:", torch.cuda.is_available())

# Obter detalhes da GPU
if torch.cuda.is_available():
    print("GPU Name:", torch.cuda.get_device_name(0))

6. Treinar ou Inferir com GPU

Especifique o dispositivo como cuda em seus comandos de treinamento ou inferência:

Exemplo de Linha de Comando

yolo task=detect mode=train data=coco.yaml model=yolov8n.pt device=0 epochs = 128 plots = True

Validar o modelo personalizado

yolo task=detect mode=val model={HOME}/runs/detect/train/weights/best.pt data={dataset.location}/data.yaml

Exemplo de Script Python

from ultralytics import YOLO

Carregue o modelo YOLOv8
model = YOLO('yolov8n.pt')

 Treine o modelo na GPU
model.train(data='coco.yaml', epochs=50, device='cuda')

 Realize inferência na GPU
results = model.predict(source='input.jpg', device='cuda')

Por que escolher os Droplets com GPU da DigitalOcean?

Os Droplets com GPU da DigitalOcean são projetados para lidar com tarefas de AI e aprendizado de máquina de alto desempenho. Os H100s alimentam esses Droplets com GPU para fornecer velocidade excepcional e capacidades de processamento paralelo, tornando-os ideais para treinar e executar modelos YOLOv8 de forma eficiente. Além disso, esses droplets vêm pré-instalados com a versão mais recente do CUDA, garantindo que você possa começar a aproveitar a aceleração da GPU sem precisar gastar tempo em configurações manuais. Esse ambiente simplificado permite que você se concentre totalmente na otimização de seus modelos YOLOv8 e escalonamento de seus projetos sem esforço.

Solução de Problemas de Problemas Comuns

1. YOLOv8 Não Utilizando a GPU

• Verifique a disponibilidade da GPU usando

torch.cuda.is_available()

• Verifique a compatibilidade com CUDA e PyTorch.
• Certifique-se de especificar device=0 ou device='cuda' nos comandos ou scripts.
• Atualize os drivers da NVIDIA e reinstale o CUDA Toolkit, se necessário.

2. Erros do CUDA

• Garanta que a versão do CUDA Toolkit corresponda aos requisitos do PyTorch.
• Verifique a instalação do cuDNN executando scripts de diagnóstico.
• Verifique as variáveis de ambiente para CUDA (PATH e LD_LIBRARY_PATH).

3. Desempenho Lento

• Ative o treinamento de precisão mista para otimizar o uso de memória e velocidade:

model.train(data='coco.yaml', epochs=50, device='cuda', amp=True)

• Reduza o tamanho do lote se o uso de memória estiver muito alto.
• Certifique-se de ter um sistema otimizado para execução de processamento paralelo e considere usar o processamento em lote em seu script de detecção para aprimorar o desempenho.

from Ultralytics import YOLO

# Carregar os modelos
vehicle_model = YOLO('yolov8l.pt')
license_model = YOLO('Registration.pt')

# Processar cada fluxo, exemplo para um fluxo
results = vehicle_model(source='stream1.mp4', batch=4)  # Modificar conforme necessário para processamento paralelo

FAQs

Como habilitar a GPU para o YOLOv8?

Especifique device='cuda' ou device=0 (se estiver usando a primeira GPU) em seus comandos ou scripts ao carregar o modelo. Isso permitirá que o YOLOv8 utilize a GPU para uma computação mais rápida durante a inferência e treinamento. Certifique-se de que sua GPU está configurada corretamente e detectada.

model = YOLO("yolov8n.pt") 
model.to('cuda')

Por que o YOLOv8 não está usando minha GPU?

O YOLOv8 pode não estar utilizando a GPU se houver problemas com o hardware, drivers ou configuração.
Para começar, verifique a instalação do CUDA e a compatibilidade com o PyTorch. Atualize os drivers, se necessário. Certifique-se de que seu CUDA e CuDNN são compatíveis com sua instalação do PyTorch.
Instale o torchvision e verifique a configuração que está sendo instalada e usada.

pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118`

import torch print(torch.cuda.get_device_name())

Além disso, se o PyTorch não estiver instalado com suporte para GPU (por exemplo, uma versão apenas para CPU), ou se o parâmetro device em seus comandos YOLOv8 não estiver explicitamente definido como cuda. Executar o YOLOv8 em um sistema sem uma GPU compatível com CUDA ou com VRAM insuficiente também pode fazer com que ele seja configurado para usar a CPU por padrão.

Para resolver isso, certifique-se de que sua GPU é compatível com CUDA, verifique a instalação de todas as dependências necessárias, verifique se torch.cuda.is_available() retorna True, e especifique explicitamente o parâmetro device='cuda' em seus scripts ou comandos do YOLOv8.

Quais são os requisitos de hardware para o YOLOv8 em GPU?

Para instalar e executar efetivamente o YOLOv8 em uma GPU, é recomendado o Python 3.7 ou superior, e uma GPU compatível com CUDA é necessária para usar a aceleração da GPU.

Uma GPU moderna da NVIDIA com pelo menos 8GB de memória é recomendada. Para conjuntos de dados grandes, mais memória é benéfica. Para obter um desempenho ótimo, é recomendado usar Python 3.8 ou mais recente, PyTorch 1.10 ou superior, e uma GPU da NVIDIA compatível com CUDA 11.2+. A GPU deve idealmente ter pelo menos 8GB de VRAM para lidar eficientemente com conjuntos de dados moderados, embora mais VRAM seja benéfico para conjuntos de dados maiores e modelos complexos. Além disso, seu sistema deve ter pelo menos 8GB de RAM e 50GB de espaço em disco livre para armazenar conjuntos de dados e facilitar o treinamento do modelo. Garantir essas configurações de hardware e software ajudará você a alcançar um treinamento e inferência mais rápidos com o YOLOv8, especialmente para tarefas computacionalmente intensivas.

Observação: As GPUs da AMD podem não suportar CUDA, portanto, escolher uma GPU da NVIDIA para compatibilidade com o YOLOv8 é essencial.

O YOLOv8 pode ser executado em várias GPUs?

Para treinar o YOLOv8 usando várias GPUs, você pode usar o DataParallel do PyTorch ou especificar diretamente vários dispositivos (por exemplo, cuda:0,1). Para treinamento distribuído, o YOLOv8 utiliza por padrão o Multi-GPU DistributedDataParallel (DDP) do PyTorch. Certifique-se de que seu sistema tenha várias GPUs disponíveis e especifique as GPUs que deseja usar no script de treinamento ou na linha de comando. Por exemplo, defina --device 0,1,2,3 na CLI ou device=[0,1,2,3] em Python para utilizar as GPUs 0, 1, 2 e 3. O YOLOv8 lida automaticamente com o treinamento paralelo nas GPUs especificadas sem exigir um argumento data_parallel explícito. Embora todas as GPUs sejam utilizadas durante o treinamento, a fase de validação geralmente é executada em uma única GPU por padrão, pois é menos intensiva em recursos do que o treinamento.

Como otimizar o YOLOv8 para inferência na GPU?

Habilite a precisão mista e ajuste os tamanhos dos lotes para equilibrar memória e velocidade. Dependendo do seu conjunto de dados, treinar o YOLOv8 requer bastante poder de computação para ser executado de forma eficiente. Use uma variante de modelo menor ou quantizado (por exemplo, versões quantizadas YOLOv8n ou INT8) para reduzir o uso de memória e o tempo de inferência. Em seu script de inferência, defina explicitamente o parâmetro device como cuda para execução GPU. Utilize técnicas como inferência em lote para processar várias imagens simultaneamente e maximizar a utilização da GPU. Se aplicável, utilize o TensorRT para otimizar ainda mais o modelo para uma inferência GPU mais rápida. Monitore regularmente a memória da GPU e o desempenho para garantir o uso eficiente dos recursos.

O trecho de código abaixo permitirá que você processe imagens em paralelo dentro do tamanho de lote definido.

from Ultralytics import YOLO
model = YOLO('yolov8n.pt', device='cpu', batch=4)  # especifique o tamanho do lote conforme necessário

# passe o argumento 'imagens', que é a lista de imagens pré-processadas
results = model.predict(images)  # 'imagens' deve ter o formato (N, 3, H, W)

Se estiver utilizando a CLI, especifique o tamanho do lote com -b ou –batch-size. Com Python, certifique-se de que o argumento de lote esteja corretamente configurado ao inicializar seu modelo ou chamar o método de previsão.

Como resolver problemas de falta de memória CUDA?

Para resolver erros de falta de memória do CUDA, reduza o tamanho do lote de validação no arquivo de configuração do YOLOv8, pois lotes menores exigem menos memória da GPU. Além disso, se você tiver acesso a várias GPUs, considere distribuir a carga de trabalho de validação entre elas usando o DistributedDataParallel do PyTorch ou funcionalidade similar, embora isso exija conhecimento avançado do PyTorch. Você também pode tentar limpar a memória em cache usando torch.cuda.empty_cache() em seu script e garantir que nenhum processo desnecessário esteja sendo executado em sua GPU. Fazer upgrade para uma GPU com mais VRAM ou otimizar seu modelo e conjunto de dados para eficiência de memória são passos adicionais para mitigar tais problemas.

Conclusão

Configurar o YOLOv8 para utilizar uma GPU é um processo simples que pode melhorar significativamente o desempenho. Seguindo este guia detalhado, você pode acelerar o treinamento e inferência para suas tarefas de detecção de objetos. Otimize sua configuração, resolva problemas comuns e desbloqueie todo o potencial do YOLOv8 com aceleração da GPU.

Referências

• Como treinar o yolov8 com múltiplas GPUs? · Issue #3308
• O QUE É YOLOv8: UMA EXPLORAÇÃO PROFUNDA DAS CARACTERÍSTICAS INTERNAS DO DETECTOR DE OBJETOS DA PRÓXIMA GERAÇÃO