Tarefas Centrais

Visão geral: “Tarefas Centrais” em Visão Computacional

A maioria dos sistemas de visão computacional pode ser descrita como resolvendo uma (ou mais) de três tarefas centrais:

  1. Classificação: O que há na imagem?
  2. Detecção: O que há na imagem e onde está?
  3. Segmentação: O que há na imagem e quais pixels pertencem a cada objeto ou região?

Essas tarefas compartilham fundamentos comuns — extração de características com Redes Neurais, otimização com Descida do Gradiente e Retropropagação, pré-processamento cuidadoso de dados e avaliação rigorosa — mas diferem nas saídas, nas cabeças do modelo, nas funções de perda e nas métricas.

Este artigo explica a teoria e as realidades práticas de cada tarefa e apresenta uma visão geral de arquiteturas amplamente usadas (baseadas em CNN, transformadores e híbridas), com exemplos de onde cada tarefa se encaixa em aplicações reais.

Para pipelines de dados e ampliações de dados (augmentations), veja Fundamentos de Imagens. Para métricas como IoU e mAP, veja Avaliação para Visão.

Uma perspectiva unificadora: entradas, saídas e supervisão

As três tarefas normalmente começam da mesma entrada: um tensor de imagem (por exemplo, H×W×3), possivelmente normalizado e aumentado.

O que muda é a estrutura do alvo e, portanto, o problema de aprendizado:

  • Classificação
    • Alvo: um rótulo (rótulo único) ou um conjunto de rótulos (múltiplos rótulos)
    • Saída: probabilidades de classe
    • Supervisão: rótulos em nível de imagem
  • Detecção
    • Alvo: um conjunto de caixas delimitadoras + rótulos de classe
    • Saída: lista de comprimento variável de caixas, pontuações e rótulos
    • Supervisão: anotações em nível de caixa
  • Segmentação
    • Alvo: rótulos em nível de pixel e, opcionalmente, IDs de instância
    • Saída: máscara(s) por pixel
    • Supervisão: anotações em nível de máscara (caras, porém ricas)

Uma regra prática: saídas mais detalhadas exigem rotulagem mais detalhada e mais computação, mas também permitem decisões downstream mais precisas.

Classificação

O que é

Classificação de imagens atribui uma ou mais categorias a uma imagem inteira (ou recorte). Variantes incluem:

  • Classificação de rótulo único: uma classe por imagem (por exemplo, “gato” vs “cachorro”)
  • Classificação de múltiplos rótulos: múltiplas classes podem estar presentes (por exemplo, “pessoa”, “bicicleta”, “semáforo”)
  • Classificação de granularidade fina: diferenças sutis (por exemplo, espécies de aves, modelos de carros)

Aplicações comuns

  • Categorização de produtos (e-commerce)
  • Diagnóstico médico a partir de exames (com ressalvas e validação clínica)
  • Moderação de conteúdo (categorias seguro/não seguro)
  • Inspeção de qualidade (“defeituoso” vs “ok”)

Ideia central de modelagem

A maioria dos classificadores modernos aprende um extrator de características e uma cabeça de classificação linear:

  • Backbone: CNN (rede neural convolucional, convolutional neural network) (por exemplo, ResNet, ConvNeXt) ou Transformer de Visão (Vision Transformer, ViT)
  • Cabeça: pooling global + MLP/camada linear produzindo logits

Perdas típicas

  • Perda de entropia cruzada para classificação de rótulo único
  • Entropia cruzada binária (BCE, binary cross-entropy) (frequentemente com logits) para múltiplos rótulos

Arquiteturas comuns (classificação)

  • CNNs:
    • ResNet (backbone padrão forte)
    • EfficientNet (trade-off computação/acurácia)
    • ConvNeXt (CNN modernizada com escolhas de projeto da era dos transformadores)
  • Transformadores:
    • ViT e derivados (frequentemente fortes com pré-treinamento em grande escala)
    • Transformadores hierárquicos como Swin (frequentemente usados como backbones para detecção/segmentação também)

Veja também: Arquitetura de Transformadores para o mecanismo de atenção e os blocos de codificador.

Exemplo prático (PyTorch / torchvision)

import torch
from torchvision.models import resnet50, ResNet50_Weights

weights = ResNet50_Weights.DEFAULT
model = resnet50(weights=weights)
model.eval()

# Preprocess using the weights’ transforms
preprocess = weights.transforms()

img = ...  # a PIL image
x = preprocess(img).unsqueeze(0)  # [1, 3, H, W]

with torch.no_grad():
    logits = model(x)
probs = logits.softmax(dim=1)
top_prob, top_idx = probs[0].max(dim=0)

label = weights.meta["categories"][top_idx.item()]
print(label, float(top_prob))

Armadilhas comuns

  • Viés do conjunto de dados (o fundo correlaciona com o rótulo)
  • Ruído de rótulo (especialmente em dados em escala web)
  • Excesso de confiança: calibração importa em sistemas críticos para segurança
  • Mudança de domínio (domain shift): a performance cai quando iluminação/câmeras/ambientes mudam

Detecção (Detecção de Objetos)

O que é

Detecção de objetos encontra instâncias de objetos e as localiza usando caixas delimitadoras (bounding boxes). A saída é um conjunto:

  • coordenadas da caixa (por exemplo, (x1, y1, x2, y2)),
  • rótulo de classe por caixa,
  • pontuação de confiança.

Aplicações comuns

  • Direção autônoma (veículos, pedestres, placas)
  • Análise de varejo (contagem de pessoas, monitoramento de prateleiras)
  • Robótica (alvos para preensão, detecção de obstáculos)
  • Segurança (detecção de áreas restritas)

Conceito-chave: localização + classificação

Detecção combina:

  • classificação (“o que é?”)
  • regressão (“onde está?”)

Essa natureza dupla guia muitas escolhas de projeto em cabeças de detecção e perdas.

Duas grandes famílias de detectores

1) Detectores de dois estágios (baseados em regiões)

Ideia: propor regiões candidatas e, em seguida, classificá-las/refiná-las.

  • Estágio 1: gerar propostas de região (locais prováveis de objetos)
  • Estágio 2: classificar cada proposta e refinar sua caixa

Exemplos canônicos:

  • Faster R-CNN (com uma RPN: Rede de Propostas de Região, Region Proposal Network)
  • Extensões: Cascade R-CNN, Mask R-CNN (adiciona máscaras)

Prós

  • Frequentemente alta acurácia, especialmente para objetos pequenos
  • Cabeças flexíveis (por exemplo, adicionar máscaras, pontos-chave)

Contras

  • Mais complexos e normalmente mais lentos do que métodos de um estágio

2) Detectores de um estágio (predição densa)

Ideia: prever caixas e classes diretamente em uma grade densa de locais.

Exemplos canônicos:

  • família YOLO (ênfase em tempo real; muitas variantes modernas)
  • SSD
  • RetinaNet (introduziu a perda focal (focal loss) para lidar com desbalanceamento de classes)

Prós

  • Inferência rápida e pipelines simples
  • Forte desempenho na prática

Contras

  • Historicamente mais fracos em objetos pequenos (a diferença diminuiu substancialmente)

Âncoras vs sem âncoras

  • Com âncoras (anchor-based): formas/tamanhos de caixas predefinidos em cada localização; o modelo prevê offsets.
  • Sem âncoras (anchor-free): o modelo prevê pontos-chave (por exemplo, centros) e extensões da caixa diretamente.

Ambos podem funcionar bem; sem âncoras frequentemente reduz projeto manual e hiperparâmetros.

Transformadores para detecção (estilo DETR)

DETR reformula a detecção como um problema de predição de conjunto (set prediction) usando decodificadores transformadores e perda de correspondência bipartida, muitas vezes reduzindo a dependência de componentes desenhados à mão como âncoras e NMS (dependendo da variante).

  • Prós: formulação elegante; forte raciocínio global
  • Contras: treinamento e convergência historicamente mais difíceis; existem muitas melhorias (Deformable DETR etc.)

Perdas e pós-processamento

Perdas típicas de treinamento em detecção:

  • Perda de classificação: entropia cruzada ou perda focal
  • Perda de regressão da caixa: Smooth L1, L1 ou perdas baseadas em IoU (GIoU/DIoU/CIoU)

Pós-processamento típico na inferência:

  • Supressão Não Máxima (NMS, Non-Maximum Suppression) para remover caixas duplicadas (muitos modelos do tipo DETR reduzem ou evitam NMS)

Exemplo prático (detector do torchvision)

import torch
from torchvision.models.detection import fasterrcnn_resnet50_fpn, FasterRCNN_ResNet50_FPN_Weights

weights = FasterRCNN_ResNet50_FPN_Weights.DEFAULT
model = fasterrcnn_resnet50_fpn(weights=weights)
model.eval()

preprocess = weights.transforms()

img = ...  # PIL image
x = preprocess(img)  # [3, H, W]

with torch.no_grad():
    outputs = model([x])[0]  # dict with boxes, labels, scores

# Filter by score threshold
keep = outputs["scores"] > 0.7
boxes = outputs["boxes"][keep]
labels = outputs["labels"][keep]
scores = outputs["scores"][keep]

Considerações práticas

  • Custo de anotação: caixas são mais baratas do que máscaras, mas ainda exigem ferramentas e QA
  • Objetos pequenos: exigem resolução apropriada, pirâmides de características (FPN) e protocolo de avaliação adequado
  • Restrições de latência: modelos de um estágio frequentemente vencem em implantações na borda (edge)
  • Cenas lotadas: objetos sobrepostos pressionam NMS e estratégias de atribuição de rótulos

Segmentação

O que é

Segmentação atribui rótulos no nível de pixel, o que permite compreensão de granularidade fina. Existem três variantes comumente discutidas:

  1. Segmentação semântica: cada pixel recebe um rótulo de classe (todos os “carros” compartilham o mesmo rótulo)
  2. Segmentação por instância: máscaras separadas para cada instância de objeto (“carro #1”, “carro #2”)
  3. Segmentação panóptica: unifica as duas — cada pixel recebe um ID de instância de “coisa” (thing) ou uma classe de “massa” (stuff) (estrada, céu)

Aplicações comuns

  • Imagens médicas (limites de tumor/órgãos)
  • Direção autônoma (segmentação de estrada/faixas)
  • Inspeção industrial (regiões de defeitos na superfície)
  • Edição de fotos (remoção de fundo, seleção de sujeito)

Por que segmentação é mais difícil

A segmentação aumenta a dimensionalidade da saída de “um rótulo” ou “algumas caixas” para predições densas por pixel. Ela exige:

  • mais supervisão (máscaras),
  • mais memória/computação (mapas de características de alta resolução),
  • tratamento cuidadoso do desbalanceamento de classes (o fundo domina),
  • preservação de detalhes espaciais (bordas e estruturas finas).

Arquiteturas para segmentação semântica

Estilo FCN (totalmente convolucional)

Abordagem moderna inicial: substituir camadas totalmente conectadas por convolução e fazer upsampling para saídas densas.

U-Net (codificador–decodificador com conexões de atalho)

U-Net é um clássico para imagens médicas e científicas:

  • O codificador comprime a resolução espacial e aprende semântica
  • O decodificador faz upsampling para recuperar detalhes espaciais
  • Conexões de atalho passam detalhes finos do codificador para o decodificador

Família DeepLab (convoluções atrous/dilatadas)

DeepLab usa:

  • convoluções dilatadas (dilated convolutions) para aumentar o campo receptivo sem reduzir a amostragem demais
  • ASPP (Pooling Piramidal Espacial Atrous, Atrous Spatial Pyramid Pooling) para contexto multi-escala

Segmentação na era dos transformadores

A segmentação moderna frequentemente usa backbones de transformadores ou projetos híbridos:

  • SegFormer: codificador transformador com um decodificador leve
  • Mask2Former/outros: unificam múltiplas formulações de segmentação com decodificadores transformadores (particularmente fortes para variantes panópticas/por instância)

Arquiteturas para segmentação por instância

Mask R-CNN (baseline clássico)

Estende o Faster R-CNN:

  • detecta caixas,
  • para cada região detectada, prevê uma máscara binária (frequentemente em resolução fixa, por exemplo, 28×28),
  • projeta de volta para as coordenadas da imagem.

Forte, modular e amplamente usada.

Mask2Former / cabeças baseadas em transformadores

Decodificadores transformadores podem prever um conjunto de “queries” de máscara, em espírito semelhante ao DETR para caixas, frequentemente obtendo forte desempenho em tarefas por instância/panópticas.

Segmentação com prompts / de base (tendência moderna)

Modelos no estilo “segment anything” aprendem priors amplos de segmentação e podem ser guiados por prompts com pontos/caixas/texto. Eles frequentemente servem como:

  • aceleradores de rotulagem,
  • ferramentas interativas,
  • ou módulos de segmentação de uso geral.

Eles não substituem completamente o treinamento específico da tarefa, mas mudam significativamente os fluxos de trabalho.

Perdas para segmentação

Componentes comuns de perda:

  • Entropia cruzada por pixel
  • Perda Dice (Dice loss) (popular em imagens médicas; robusta a desbalanceamento de classes)
  • Perdas de IoU/Jaccard ou variantes sensíveis a contorno
  • Para segmentação por instância: perdas de máscara + perdas de detecção

Exemplo prático (segmentação semântica com torchvision)

import torch
from torchvision.models.segmentation import deeplabv3_resnet50, DeepLabV3_ResNet50_Weights

weights = DeepLabV3_ResNet50_Weights.DEFAULT
model = deeplabv3_resnet50(weights=weights)
model.eval()

preprocess = weights.transforms()

img = ...  # PIL image
x = preprocess(img).unsqueeze(0)  # [1, 3, H, W]

with torch.no_grad():
    out = model(x)["out"]  # [1, C, H, W] logits

pred = out.argmax(dim=1)[0]  # [H, W] class IDs

Blocos arquiteturais comuns entre tarefas

Embora as saídas diferenciem, muitos sistemas compartilham a mesma “espinha dorsal”:

Backbones

Um backbone extrai características de imagens. Escolhas populares:

  • CNN: ResNet, ConvNeXt, EfficientNet
  • Transformador: ViT, Swin (hierárquico)
  • Híbrido: stem convolucional + blocos de transformador

Backbones são frequentemente pré-treinados (supervisionados ou auto-supervisionados) e depois ajustados (fine-tuned) para uma tarefa downstream.

Pirâmides de características (características multi-escala)

Objetos vêm em muitos tamanhos. FPN (Rede de Pirâmide de Características, Feature Pyramid Network) e projetos relacionados fornecem mapas de características multi-escala muito usados em detecção e segmentação.

Cabeças

Camadas específicas da tarefa anexadas ao backbone:

  • Cabeça de classificação: pooling global + classificador linear
  • Cabeça de detecção: classificação + regressão de caixa (e às vezes objectness)
  • Cabeça de segmentação: classificador por pixel (além de decodificadores de máscara para instâncias)

Loop de treinamento (esqueleto compartilhado)

Todas as tarefas normalmente seguem:

  1. pré-processar/aumentar a entrada (Fundamentos de Imagens)
  2. forward pass
  3. computar a perda da tarefa
  4. backward pass + passo do otimizador
  5. avaliar com métricas apropriadas (Avaliação para Visão)

Avaliação: o que significa “bom desempenho” difere por tarefa

  • Classificação: acurácia, acurácia top-k, F1 (múltiplos rótulos), calibração
  • Detecção: mAP em limiares de IoU, AP por classe, desagregações pequeno/médio/grande
  • Segmentação:
    • semântica: IoU médio (mIoU), acurácia por pixel
    • por instância: AP de máscara (estilo COCO)
    • panóptica: PQ (Qualidade Panóptica, Panoptic Quality)

A escolha da métrica pode mudar qual modelo é “melhor”, então o protocolo de avaliação faz parte do projeto do sistema. Veja Avaliação para Visão.

Escolhendo a tarefa central certa

Um guia rápido de decisão:

  • Use classificação se:

    • você só precisa de decisões em nível de imagem (por exemplo, “há um defeito?”)
    • localização não é necessária
    • você tem orçamento limitado para rotulagem

  • Use detecção se:

    • você precisa de localizações e contagens aproximadas (por exemplo, “quantas pessoas?”)
    • caixas delimitadoras são suficientes para a ação downstream (por exemplo, rastreamento, recorte)

  • Use segmentação se:

    • limites precisos importam (medicina, manipulação robótica, edição de fotos)
    • você precisa de medições de área/forma ou controle em nível de pixel

Um padrão comum em produção é a complexidade em estágios:

  • começar com classificação para validar viabilidade,
  • migrar para detecção quando você precisa de localização,
  • migrar para segmentação quando você precisa de precisão.

Notas práticas de implantação

Latência e memória

  • Classificação geralmente é o mais barato.
  • O custo de detecção cresce com o número de caixas previstas e as escalas dos mapas de características.
  • Segmentação pode ser pesada devido a ativações de alta resolução.

Estratégias:

  • backbones menores
  • quantização e precisão mista
  • batching e redimensionamento da entrada (com cuidado para objetos pequenos)

Estratégia de dados e rotulagem

  • Rótulos de classificação podem ser coletados de forma barata, mas podem ser ambíguos.
  • Caixas de detecção exigem mais esforço; a qualidade varia entre anotadores.
  • Máscaras de segmentação são caras; considere:
    • supervisão fraca (caixas/rabiscos),
    • ferramentas interativas de rotulagem,
    • aproveitar modelos de base pré-treinados para acelerar a anotação (e depois QA humano).

Robustez e mudança

Qualquer tarefa central pode falhar sob:

  • novas iluminações/câmeras,
  • mudanças climáticas,
  • diferenças geográficas/culturais,
  • divergência entre dados sintéticos e reais.

Na prática, a melhor mitigação é dados representativos, monitoramento contínuo e retreinamento periódico.

Como essas tarefas se conectam à pilha mais ampla de Visão Computacional

  • Tarefas centrais frequentemente são combinadas com:

Elas também compartilham cada vez mais backbones pré-treinados e arquiteturas unificadas, mas a estrutura da saída e o protocolo de avaliação continuam sendo a diferença definidora.

Resumo

  • Classificação prevê rótulos para uma imagem inteira; é a mais simples e frequentemente o ponto de entrada.
  • Detecção prevê caixas delimitadoras rotuladas; dá suporte a contagem e localização com custo moderado de anotação.
  • Segmentação prevê regiões em nível de pixel; permite controle fino e medição, mas exige mais supervisão e computação.
  • Sistemas modernos reutilizam backbones comuns (CNNs/transformadores), características multi-escala (FPN) e cabeças específicas por tarefa.
  • Famílias de arquitetura para conhecer:
    • Classificação: ResNet/EfficientNet/ConvNeXt, ViT/Swin
    • Detecção: Faster R-CNN (dois estágios), YOLO/RetinaNet (um estágio), variantes de DETR (predição de conjunto com transformadores)
    • Segmentação: U-Net/DeepLab (semântica), Mask R-CNN (por instância), decodificadores de máscara baseados em transformadores (panóptica/por instância)

Se você estiver implementando esses sistemas, comece acertando seu pipeline de dados (Fundamentos de Imagens) e a configuração de avaliação (Avaliação para Visão); a escolha da arquitetura importa, mas qualidade dos dados e protocolo frequentemente importam mais.