Dataset COCO

O que é o Dataset COCO?

COCO (Common Objects in Context) é um dos conjuntos de dados (datasets) de referência mais usados em visão computacional. Introduzido pela Microsoft em 2014, o COCO foi projetado para ir além de fotos de objetos “icônicos” (um único objeto centralizado) e, em vez disso, enfatizar cenas do cotidiano com:

múltiplos objetos por imagem,
desordem visual e oclusão,
uma ampla variedade de escalas de objetos,
objetos em contexto natural (cozinha, rua, esportes etc.).

O COCO é central no benchmarking moderno de visão para tarefas como Detecção de Objetos, Segmentação de Instâncias, Detecção de Pontos-Chave e Geração de Legendas de Imagens. Ele também é influente porque seu protocolo de avaliação (especialmente o “COCO mAP”) tornou-se um padrão de facto até mesmo para conjuntos de dados que não são COCO.

Quais tarefas o COCO suporta?

O COCO inclui múltiplos tipos de anotação sobre, em grande parte, o mesmo conjunto de imagens.

Detecção de objetos (caixas delimitadoras)

Objetivo: prever uma caixa delimitadora e um rótulo de classe para cada instância de objeto.

O COCO define 80 categorias comumente usadas para benchmarks de detecção e segmentação (por exemplo: pessoa, bicicleta, carro, cachorro, cadeira).
Cada instância de objeto é anotada com uma caixa delimitadora.
A avaliação se baseia em Interseção sobre União (Intersection over Union, IoU) e no mAP de múltiplos limiares do COCO (explicado abaixo).

Essa tarefa é o caso de uso canônico do COCO para avaliar detectores como Faster R-CNN, RetinaNet, variantes de YOLO e modelos no estilo DETR.

Segmentação de instâncias (máscaras por objeto)

Objetivo: prever uma máscara precisa em nível de pixel para cada instância de objeto e classificá-la.

A segmentação de instâncias do COCO fornece:

máscaras de objetos codificadas como polígonos (polygons) ou RLE (run-length encoding),
uma caixa delimitadora para cada instância,
um indicador opcional de “multidão” (crowd) que afeta a avaliação.

Este é um benchmark central para modelos no estilo Mask R-CNN e sistemas modernos de segmentação baseados em transformadores.

Pontos-chave (estimativa de pose humana)

Objetivo: prever pontos-chave do corpo para cada instância de pessoa (por exemplo, ombros, cotovelos, joelhos).

Os pontos-chave do COCO focam na categoria pessoa e definem um conjunto padrão de pontos-chave (comumente o formato de 17 pontos-chave (17-keypoint): nariz, olhos, orelhas, ombros, cotovelos, punhos, quadris, joelhos, tornozelos).

Ao contrário do IoU de detecção, os pontos-chave são avaliados usando OKS (Object Keypoint Similarity), que considera escala e incerteza específica de cada ponto-chave.

Legendas (geração de legendas de imagens)

Objetivo: gerar uma descrição em linguagem natural de uma imagem.

O COCO Captions fornece:

múltiplas (tipicamente 5) legendas escritas por humanos por imagem,
divisões padrão de treino/val/test e servidores de avaliação.

A geração de legendas é comumente avaliada usando métricas como BLEU, METEOR, ROUGE-L, CIDEr e SPICE, cada uma medindo aspectos diferentes da qualidade do texto.

(Relacionada) Segmentação panóptica

Embora nem sempre seja agrupada com as “quatro principais” tarefas acima, o COCO também tem um benchmark amplamente usado, o COCO Panoptic, que unifica:

classes thing (objetos contáveis como pessoa, carro) e
classes stuff (regiões amorfas como céu, estrada)

em uma única saída de segmentação em nível de cena. A avaliação panóptica usa métricas como PQ (Panoptic Quality).

Versões e divisões comuns do COCO

O COCO possui múltiplas versões lançadas. As duas mais encontradas hoje são:

COCO 2014

train2014: ~83k imagens
val2014: ~40k imagens
test2014: ~41k imagens (rótulos não divulgados)

Muitos artigos mais antigos reportam resultados no COCO 2014. Você também pode ver “minival” (um subconjunto de 5k da validação) usado historicamente.

COCO 2017 (mais comum em pipelines modernos)

train2017: ~118k imagens
val2017: 5k imagens
test2017: ~20k imagens (rótulos não divulgados)

O COCO 2017 é a configuração mais comum para treino e reporte. Prática típica:

treinar em train2017
ajustar/validar em val2017
reportar números finais em test-dev (via servidor de avaliação)

Conjuntos de teste e servidores de avaliação

As anotações de teste do COCO não são disponibilizadas publicamente para os conjuntos de teste padrão. Em vez disso, você envia as predições ao servidor de avaliação do COCO para:

test-dev (comumente usado para resultados em artigos)
test-std (mais restrito / formal)

Isso importa para reprodutibilidade: se um artigo reporta test-dev, você não consegue reproduzir exatamente sem acesso ao servidor e uma implementação cuidadosamente compatível.

Formato de anotação do COCO (JSON)

As anotações do COCO são distribuídas como um único arquivo JSON por divisão/tarefa (por exemplo, instâncias, legendas, pontos-chave). O formato é deliberadamente modular e tornou-se um esquema padrão no estilo “COCO-style” usado por muitos outros conjuntos de dados.

Estrutura de alto nível

Um JSON típico de instâncias do COCO inclui estes arrays de nível superior:

images: metadados da imagem (nome do arquivo, largura/altura, id)
annotations: rótulos por instância (bbox, segmentação, categoria etc.)
categories: definições de categoria (id, nome, supercategoria)

Campos adicionais comuns incluem licenses, info.

Images

Cada entrada se parece com:

{
  "id": 397133,
  "file_name": "000000397133.jpg",
  "width": 640,
  "height": 427
}

Anotações de detecção (caixas delimitadoras)

Uma anotação de detecção tipicamente contém:

image_id: a qual imagem isso pertence
category_id: id da classe
bbox: [x, y, width, height] em coordenadas de pixel (origem no canto superior esquerdo)
area: área em pixels (frequentemente computada a partir da segmentação)
iscrowd: se esta anotação é uma região de multidão (importante para avaliação)

Exemplo:

{
  "id": 1768,
  "image_id": 397133,
  "category_id": 1,
  "bbox": [217.62, 240.54, 38.99, 57.75],
  "area": 1965.4,
  "iscrowd": 0
}

Anotações de segmentação de instâncias (máscaras)

A segmentação é armazenada em segmentation, como:

Polígono(s) (lista de listas de coordenadas x/y)

"segmentation": [[
  264.0, 126.0, 276.0, 131.0, 277.0, 147.0, 264.0, 148.0
]]

RLE (run-length encoding) (comum para regiões de multidão e, às vezes, máscaras regulares)

"segmentation": {
  "counts": "eWm11a0...",
  "size": [427, 640]
}

Implicação prática: muitos pipelines de treinamento convertem polígonos em máscaras binárias “on the fly”, enquanto RLE pode ser decodificado com eficiência com pycocotools.

Anotações de pontos-chave

Para pontos-chave do COCO, cada instância de pessoa inclui:

keypoints: uma lista plana [x1, y1, v1, x2, y2, v2, ...]
num_keypoints: número de pontos-chave rotulados (visíveis ou não)

A flag de visibilidade v é tipicamente:

0: não rotulado (ausente)
1: rotulado mas não visível (ocluído)
2: rotulado e visível

Anotações de legendas

As legendas são armazenadas de forma diferente (JSON separado). Cada anotação inclui:

image_id
texto de caption
seu próprio id

Exemplo:

{
  "id": 37,
  "image_id": 397133,
  "caption": "A man riding a bicycle down a city street."
}

Como o COCO é usado para benchmarking

O COCO não é apenas um conjunto de dados — ele também é um protocolo de avaliação. Muitas bibliotecas e leaderboards reportam “métricas COCO” mesmo quando usam dados diferentes.

COCO mAP para detecção e segmentação de instâncias

A métrica principal do COCO frequentemente é chamada de “COCO mAP” (também escrita como AP), e ela difere do AP@0.5 no estilo PASCAL VOC mais antigo.

O AP do COCO faz a média da precisão em múltiplos limiares de IoU:

Limiar(es) de IoU: 0.50, 0.55, …, 0.95 (10 limiares)
O AP final é a média entre esses limiares e entre as classes.

O COCO comumente reporta:

AP (principal): AP médio em IoU 0.50:0.95
AP50: AP em IoU = 0.50 (frequentemente mais fácil / mais alto)
AP75: AP em IoU = 0.75 (localização mais rigorosa)
APs, APm, APl: AP para objetos pequenos, médios, grandes (por área)
AR: revocação média, frequentemente com diferentes máximos de detecções por imagem (por exemplo, 1, 10, 100)

Essa métrica é amplamente discutida em Precisão Média (Mean Average Precision) e é valorizada porque recompensa:

classificação e ranqueamento corretos, e
localização precisa (limiares mais altos de IoU).

Exemplo prático: interpretando métricas

Se um modelo tem:

AP50 alto, mas AP75 muito mais baixo, isso frequentemente indica que o detector encontra os objetos certos, mas as caixas/máscaras não estão suficientemente “justas”.

Se APs é muito mais baixo do que APl, o modelo tem dificuldade com objetos pequenos (comum no COCO).

mAP baseado em OKS para pontos-chave

Pontos-chave usam OKS (Object Keypoint Similarity), análogo ao IoU, mas para pontos-chave. Ele considera:

escala do objeto (alguns pixels importam mais em uma pessoa pequena),
tolerâncias diferentes de localização por ponto-chave.

As métricas se parecem com as de detecção (AP, AP50, AP75), mas os limiares se aplicam ao OKS em vez do IoU.

Métricas de legendas

A tarefa de legendas do COCO usa o conjunto de ferramentas de avaliação de legendas do COCO; métricas comuns incluem:

CIDEr (comumente enfatizada; correlaciona-se razoavelmente com julgamento humano em muitos cenários)
SPICE (proposições semânticas)
BLEU/METEOR/ROUGE (variantes de sobreposição de n-gramas)

Na avaliação multimodal moderna, métricas de legendas frequentemente são complementadas com avaliação humana ou avaliação baseada em tarefas devido a limitações conhecidas da pontuação por sobreposição de n-gramas.

Trabalhando com COCO na prática

A API do COCO (pycocotools)

O kit de ferramentas de referência é o pycocotools, que fornece:

parsing e indexação de anotações,
utilitários de decodificação/codificação de máscaras,
código oficial de avaliação (importante para corresponder a números reportados).

Exemplo mínimo: carregar anotações e listar todas as anotações de “person” em uma imagem:

from pycocotools.coco import COCO

coco = COCO("annotations/instances_val2017.json")

# Find category id for 'person'
cat_ids = coco.getCatIds(catNms=["person"])
img_ids = coco.getImgIds(catIds=cat_ids)

img_id = img_ids[0]
ann_ids = coco.getAnnIds(imgIds=[img_id], catIds=cat_ids, iscrowd=None)
anns = coco.loadAnns(ann_ids)

print("image:", coco.loadImgs([img_id])[0]["file_name"])
print("num person instances:", len(anns))
print("first bbox [x,y,w,h]:", anns[0]["bbox"])

Predições de saída no estilo COCO

Para avaliar com o código oficial, as saídas do seu modelo tipicamente são convertidas para uma lista de objetos JSON como:

[
  {
    "image_id": 397133,
    "category_id": 1,
    "bbox": [217.6, 240.5, 39.0, 57.8],
    "score": 0.98
  }
]

Para segmentação, você inclui segmentation (frequentemente como RLE). Para pontos-chave, inclua keypoints.

Avaliando com as métricas oficiais do COCO

Um trecho padrão de avaliação para detecção:

from pycocotools.coco import COCO
from pycocotools.cocoeval import COCOeval
import json

coco_gt = COCO("annotations/instances_val2017.json")
coco_dt = coco_gt.loadRes("predictions_val2017_bbox.json")  # your predictions

evaluator = COCOeval(coco_gt, coco_dt, iouType="bbox")
evaluator.evaluate()
evaluator.accumulate()
evaluator.summarize()   # prints AP, AP50, AP75, APs, ...

Usar o avaliador oficial é fortemente recomendado para afirmações de benchmark, porque pequenas diferenças em correspondência e filtragem podem alterar os resultados.

Principais ressalvas e “pegadinhas”

O COCO é extremamente útil, mas tem detalhes que frequentemente pegam as pessoas de surpresa.

1) Definições e IDs de categoria nem sempre são o que você espera

Os IDs de categoria do COCO são fixos pela especificação do conjunto de dados; não os reordene casualmente.
“80 categorias” é o padrão para benchmarking de detecção/segmentação, mas referências antigas podem mencionar 91 categorias da taxonomia mais ampla do artigo original.
Alguns pipelines mapeiam categorias do COCO para índices contíguos (0..79) internamente; tenha cuidado ao exportar predições de volta para JSON COCO (você deve usar category_id do COCO).

2) O formato da caixa delimitadora é `[x, y, width, height]`

Muitas outras ferramentas usam [x1, y1, x2, y2]. Confundir os formatos arruína a avaliação.

3) `iscrowd` afeta a avaliação

O COCO inclui regiões de multidão (crowd regions) onde múltiplas instâncias são agrupadas (por exemplo, uma multidão de pessoas). Na avaliação, detecções que se sobrepõem a regiões de multidão podem ser tratadas de forma diferente (frequentemente não penalizadas da mesma forma que falsos positivos).

Se você treina em COCO, precisa de uma política para anotações de multidão:

ignorá-las,
tratá-las como “regiões de ignorar”, ou
incluí-las com tratamento especial.

4) As anotações do COCO não são “totalmente exaustivas”

Em cenas complexas, algumas instâncias de objetos podem estar sem rótulos (omissões de anotação acontecem em conjuntos de dados reais). Isso pode levar a:

falsos positivos aparentes que, na verdade, são detecções corretas de objetos não rotulados,
sinais de treinamento ruidosos para detecção densa.

Esta é uma das razões pelas quais a avaliação no estilo COCO é melhor usada como um proxy de benchmark, não como uma medida perfeita de desempenho no mundo real. Veja também Mudança de Dataset e discussões mais amplas sobre Métricas de Avaliação.

5) O protocolo de avaliação inclui faixas de tamanho e máximo de detecções

Os APs/APm/APl do COCO dependem de limiares de área do objeto definidos pelo script de avaliação (em área de pixels). Além disso, a avaliação comumente assume um número máximo de detecções por imagem (por exemplo, 100). Se o seu sistema gerar mais, elas podem ser ignoradas além do limite.

Isso importa ao comparar:

detectores de duas etapas (frequentemente menos propostas, de maior qualidade) vs
detectores densos (muitos candidatos).

6) O pré-processamento pode mudar resultados se você tratar mal o escalonamento

Se você redimensiona imagens durante a inferência, garanta que:

caixas/máscaras/pontos-chave previstos sejam corretamente reescalados de volta para as coordenadas da imagem original,
o arredondamento seja tratado de forma consistente,
as máscaras se alinhem às convenções de coordenadas do COCO.

Para segmentação, mesmo uma pequena diferença de off-by-one ou de arredondamento pode afetar o IoU em limiares rigorosos.

7) “COCO mAP” não é um número único que você pode otimizar cegamente

O AP do COCO faz média entre limiares de IoU e tamanhos de objetos, o que é bom para robustez — mas também significa que você pode precisar de melhorias direcionadas:

melhor localização melhora o AP75 mais do que o AP50,
recursos multi-escala e maior resolução ajudam o APs (objetos pequenos),
a qualidade da cabeça de máscara (mask head) afeta o AP de segmentação mais do que o AP de detecção.

No desenvolvimento moderno de modelos, métricas do COCO frequentemente são acompanhadas junto com métricas de latência, memória e robustez, especialmente para implantação.

Por que o COCO importa em fluxos de trabalho modernos de ML

O COCO continua influente porque está na interseção de:

complexidade realista de cenas,
tarefas e métricas padronizadas,
ferramentas amplamente adotadas (pycocotools),
um enorme corpo de resultados de baseline.

Usos práticos comuns incluem:

benchmarking de novas arquiteturas (por exemplo, Transformers de Visão adaptados para detecção/segmentação),
aprendizado por transferência (transfer learning) e pré-treinamento para tarefas downstream (Aprendizado por Transferência),
avaliar mudanças de modelo (aumentações, backbones, funções de perda) sob um protocolo estável,
comparar sistemas de forma justa usando o código oficial de avaliação do COCO.

Mesmo quando um projeto usa um conjunto de dados diferente, equipes frequentemente reportam “AP no estilo COCO” porque isso se tornou uma linguagem compartilhada para desempenho de detecção/segmentação.

Resumo

O COCO é um conjunto de dados fundamental em visão que enfatiza objetos em contexto.
Ele suporta tarefas principais: detecção, segmentação de instâncias, pontos-chave e legendas (além de benchmarks panópticos relacionados).
As anotações estão em um esquema padrão COCO JSON com imagens, anotações e categorias; máscaras podem ser polígonos ou RLE.
O benchmarking do COCO é definido tanto por seu protocolo de avaliação quanto por seus dados — especialmente AP médio em limiares de IoU (0.50–0.95).
Ressalvas importantes incluem manuseio de IDs de classe, comportamento de multidão/ignorar, rótulos não exaustivos e detalhes rigorosos de avaliação.

Se você estiver implementando um pipeline COCO, a abordagem mais confiável é: usar pycocotools para parsing e avaliação, e validar cedo suas conversões de coordenadas e mapeamentos de categoria.