Segment Anything Model

Segment Anything Model (SAM)

Guia abrangente para usar o Segment Anything Model da Meta AI para segmentação de imagens zero-shot.

Quando usar SAM

Use SAM quando:

• Precisar segmentar qualquer objeto em imagens sem treinamento específico da tarefa
• Construir ferramentas de anotação interativas com prompts de ponto/caixa
• Gerar dados de treinamento para outros modelos de visão
• Precisar de transferência zero-shot para novos domínios de imagem
• Construir pipelines de detecção/segmentação de objetos
• Processar imagens médicas, de satélite ou específicas de domínio

Principais características:

• Segmentação zero-shot: Funciona em qualquer domínio de imagem sem fine-tuning
• Prompts flexíveis: Pontos, caixas delimitadoras ou máscaras anteriores
• Segmentação automática: Gera todas as máscaras de objetos automaticamente
• Alta qualidade: Treinado em 1,1 bilhão de máscaras de 11 milhões de imagens
• Múltiplos tamanhos de modelo: ViT-B (mais rápido), ViT-L, ViT-H (mais preciso)
• Exportação ONNX: Deploy em navegadores e dispositivos edge

Use alternativas em vez disso:

• YOLO/Detectron2: Para detecção de objetos em tempo real com classes
• Mask2Former: Para segmentação semântica/panóptica com categorias
• GroundingDINO + SAM: Para segmentação com prompt de texto
• SAM 2: Para tarefas de segmentação de vídeo

Início rápido

Instalação

# Do GitHub
pip install git+https://github.com/facebookresearch/segment-anything.git

# Dependências opcionais
pip install opencv-python pycocotools matplotlib

# Ou use transformers do HuggingFace
pip install transformers

Baixar checkpoints

# ViT-H (maior, mais preciso) - 2.4GB
wget https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth

# ViT-L (médio) - 1.2GB
wget https://dl.fbaipublicfiles.com/segment_anything/sam_vit_l_0b3195.pth

# ViT-B (menor, mais rápido) - 375MB
wget https://dl.fbaipublicfiles.com/segment_anything/sam_vit_b_01ec64.pth

Uso básico com SamPredictor

import numpy as np
from segment_anything import sam_model_registry, SamPredictor

# Carregar modelo
sam = sam_model_registry["vit_h"](checkpoint="sam_vit_h_4b8939.pth")
sam.to(device="cuda")

# Criar preditor
predictor = SamPredictor(sam)

# Definir imagem (calcula embeddings uma vez)
image = cv2.imread("image.jpg")
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
predictor.set_image(image)

# Prever com prompts de ponto
input_point = np.array([[500, 375]])  # coordenadas (x, y)
input_label = np.array([1])  # 1 = foreground, 0 = background

masks, scores, logits = predictor.predict(
    point_coords=input_point,
    point_labels=input_label,
    multimask_output=True  # Retorna 3 opções de máscara
)

# Selecionar melhor máscara
best_mask = masks[np.argmax(scores)]

HuggingFace Transformers

import torch
from PIL import Image
from transformers import SamModel, SamProcessor

# Carregar modelo e processador
model = SamModel.from_pretrained("facebook/sam-vit-huge")
processor = SamProcessor.from_pretrained("facebook/sam-vit-huge")
model.to("cuda")

# Processar imagem com prompt de ponto
image = Image.open("image.jpg")
input_points = [[[450, 600]]]  # Lote de pontos

inputs = processor(image, input_points=input_points, return_tensors="pt")
inputs = {k: v.to("cuda") for k, v in inputs.items()}

# Gerar máscaras
with torch.no_grad():
    outputs = model(**inputs)

# Pós-processar máscaras para tamanho original
masks = processor.image_processor.post_process_masks(
    outputs.pred_masks.cpu(),
    inputs["original_sizes"].cpu(),
    inputs["reshaped_input_sizes"].cpu()
)

Conceitos principais

Arquitetura do modelo

Arquitetura SAM:
┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│  Image Encoder  │────▶│ Prompt Encoder  │────▶│  Mask Decoder   │
│     (ViT)       │     │ (Points/Boxes)  │     │ (Transformer)   │
└─────────────────┘     └─────────────────┘     └─────────────────┘
        │                       │                       │
   Image Embeddings      Prompt Embeddings         Masks + IoU
   (computed once)       (per prompt)             predictions

Variantes do modelo

Tipos de prompt

Segmentação interativa

Prompts de ponto

# Ponto único de foreground
input_point = np.array([[500, 375]])
input_label = np.array([1])

masks, scores, logits = predictor.predict(
    point_coords=input_point,
    point_labels=input_label,
    multimask_output=True
)

# Múltiplos pontos (foreground + background)
input_points = np.array([[500, 375], [600, 400], [450, 300]])
input_labels = np.array([1, 1, 0])  # 2 foreground, 1 background

masks, scores, logits = predictor.predict(
    point_coords=input_points,
    point_labels=input_labels,
    multimask_output=False  # Máscara única quando prompts são claros
)

Prompts de caixa

# Caixa delimitadora [x1, y1, x2, y2]
input_box = np.array([425, 600, 700, 875])

masks, scores, logits = predictor.predict(
    box=input_box,
    multimask_output=False
)

Prompts combinados

# Caixa + pontos para controle preciso
masks, scores, logits = predictor.predict(
    point_coords=np.array([[500, 375]]),
    point_labels=np.array([1]),
    box=np.array([400, 300, 700, 600]),
    multimask_output=False
)

Refinamento iterativo

# Predição inicial
masks, scores, logits = predictor.predict(
    point_coords=np.array([[500, 375]]),
    point_labels=np.array([1]),
    multimask_output=True
)

# Refinar com ponto adicional usando máscara anterior
masks, scores, logits = predictor.predict(
    point_coords=np.array([[500, 375], [550, 400]]),
    point_labels=np.array([1, 0]),  # Adicionar ponto de background
    mask_input=logits[np.argmax(scores)][None, :, :],  # Usar melhor máscara
    multimask_output=False
)

Geração automática de máscaras

Segmentação automática básica

from segment_anything import SamAutomaticMaskGenerator

# Criar gerador
mask_generator = SamAutomaticMaskGenerator(sam)

# Gerar todas as máscaras
masks = mask_generator.generate(image)

# Cada máscara contém:
# - segmentation: máscara binária
# - bbox: [x, y, w, h]
# - area: contagem de pixels
# - predicted_iou: pontuação de qualidade
# - stability_score: pontuação de robustez
# - point_coords: ponto gerador

Geração customizada

mask_generator = SamAutomaticMaskGenerator(
    model=sam,
    points_per_side=32,          # Densidade de grade (mais = mais máscaras)
    pred_iou_thresh=0.88,        # Limiar de qualidade
    stability_score_thresh=0.95,  # Limiar de estabilidade
    crop_n_layers=1,             # Crops multi-escala
    crop_n_points_downscale_factor=2,
    min_mask_region_area=100,    # Remover máscaras minúsculas
)

masks = mask_generator.generate(image)

Filtragem de máscaras

# Ordenar por área (maior primeiro)
masks = sorted(masks, key=lambda x: x['area'], reverse=True)

# Filtrar por IoU predito
high_quality = [m for m in masks if m['predicted_iou'] > 0.9]

# Filtrar por pontuação de estabilidade
stable_masks = [m for m in masks if m['stability_score'] > 0.95]

Inferência em lote

Múltiplas imagens

# Processar múltiplas imagens eficientemente
images = [cv2.imread(f"image_{i}.jpg") for i in range(10)]

all_masks = []
for image in images:
    predictor.set_image(image)
    masks, _, _ = predictor.predict(
        point_coords=np.array([[500, 375]]),
        point_labels=np.array([1]),
        multimask_output=True
    )
    all_masks.append(masks)

Múltiplos prompts por imagem

# Processar múltiplos prompts eficientemente (uma codificação de imagem)
predictor.set_image(image)

# Lote de prompts de ponto
points = [
    np.array([[100, 100]]),
    np.array([[200, 200]]),
    np.array([[300, 300]])
]

all_masks = []
for point in points:
    masks, scores, _ = predictor.predict(
        point_coords=point,
        point_labels=np.array([1]),
        multimask_output=True
    )
    all_masks.append(masks[np.argmax(scores)])

Deploy ONNX

Exportar modelo

python scripts/export_onnx_model.py \
    --checkpoint sam_vit_h_4b8939.pth \
    --model-type vit_h \
    --output sam_onnx.onnx \
    --return-single-mask

Usar modelo ONNX

import onnxruntime

# Carregar modelo ONNX
ort_session = onnxruntime.InferenceSession("sam_onnx.onnx")

# Executar inferência (embeddings de imagem calculados separadamente)
masks = ort_session.run(
    None,
    {
        "image_embeddings": image_embeddings,
        "point_coords": point_coords,
        "point_labels": point_labels,
        "mask_input": np.zeros((1, 1, 256, 256), dtype=np.float32),
        "has_mask_input": np.array([0], dtype=np.float32),
        "orig_im_size": np.array([h, w], dtype=np.float32)
    }
)

Workflows comuns

Workflow 1: Ferramenta de anotação

import cv2

# Carregar modelo
predictor = SamPredictor(sam)
predictor.set_image(image)

def on_click(event, x, y, flags, param):
    if event == cv2.EVENT_LBUTTONDOWN:
        # Ponto de foreground
        masks, scores, _ = predictor.predict(
            point_coords=np.array([[x, y]]),
            point_labels=np.array([1]),
            multimask_output=True
        )
        # Exibir melhor máscara
        display_mask(masks[np.argmax(scores)])

Workflow 2: Extração de objeto

def extract_object(image, point):
    """Extrair objeto no ponto com fundo transparente."""
    predictor.set_image(image)

    masks, scores, _ = predictor.predict(
        point_coords=np.array([point]),
        point_labels=np.array([1]),
        multimask_output=True
    )

    best_mask = masks[np.argmax(scores)]

    # Criar saída RGBA
    rgba = np.zeros((image.shape[0], image.shape[1], 4), dtype=np.uint8)
    rgba[:, :, :3] = image
    rgba[:, :, 3] = best_mask * 255

    return rgba

Workflow 3: Segmentação de imagem médica

# Processar imagens médicas (escala de cinza para RGB)
medical_image = cv2.imread("scan.png", cv2.IMREAD_GRAYSCALE)
rgb_image = cv2.cvtColor(medical_image, cv2.COLOR_GRAY2RGB)

predictor.set_image(rgb_image)

# Segmentar região de interesse
masks, scores, _ = predictor.predict(
    box=np.array([x1, y1, x2, y2]),  # Caixa de ROI
    multimask_output=True
)

Formato de saída

Estrutura de dados de máscara

# Saída de SamAutomaticMaskGenerator
{
    "segmentation": np.ndarray,  # Máscara binária H×W
    "bbox": [x, y, w, h],        # Caixa delimitadora
    "area": int,                 # Contagem de pixels
    "predicted_iou": float,      # Pontuação de qualidade 0-1
    "stability_score": float,    # Pontuação de robustez 0-1
    "crop_box": [x, y, w, h],    # Região de crop de geração
    "point_coords": [[x, y]],    # Ponto de entrada
}

Formato COCO RLE

from pycocotools import mask as mask_utils

# Codificar máscara para RLE
rle = mask_utils.encode(np.asfortranarray(mask.astype(np.uint8)))
rle["counts"] = rle["counts"].decode("utf-8")

# Decodificar RLE para máscara
decoded_mask = mask_utils.decode(rle)

Otimização de desempenho

Memória GPU

# Usar modelo menor para VRAM limitada
sam = sam_model_registry["vit_b"](checkpoint="sam_vit_b_01ec64.pth")

# Processar imagens em lotes
# Limpar cache CUDA entre lotes grandes
torch.cuda.empty_cache()

Otimização de velocidade

# Usar precisão reduzida
sam = sam.half()

# Reduzir pontos para geração automática
mask_generator = SamAutomaticMaskGenerator(
    model=sam,
    points_per_side=16,  # Padrão é 32
)

# Usar ONNX para deploy
# Exportar com --return-single-mask para inferência mais rápida

Problemas comuns

Referências

• Uso avançado - Batching, fine-tuning, integração
• Resolução de problemas - Problemas comuns e soluções

Recursos

• GitHub: https://github.com/facebookresearch/segment-anything
• Paper: https://arxiv.org/abs/2304.02643
• Demo: https://segment-anything.com
• SAM 2 (Vídeo): https://github.com/facebookresearch/segment-anything-2
• HuggingFace: https://huggingface.co/facebook/sam-vit-huge