Transformers na Detecção de Objetos: Dominando o DETR

No campo da visão computacional, a detecção de objetos evoluiu para além das abordagens tradicionais baseadas em componentes manuais como âncoras (Anchor Boxes) e supressão não-máxima (NMS). O DETR (DEtection TRansformer), introduzido pelo Facebook AI Research, apresentou um paradigma revolucionário: tratar a detecção como um problema de previsão de conjuntos ponta a ponta (end-to-end), eliminando etapas de pós-processamento complexas.

A essência do DETR reside em seu mecanismo de Previsão de Conjuntos. Em vez de gerar inúmeras caixas delimitadoras candidatas e filtrá-las, o modelo gera diretamente um conjunto fixo de previsões (geralmente 100). A correspondência única entre as previsões e as anotações reais é estabelecida durante o treinamento usando o algoritmo húngaro, o que elimina a necessidade do NMS na inferência.

O arquiteto do DETR é composto por três pilares principais:

Backbone (Espinha Dorsal) de CNN: Extrai características da imagem de entrada.
Encoder Trensformer: Processa as características planificadas da imagem, permitindo que cada elemento (pixel ou região) atenda globalmente a todos os outros.
Decoder Transformer com Consultas de Objetos: Utiliza um conjunto de vetores aprendíveis ("consultas") que interagem com a memória do encoder para prever a classe e a localização de cada objeto.

Instalação e Configuração

Para começar com o DETR, a abordagem mais simples é utilizar a biblioteca Hugging Face Transformers, que fornece uma interface simplificada.

# Instale as dependências necessárias
pip install transformers torch torchvision pillow

Para quem deseja explorar o código fonte oficial ou treinar em datasets customizados, é possível clonar o repositório original.

# Clonar e instalar a versão oficial
git clone https://github.com/facebookresearch/detr.git
cd detr
pip install -r requirements.txt

O DETR também requer a API COCO para avaliação e dataset.

pip install pycocotools

Modelos Pré-Treinados

Vários modelos pré-treinados no COCO 2017 estão disponíveis. As variantes "DC5" (Dilated C5) oferecem melhor precisão para objetos pequenos, sacrificando um pouco a velocidade.

DETR-R50: Backbone ResNet-50, AP de 42.0.
DETR-R50-DC5: Backbone ResNet-50 com taxa dilatada, AP de 43.3.
DETR-R101: Backbone ResNet-101, AP de 43.5.
DETR-R101-DC5: Backbone ResNet-101 com taxa dilatada, AP de 44.9.

Os pesos podem ser baixados diretamente dos links fornecidos no repositório oficial.

Preparação dos Dados

O DETR espera dados no formato padrão do COCO. Para datasets personalizados, as anotações devem ser convertidas para um arquivo JSON contendo as chaves images, annotations e categories. Ferramentas como Labelme, CVAT ou Roboflow podem auxiliar na conversão.

A estrutura de diretórios esperada para o treinamento é:

seu_dataset/
├── annotations/
│   ├── instances_train.json
│   └── instances_val.json
├── train/
│   └── (imagens de treino)
└── val/
    └── (imagens de validação)

Usando o DETR para Inferência

A maneira mais eficiente de realizar inferência é através da API do Hugging Face Transformers.

from transformers import DetrImageProcessor, DetrForObjectDetection
from PIL import Image
import torch

# Carregar o modelo e o processador
processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50")
model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50")

# Carregar e processar uma imagem
imagem = Image.open("caminho/para/sua/imagem.jpg")
entradas = processor(images=imagem, return_tensors="pt")

# Executar inferência
with torch.no_grad():
    saidas = model(**entradas)

# Converter saídas para caixas delimitadoras e rótulos
tamanho_alvo = torch.tensor([imagem.size[::-1]])
resultados = processor.post_process_object_detection(
    saidas,
    target_sizes=tamanho_alvo,
    threshold=0.7
)[0]

# Exibir os resultados
for confianca, rotulo, caixa in zip(resultados["scores"], resultados["labels"], resultados["boxes"]):
    caixa_arredondada = [round(coord, 2) for coord in caixa.tolist()]
    print(f"Detectado: {model.config.id2label[rotulo.item()]} | "
          f"Confiança: {confianca:.3f} | "
          f"Coordenadas: {caixa_arredondada}")

Para uma visualização dos resultados, a biblioteca supervision é extremamente útil.

import supervision as sv

# Converter resultados para o formato da Supervision
deteccoes = sv.Detections.from_transformers(resultados, id2label=model.config.id2label)

# Anotar a imagem original
anotador_caixas = sv.BoxAnnotator()
anotador_rotulos = sv.LabelAnnotator()

imagem_anotada = anotador_caixas.annotate(scene=imagem.copy(), detections=deteccoes)
imagem_anotada = anotador_rotulos.annotate(scene=imagem_anotada, detections=deteccoes)

# Salvar a imagem anotada
imagem_anotada.save("resultado_detr.jpg")

Treinando com o Repositório Oficial

Para treinar em um dataset customizado, use o script main.py com os argumentos apropriados.

# Treinamento do zero no dataset COCO
python main.py \
    --dataset_file coco \
    --coco_path /caminho/para/coco \
    --output_dir ./resultados \
    --batch_size 2 \
    --epochs 300 \
    --lr_drop 200

# Fine-tuning a partir de um modelo pré-treinado
python main.py \
    --dataset_file coco \
    --coco_path /caminho/para/coco \
    --output_dir ./resultados_finetuned \
    --batch_size 2 \
    --epochs 50 \
    --lr_drop 40 \
    --resume ./detr-r50-e632da11.pth

Parâmetros importantes incluem --batch_size (DETR demanda memória significativa), --epochs (treinamento original usa 500 épocas) e --lr_drop (época para decaimento da taxa de aprendizado).

Conceitos Chave da Arquitetura

O Decoder do DETR utiliza um mecanismo de Consultas de Objetos — um conjunto de N vetores aprendíveis (tipicamente 100). Cada consulta aprende, durante o treinamento, a especializar-se em detectar objetos de certas classes ou em certas regiões espaciais da imagem. A Perda de Correspondência Bipartida é então usada para alinhar perfeitamente as N previsões do modelo com as anotações reais (onde N é geralmente muito maior que o número de objetos na imagem), garantindo uma correspondência um-para-um e uma saída limpa sem NMS.

A Evolução e o Estado da Arte

O DETR original teve limitações, como convergência lenta e desempenho inferior em objetos pequenos. Isso gerou uma onda de melhorias:

Deformable DETR: Introduziu atenção deformável, focando em pontos-chave específicos em vez de toda a imagem, melhorando a eficiência e a precisão.
DINO: Incorporou técnicas de treinamento com redução de ruído e uma regra de "look-forward twice", impulsionando significativamente o desempenho.
RT-DETR / RT-DETRv2: Tornaram o DETR viável para aplicações em tempo real, competindo diretamente com modelos como os da família YOLO em termos de velocidade e precisão.
Co-DETR: Utilizou treinamento com atribuição mista e cabeças auxiliares durante o treinamento para melhorar o aprendizado, alcançando recordes de desempenho.

O ecossistema DETR se expandiu para além da detecção de objetos padrão, apoiando segmentação panóptica e semântica, e sendo aplicado em campos como condução autônoma, inspeção industrial e imagans médicas. Modelos como o RT-DETRv2 representam o estado atual, oferecendo uma implementação eficiente e de alto desempenho para uso prático.

Tags: DETR Transformer detecção de objetos Visão Computacional Pytorch

Publicado em 7-10 00:48

Doido Dev