Segment Anything Model 완전 정복: SAM 1 → SAM 2 → SAM 3 논문 분석과 실전 가이드

┌─────────────────────────────────────────────────────────┐
│                      SAM Architecture                    │
│                                                          │
│  ┌──────────────┐   ┌────────────────┐                   │
│  │ Image Encoder │   │ Prompt Encoder │                   │
│  │  (ViT-H/L/B) │   │ (Point/Box/    │                   │
│  │  MAE 사전학습  │   │  Mask/Text)    │                   │
│  └──────┬───────┘   └───────┬────────┘                   │
│         │                   │                            │
│         └─────────┬─────────┘                            │
│                   ▼                                      │
│          ┌────────────────┐                              │
│          │  Mask Decoder   │                              │
│          │ (Transformer    │                              │
│          │  2-layer)       │──→ 3개 마스크 + IoU 점수      │
│          └────────────────┘                              │
└─────────────────────────────────────────────────────────┘

Phase 1: Assisted-Manual        Phase 2: Semi-Automatic       Phase 3: Fully Automatic
─────────────────────          ──────────────────────         ──────────────────────
• SAM + 사람 어노테이터           • SAM이 자동 마스크 제안        • 32×32 그리드 포인트 자동 생성
• 브라우저 기반 도구              • 사람이 누락된 객체 추가       • NMS + 신뢰도 필터링
• 12만 이미지 / 430만 마스크     • 18만 이미지 / 590만 마스크    • 11억 마스크의 대부분

# 설치
pip install git+https://github.com/facebookresearch/segment-anything.git

# 선택 의존성
pip install opencv-python pycocotools matplotlib onnxruntime onnx

from segment_anything import SamPredictor, sam_model_registry
import numpy as np

# 모델 로드
sam = sam_model_registry["vit_h"](checkpoint="sam_vit_h_4b8939.pth")
sam.to(device="cuda")

# 예측기 생성
predictor = SamPredictor(sam)

# 이미지 설정 (이미지 임베딩 1회 계산)
predictor.set_image(image)  # numpy array (H, W, 3) RGB

# 포인트 프롬프트로 예측
masks, scores, logits = predictor.predict(
    point_coords=np.array([[500, 375]]),  # (N, 2) 좌표
    point_labels=np.array([1]),            # 1=전경, 0=배경
    multimask_output=True,                 # 3개 후보 마스크 반환
)

from segment_anything import SamAutomaticMaskGenerator, sam_model_registry

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

mask_generator = SamAutomaticMaskGenerator(sam)
masks = mask_generator.generate(image)
# 각 마스크: segmentation, area, bbox, predicted_iou, stability_score

┌────────────────────────────────────────────────────────────────────┐
│                    SAM 2 Streaming Architecture                    │
│                                                                    │
│  프레임 t-2    프레임 t-1    프레임 t (현재)                          │
│     │            │            │                                    │
│     ▼            ▼            ▼                                    │
│  ┌──────┐    ┌──────┐    ┌──────────────┐                          │
│  │Hiera │    │Hiera │    │ Hiera Image  │                          │
│  │Enc.  │    │Enc.  │    │   Encoder    │                          │
│  └──┬───┘    └──┬───┘    └──────┬───────┘                          │
│     │           │               │                                  │
│     ▼           ▼               ▼                                  │
│  ┌──────────────────────────────────────────┐                      │
│  │            Memory Bank                    │                      │
│  │  ┌──────────────┐  ┌───────────────────┐ │                      │
│  │  │ FIFO Queue   │  │ Prompted Frames   │ │                      │
│  │  │ (N 최근 프레임)│  │ (M 프롬프트 프레임)│ │                      │
│  │  └──────────────┘  └───────────────────┘ │                      │
│  │  ┌──────────────────────────────────────┐│                      │
│  │  │     Object Pointers (256-dim)        ││                      │
│  │  └──────────────────────────────────────┘│                      │
│  └──────────────────┬───────────────────────┘                      │
│                     ▼                                              │
│  ┌──────────────────────────────┐   ┌───────────────┐              │
│  │    Memory Attention Module    │←──│Prompt Encoder │              │
│  │ (L Transformer Blocks:       │   │(Point/Box/    │              │
│  │  Self-Attn + Cross-Attn)     │   │ Mask)         │              │
│  └──────────────┬───────────────┘   └───────────────┘              │
│                 ▼                                                   │
│  ┌──────────────────────────┐                                      │
│  │      Mask Decoder        │──→ 마스크 + IoU + Occlusion Score    │
│  │ (+ Skip Connections)     │                                      │
│  └──────────────────────────┘                                      │
└────────────────────────────────────────────────────────────────────┘

# 설치
git clone https://github.com/facebookresearch/sam2.git && cd sam2
pip install -e .

# 체크포인트 다운로드
cd checkpoints && ./download_ckpts.sh && cd ..

import torch
from sam2.build_sam import build_sam2
from sam2.sam2_image_predictor import SAM2ImagePredictor

checkpoint = "./checkpoints/sam2.1_hiera_large.pt"
model_cfg = "configs/sam2.1/sam2.1_hiera_l.yaml"
predictor = SAM2ImagePredictor(build_sam2(model_cfg, checkpoint))

with torch.inference_mode(), torch.autocast("cuda", dtype=torch.bfloat16):
    predictor.set_image(image)
    masks, _, _ = predictor.predict(
        point_coords=np.array([[500, 375]]),
        point_labels=np.array([1]),
    )

import torch
from sam2.build_sam import build_sam2_video_predictor

checkpoint = "./checkpoints/sam2.1_hiera_large.pt"
model_cfg = "configs/sam2.1/sam2.1_hiera_l.yaml"
predictor = build_sam2_video_predictor(model_cfg, checkpoint)

with torch.inference_mode(), torch.autocast("cuda", dtype=torch.bfloat16):
    state = predictor.init_state(video_path)

    # 특정 프레임에 프롬프트 추가
    frame_idx, object_ids, masks = predictor.add_new_points_or_box(
        state, frame_idx=0, obj_id=1,
        points=np.array([[500, 375]]),
        labels=np.array([1]),
    )

    # 비디오 전체 전파
    for frame_idx, object_ids, masks in predictor.propagate_in_video(state):
        # 각 프레임의 마스크 처리
        process_masks(frame_idx, masks)

from sam2.sam2_image_predictor import SAM2ImagePredictor
predictor = SAM2ImagePredictor.from_pretrained("facebook/sam2-hiera-large")

from sam2.sam2_video_predictor import SAM2VideoPredictor
predictor = SAM2VideoPredictor.from_pretrained("facebook/sam2-hiera-large")

SAM 1: 포인트/박스 → "이 위치의 객체를 분리해줘"
SAM 2: 포인트/박스 + 비디오 추적 → "이 객체를 비디오에서 따라가줘"
SAM 3: 텍스트/이미지 예시 → "이 개념에 해당하는 모든 것을 찾아줘"

┌───────────────────────────────────────────────────────────────────────┐
│                       SAM 3 Architecture                              │
│                                                                       │
│  ┌────────────┐  ┌────────────┐  ┌──────────────────┐                 │
│  │ Text       │  │ Exemplar   │  │ Visual Prompts   │                 │
│  │ Encoder    │  │ Encoder    │  │ (Point/Box/Mask) │                 │
│  │ "school    │  │ [이미지]    │  │                  │                 │
│  │  bus"      │  │            │  │                  │                 │
│  └─────┬──────┘  └─────┬──────┘  └────────┬─────────┘                 │
│        └────────────┬───┘                  │                          │
│                     ▼                      │                          │
│  ┌──────────────────────────────┐          │                          │
│  │   Meta Perception Encoder    │          │                          │
│  │   (Vision-Language 공동 공간) │          │                          │
│  └──────────────┬───────────────┘          │                          │
│                 │                          │                          │
│        ┌────────┴────────┐                 │                          │
│        ▼                 ▼                 │                          │
│  ┌───────────┐    ┌─────────────────┐      │                          │
│  │ Presence  │    │  Fusion Encoder │      │                          │
│  │   Head    │    │  (조건부 특징)   │      │                          │
│  │ "있다/없다"│    └────────┬────────┘      │                          │
│  └───────────┘             │               │                          │
│                            ▼               │                          │
│               ┌──────────────────┐         │                          │
│               │  DETR Detector   │←────────┘                          │
│               │  (Transformer    │                                    │
│               │   기반 검출)      │                                    │
│               └────────┬─────────┘                                    │
│                        │                                              │
│                        ▼                                              │
│  ┌──────────────────────────────────────┐                             │
│  │    SAM 2-inspired Tracker            │                             │
│  │    (Memory Bank + 시간적 일관성)      │                             │
│  └──────────────────┬───────────────────┘                             │
│                     ▼                                                 │
│              마스크 + 박스 + 점수                                      │
└───────────────────────────────────────────────────────────────────────┘

기존 방식: 검출기가 "찾기"와 "있는지 판단" 동시 수행 → 최적화 충돌
SAM 3:    Presence Head가 "있는지" 먼저 판단 → 검출기는 "찾기"에만 집중

# 환경 생성
conda create -n sam3 python=3.12
conda activate sam3

# PyTorch 설치
pip install torch==2.7.0 torchvision torchaudio \
    --index-url https://download.pytorch.org/whl/cu126

# SAM 3 설치
git clone https://github.com/facebookresearch/sam3.git
cd sam3
pip install -e .

# 선택: 노트북 또는 개발용
pip install -e ".[notebooks]"
pip install -e ".[train,dev]"

from PIL import Image
from sam3.model_builder import build_sam3_image_model
from sam3.model.sam3_image_processor import Sam3Processor

model = build_sam3_image_model()
processor = Sam3Processor(model)
image = Image.open("path/to/image.jpg")

# 텍스트 프롬프트로 개념 세그멘테이션
inference_state = processor.set_image(image)
output = processor.set_text_prompt(
    state=inference_state,
    prompt="yellow school bus"
)
masks, boxes, scores = output["masks"], output["boxes"], output["scores"]

from sam3.model_builder import build_sam3_video_predictor

video_predictor = build_sam3_video_predictor()
response = video_predictor.handle_request(
    request=dict(
        type="start_session",
        resource_path="path/to/video.mp4"
    )
)

pip install -U ultralytics

from ultralytics.models.sam import SAM3SemanticPredictor

overrides = dict(
    conf=0.25, task="segment", mode="predict",
    model="sam3.pt", half=True
)
predictor = SAM3SemanticPredictor(overrides=overrides)
predictor.set_image("path/to/image.jpg")

# 여러 개념 동시 세그멘테이션
results = predictor(text=["person", "bus", "glasses"])

1. SAM 1 논문 (2023) → 기초 개념 확립
   ↓
2. SAM 2 논문 (2024) → 비디오 확장 이해
   ↓
3. SAM 3 논문 (2025) → 개념 인식 이해
   ↓
4. 각 GitHub 레포의 노트북 실습