Anotação inteligente e rotulagem em lote

Três formas de pré-anotar#

No editor de anotações, o modo Draw (V) é manual e o modo Smart (S) permite que um modelo proponha rótulos:

O SAM requer um clique por objeto e gera formas mais precisas. As previsões do modelo requerem um clique por imagem e a sua qualidade depende do modelo; por isso, o resto desta lição é dedicado a escolher e ajustar esse modelo.

Escolhe o modelo de rotulagem#

Mesmo um modelo v0 fraco, treinado com 100–200 anotações manuais, é melhor do que começar do zero e, na versão v1, costuma ser um parceiro útil de aprendizagem ativa. O desempenho dos modelos com indicação de classes varia muito conforme o domínio: alguns que encontram quase tudo em fotografias do dia a dia não detetam a maioria dos objetos em imagens de PCB, raios X ou retalho; por isso, verifica dez previsões antes de confiar num modelo.

Exemplo prático: mede o trabalho de revisão por limiar#

O limiar de confiança determina em que os revisores gastam o seu tempo: se for demasiado baixo, eliminam caixas falsas; se for demasiado alto, desenham as caixas que o modelo não detetou. Mede-o em imagens que já têm rótulos corretos; neste caso, as 128 imagens anotadas de COCO128, usando um YOLO26n pré-treinado como modelo de rotulagem:

from pathlib import Path

import torch

from ultralytics import YOLO
from ultralytics.data.utils import check_det_dataset
from ultralytics.utils.metrics import box_iou
from ultralytics.utils.ops import xywhn2xyxy

data = check_det_dataset("coco128.yaml")  # 128 labeled images, downloaded on first use
images = sorted(Path(data["train"]).glob("*.jpg"))
results = YOLO("yolo26n.pt").predict(images, conf=0.05, verbose=False)  # your labeling model

def review_work(result, image, conf):
    """Return (kept, delete, draw): correct pre-labels, false positives to delete, missed objects to draw."""
    label = Path(str(image).replace("images", "labels")).with_suffix(".txt")
    lines = label.read_text().splitlines() if label.exists() else []  # no label file = background image
    gt = torch.tensor([[float(x) for x in line.split()] for line in lines]).reshape(-1, 5)
    h, w = result.orig_shape
    gt_boxes, gt_cls = xywhn2xyxy(gt[:, 1:], w=w, h=h), gt[:, 0]
    boxes = result.boxes[result.boxes.conf >= conf]
    iou = box_iou(boxes.xyxy, gt_boxes) * (boxes.cls[:, None] == gt_cls[None])  # IoU with same-class boxes only
    matched = set()
    for row in iou:  # greedily match each prediction to its best unmatched ground-truth box
        for j in row.argsort(descending=True).tolist():
            if row[j] >= 0.5 and j not in matched:
                matched.add(j)
                break
    return len(matched), len(boxes) - len(matched), len(gt) - len(matched)

print("conf  kept  delete  draw  edits/image")
for conf in (0.1, 0.25, 0.4, 0.5, 0.7):
    kept, delete, draw = (sum(t) for t in zip(*(review_work(r, i, conf) for r, i in zip(results, images))))
    print(f"{conf:<5} {kept:>4} {delete:>7} {draw:>5} {(delete + draw) / len(images):>12.1f}")

conf  kept  delete  draw  edits/image
0.1    590     490   339          6.5
0.25   468     138   461          4.7
0.4    386      58   543          4.7
0.5    328      35   601          5.0
0.7    230       6   699          5.5

Como funciona e o que indica:

1. O modelo faz previsões uma vez com um conf=0.05 baixo; depois, cada limiar filtra as mesmas previsões, pelo que o teste é rápido.
2. review_work associa cada previsão a uma caixa de referência da mesma classe com IoU igual ou superior a 0.5. As previsões não associadas são caixas que um revisor elimina; os objetos de referência não associados são objetos que um revisor desenha.
3. O número de edições por imagem atinge o mínimo entre 0.25 e 0.4 (4.7). Abaixo desse intervalo, as eliminações disparam; acima, são as deteções em falta que disparam.
4. Mesmo no melhor limiar, os revisores desenham cerca de 3.6 caixas por imagem, porque a longa cauda de objetos pequenos do COCO é difícil de detetar para um modelo nano.

Regras de decisão: escolhe o limiar com menos edições por imagem. Se desenhar predominar em todos os limiares, o modelo de rotulagem é demasiado fraco para os dados, por isso usa um modelo maior ou o teu modelo ajustado. Se eliminar predominar mesmo em 0.5, o modelo confunde classes parecidas; verifica a matriz de confusão antes de anotar mais dados. No teu próprio projeto, testa os limiares com o teu modelo ajustado em 50–100 imagens que já anotaste.

Executa a anotação em lote#

A anotação em lote executa um modelo YOLO ou com indicação de classes em todo o conjunto de dados. Abre-a em More actions > Batch Annotation ou seleciona Annotate all na notificação após uma previsão no editor:

1. Escolhe o modelo. Os conjuntos de dados de deteção abrem com Moondream 3.1 selecionado; muda para o teu modelo ajustado ou modelo YOLO.
2. Num modelo YOLO, define a confiança para o limiar escolhido no teste (o valor predefinido é 0.25) e o IoU (0.7) e verifica as pré-visualizações de exemplo.
3. Deixa Include annotated images desativado para rotular apenas imagens sem rótulos.
4. Verifica o Estimated Cost ($1.00 por cada 1 000 imagens, mínimo de $0.01) e clica em Start.

Ao iniciar uma execução, é guardada primeiro uma versão do conjunto de dados para que possas restaurar o estado anterior à execução. Stop mantém e cobra as imagens processadas até esse momento.

Revê e mede a taxa de edição#

As previsões são guardadas como anotações normais, por isso nada indica que ainda não foram revistas. Filtra por classe para verificar primeiro as classes raras e ordena por Annotations em ordem crescente (prováveis deteções em falta) e decrescente (cenas congestionadas, onde as caixas se fundem). Em seguida, cria uma versão, abre Compare versions no separador Versions e escolhe v_auto como versão From:

Acompanha a taxa de edição de cada lote. Uma taxa crescente é o primeiro sinal de que as novas imagens se afastaram do que o modelo de rotulagem conhece. A lição sobre boas práticas de anotação aborda guias de rotulagem e concordância entre revisores.

Armadilhas#