Requisitos do Sistema e Configuração Inicial

Para implantar o DAMO-YOLO em um ambiente Linux, é essencial verificar as especificações do hardware. O framework é flexível, mas configurações adequadas melhoram o desempenho. Requisitos mínimos incluem uma CPU de 4 ou mais núcleos com suporte a AVX, 8GB de RAM e pelo menos 20GB de espaço em disco. Recomenda-se uma CPU de 8 núcleos com AVX2, 16GB de RAM e uma GPU NVIDIA como a RTX 3060 com 8GB de VRAM para resultados ótimos. O DAMO-YOLO é compatível com distribuições Linux como Ubuntu 18.04/20.04/22.04, CentOS 7/8 e Debian 10/11.

Comece atualizando os pacotes do sistema e instalando ferramentas de desenvolvimento. Para distribuições baseadas em Debian, use comandos como:

sudo apt update && sudo apt upgrade -y
sudo apt install -y build-essential cmake git wget curl

Em sistemas CentOS ou RHEL, execute:

sudo yum update -y
sudo yum groupinstall -y "Development Tools"
sudo yum install -y cmake git wget curl

Configure um ambiente Python isolado com a versão 3.8 ou superior:

sudo apt install -y python3.8 python3-pip
python3.8 -m venv meu-ambiente
source meu-ambiente/bin/activate

Instalação de Dependências e Compilação

Instale o PyTorch e bibliotecas auxiliares, escolhendo a versão com base na disponibilidade de GPU. Para sistemas com CUDA:

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

Para ambientes sem GPU, use a versão de CPU:

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

Adicione pacotes adicionais como OpenCV e NumPy:

pip install opencv-python numpy tqdm matplotlib
pip install onnx onnxruntime  # Opcional para exportação e inferência

Obtenha o código-fonte do DAMO-YOLO a partir do repositório oficial e instale-o:

git clone https://github.com/tinyvision/DAMO-YOLO.git
cd DAMO-YOLO
pip install -r requirements.txt
python setup.py develop

Para compilar operadores personalizados, como a convolução deformável, navegue até o diretório correspondente e execute o script de compilação:

cd DAMO-YOLO/damo_yolo/models/ops
bash make.sh

Download e Validação do Modelo

Baixe modelos pré-treinados do DAMO-YOLO conforme a necessidade. Crie um diretório para armazenar os pesos:

mkdir -p pesos
wget -P pesos https://github.com/tinyvision/DAMO-YOLO/releases/download/v1.0/damo-yolo_s.pth

Veriifque se o modelo é carregado corretamente com um script simples:

import torch
from damo_yolo import criar_modelo
dispositivo = 'cuda' if torch.cuda.is_available() else 'cpu'
modelo = criar_modelo('pesos/damo-yolo_s.pth', dispositivo)
print('Modelo carregado com sucesso!')

Otimizações Específicas por Distribuição

Em sistemas Ubuntu ou Debian, instale bibliotecas matemáticas otimizadas para acelerar cálculos:

sudo apt install -y libopenblas-dev liblapack-dev

No CentOS ou RHEL, adicione repositórios extras e dependências:

sudo yum install -y epel-release
sudo yum install -y openblas-devel lapack-devel

Ajuste parâmetros do kernel para melhorar o desempenho em qualquer distribuição Linux:

# Configurar modo de desempenho da CPU
sudo apt install -y cpufrequtils  # Para Debian/Ubuntu
sudo cpupower frequency-set -g performance

# Otimizar parâmetros de memória
echo 'vm.swappiness=10' | sudo tee -a /etc/sysctl.conf
echo 'vm.vfs_cache_pressure=50' | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

Otimização da Inferência

Para inferência em CPU, ajuste o número de threads e use motores eficientes. Exemplo de configuração:

import torch
from damo_yolo import criar_modelo

# Definir threads e motor de quantização
torch.set_num_threads(4)
torch.backends.quantized.engine = 'qnnpack'

modelo = criar_modelo('pesos/damo-yolo_s.pth', 'cpu')
modelo.eval()

# Executar inferência com gradiente desativado
with torch.no_grad():
    # Código de inferência aqui
    pass

Em ambientes com GPU NVIDIA, ative aceleração de hardware. Instale o toolkit CUDA se necessário:

sudo apt install -y nvidia-cuda-toolkit

Modifique o código para aproveitar a GPU, usando precisão meia e otimizações de benchmark:

import torch

dispositivo = 'cuda' if torch.cuda.is_available() else 'cpu'
if dispositivo == 'cuda':
    torch.cuda.set_device(0)  # Selecionar a primeira GPU

modelo = criar_modelo('pesos/damo-yolo_s.pth', dispositivo)
modelo.half()  # Ativar precisão meia para velocidade
torch.backends.cudnn.benchmark = True  # Otimizar para entradas de tamanho fixo

Considere técnicas de quantização para reduzir o tempo de inferência. Quentização dinâmica é adequada para CPU:

from torch import nn
modelo_quantizado = torch.quantization.quantize_dynamic(
    modelo, {nn.Linear, nn.Conv2d}, dtype=torch.qint8
)

Exemplo Prático de Implantação

Integre o DAMO-YOLO em um pipeline completo de detecção. Funções para inicialização, pré-processamento e inferência:

import cv2
import torch
import numpy as np
from damo_yolo import criar_modelo
from damo_yolo.utils import posprocessar, visualizar

def iniciar_modelo(caminho_modelo, dispositivo='cpu'):
    modelo = criar_modelo(caminho_modelo, dispositivo)
    modelo.eval()
    if dispositivo == 'cuda':
        modelo.half()
    return modelo

def preparar_imagem(caminho_imagem, tamanho_entrada=640):
    imagem = cv2.imread(caminho_imagem)
    imagem = cv2.cvtColor(imagem, cv2.COLOR_BGR2RGB)
    
    h, w = imagem.shape[:2]
    escala = min(tamanho_entrada / h, tamanho_entrada / w)
    novo_h, novo_w = int(h * escala), int(w * escala)
    
    imagem_redimensionada = cv2.resize(imagem, (novo_w, novo_h))
    imagem_preenchida = np.full((tamanho_entrada, tamanho_entrada, 3), 114, dtype=np.uint8)
    imagem_preenchida[:novo_h, :novo_w] = imagem_redimensionada
    
    tensor_imagem = torch.from_numpy(imagem_preenchida).float() / 255.0
    tensor_imagem = tensor_imagem.permute(2, 0, 1).unsqueeze(0)
    
    return tensor_imagem, (w, h), escala

def executar_inferencia(modelo, tensor_imagem, limiar_confianca=0.25):
    with torch.no_grad():
        if next(modelo.parameters()).is_cuda:
            tensor_imagem = tensor_imagem.half().cuda()
        else:
            tensor_imagem = tensor_imagem.float()
        
        saidas = modelo(tensor_imagem)
        resultados = posprocessar(saidas, limiar_confianca=limiar_confianca)
    
    return resultados

# Uso exemplo
dispositivo = 'cuda' if torch.cuda.is_available() else 'cpu'
modelo = iniciar_modelo('pesos/damo-yolo_s.pth', dispositivo)
tensor_imagem, tamanho_original, escala = preparar_imagem('teste.jpg')
resultados = executar_inferencia(modelo, tensor_imagem)

if resultados is not None:
    imagem_saida = cv2.imread('teste.jpg')
    visualizar(imagem_saida, resultados, limiar_confianca=0.25)
    cv2.imwrite('resultado.jpg', imagem_saida)
    print('Detecção concluída. Resultado salvo como resultado.jpg')

Resolução de Problemas Comuns

Se encontrar erros de memória CUDA, reduza o tamanho do lote ou selecione uma GPU específica:

export CUDA_VISIBLE_DEVICES=0  # Especificar a GPU a ser usada

Para conflitos de dependências, crie um ambiente virtual limpo:

python -m venv ambiente-limpo
source ambiente-limpo/bin/activate
pip install --upgrade pip

Acelere a inferência ativando otimizações adicionais no PyTorch:

torch.backends.cudnn.benchmark = True
torch.set_grad_enabled(False)  # Desativar cálculo de gradientes