papers/sam2/sau.json

{
  "paper_id": "sam2",
  "paper_title": "SAM 2: Segment Anything in Images and Videos",
  "D1": [
    {
      "id": "sam2-D1-001",
      "claim": "Memory bank: FIFO queues store up to N=6 recent frames (with temporal position encoding) and M=unbounded prompted frames (no temporal PE) as spatial feature maps; object pointers stored as lightweight semantic vectors per frame.",
      "source": "Section 4, Appendix D.1"
    },
    {
      "id": "sam2-D1-002",
      "claim": "Memory attention: L=4 transformer blocks, each with self-attention (2D-RoPE), spatial memory cross-attention, object-pointer cross-attention (no RoPE), and MLP (GeLU); memory channel dimension=64; FlashAttention-2 kernels used.",
      "source": "Section 4, Appendix D.1"
    },
    {
      "id": "sam2-D1-003",
      "claim": "Object pointers: lightweight semantic vectors (dim=256, 4 tokens per frame) from mask decoder output tokens, stored in memory bank and cross-attended by subsequent frames for high-level object information.",
      "source": "Section 4, Appendix D.1"
    },
    {
      "id": "sam2-D1-004",
      "claim": "Image encoder: MAE pre-trained Hiera hierarchical ViT in four sizes (T/S/B+/L); FPN fuses stage 3 (stride 16) + stage 4 (stride 32) outputs; stage 1 (stride 4) + stage 2 (stride 8) skip connections feed mask decoder for high-resolution detail.",
      "source": "Section 4, Appendix D.1"
    },
    {
      "id": "sam2-D1-005",
      "claim": "Hiera global attention blocks across three stages by encoder size: T=5-7-9, S=7-10-13, B+=12-16-20, L=23-33-43; window attention used in remaining blocks.",
      "source": "Section 4, Appendix D.1"
    },
    {
      "id": "sam2-D1-006",
      "claim": "Positional encoding: image encoder uses windowed absolute positional embeddings (interpolated globally, no relative positional bias RPB); memory attention uses 2D-RoPE for self-attention and spatial cross-attention.",
      "source": "Section 4, Appendix D.1"
    },
    {
      "id": "sam2-D1-007",
      "claim": "Prompt encoder (identical to SAM): click/box/mask prompts encoded via sinusoidal PE + learned embeddings; mask decoder: two-way transformer (2 blocks), multi-mask predictions (3 masks for ambiguity), skip connections from encoder stages 1+2, occlusion prediction head (MLP on occlusion token).",
      "source": "Section 4, Appendix D.1"
    },
    {
      "id": "sam2-D1-008",
      "claim": "Training hyperparameters: default resolution 1024x1024 (ablation tested [512,768,1024]), 8-frame training sequences (ablation tested [4,8,10]), fine-tuning with 16-frame sequences, max 3 masklets per 8-frame training sequence, 7 correction clicks during iterative training, FlashAttention-2 enabled at 1024 resolution.",
      "source": "Section 4, Appendix D.1, Appendix A.2, Table 9"
    },
    {
      "id": "sam2-D1-009",
      "claim": "SA-1B pre-training data configuration: max 64 masks per image, masks covering >90% image area filtered out; random horizontal flip augmentation enabled; image encoder initialized from MAE pre-trained Hiera weights.",
      "source": "Section 4, Appendix D.1"
    },
    {
      "id": "sam2-D1-010",
      "claim": "Pre-training optimizer: AdamW (beta1=0.9, beta2=0.999), lr=4e-4, weight_decay=0.1, batch_size=256, 90K steps; reciprocal sqrt lr schedule (timescale=1000) with linear warmup 1000 iterations + linear cooldown 5000 iterations; bfloat16 precision; L2 gradient clipping max=0.1.",
      "source": "Appendix D.2.1"
    },
    {
      "id": "sam2-D1-011",
      "claim": "Pre-training loss weights: focal loss=20, dice loss=1, IoU prediction L1 loss=1 (ratio 20:1:1); per-frame best-mask selection via argmin of total segmentation loss across K predicted masks.",
      "source": "Appendix D.2.1"
    },
    {
      "id": "sam2-D1-012",
      "claim": "Layer-wise learning rate decay (image encoder only) by model size: T/S=0.8, B+=0.9, L=0.925; deeper layers receive progressively lower LR via exponential decay factor.",
      "source": "Appendix D.2.1"
    },
    {
      "id": "sam2-D1-013",
      "claim": "Stochastic depth (drop path) rate by model size: T/S=0.1, B+=0.2, L=0.3.",
      "source": "Appendix D.2.1"
    },
    {
      "id": "sam2-D1-014",
      "claim": "Full training (joint video+image) data mix: SA-1B ~15.2%, SA-V ~70.0%, Internal ~14.8%; with open-source VOS datasets added: DAVIS ~1.3%, MOSE ~9.4%, YouTubeVOS ~9.2%, SA-1B ~15.5%, SA-V ~49.5%, Internal ~15.1%.",
      "source": "Appendix D.2.2"
    },
    {
      "id": "sam2-D1-015",
      "claim": "Interactive prompt sampling in full training: initial prompt type probs GT mask=0.5, positive click=0.25, bbox=0.25; up to 2 prompted frames per 8-frame seq; reverse temporal order prob 0.5; random correction click prob 0.1; 2x2 mosaic transform prob 0.1 (same video tiled, simulates similar-looking objects).",
      "source": "Appendix D.2.2"
    },
    {
      "id": "sam2-D1-016",
      "claim": "Full training loss weights: focal=20, dice=1, MAE IoU prediction=1, cross-entropy occlusion prediction=1 (ratio 20:1:1:1); when GT has no mask for a frame (object absent/occluded), mask outputs are not supervised and only occlusion loss applies.",
      "source": "Appendix D.2.2"
    },
    {
      "id": "sam2-D1-017",
      "claim": "Data augmentation pipeline: random horizontal flip (p=0.5); affine transform (rotation ±25°, shear ±15°, scale [0.7,1.3], translate ±10%); color jitter (brightness ±0.2, contrast ±0.2, saturation ±0.2, hue ±0.1); random grayscale (p=0.1).",
      "source": "Appendix D.2.2, Table 12"
    },
    {
      "id": "sam2-D1-018",
      "claim": "Fine-tuning protocol (Stage 3): 50K iterations (1/3 of full training schedule), learning rate 0.5x base lr (2e-4), freeze image encoder, 16-frame sequences, top 50% most-edited (most challenging) masklets selected for training, 80GB A100 GPUs.",
      "source": "Appendix D.2.2"
    },
    {
      "id": "sam2-D1-019",
      "claim": "SA-V dataset: 50.9K videos, 642.6K masklets (190.9K manual + 451.7K auto-generated), 35.5M masks (10.0M manual-only), 4.2M frames, 196.0 hrs total duration; 53x more masks than any existing VOS dataset (15x without auto annotations).",
      "source": "Section 5.2, Appendix E.1"
    },
    {
      "id": "sam2-D1-020",
      "claim": "SA-V dataset properties: 54% indoor / 46% outdoor scenes across 47 countries; object disappearance rate 42.5% (manual only) / 27.7% (manual+auto); 88% of masks have normalized area <0.1 (predominantly small objects and parts).",
      "source": "Section 5.2, Appendix E.1"
    },
    {
      "id": "sam2-D1-021",
      "claim": "SA-V val/test splits: val set 155 videos / 293 masklets, test set 150 videos / 278 masklets; split by video authors and geographic location; annotated at 6 FPS using Phase 1 per-frame setup; focuses on challenging fast-moving, occluded, disappearing/reappearing objects.",
      "source": "Section 5.2, Appendix E.1"
    },
    {
      "id": "sam2-D1-022",
      "claim": "Internal training dataset: 62.9K videos, 69.6K masklets (Phase 2+3 annotated), 5.4M masks, 6.0M frames, 281.8 hrs total, disappearance rate 36.4%; internal test set: 96 videos / 189 masklets (Phase 1 annotated).",
      "source": "Section 5.2"
    },
    {
      "id": "sam2-D1-023",
      "claim": "Auto masklet generation: multi-scale first-frame grid prompting (32x32 full-frame grid, 16x16 on 2x2 zoomed crops, 4x4 on 4x4 zoomed crops); post-processing removes tiny connected components (<200 px) and fills holes (<200 px); satisfactory masklets added to SA-V, unsatisfactory ones sent to human annotators for refinement.",
      "source": "Section 5.1, Appendix E.2"
    },
    {
      "id": "sam2-D1-024",
      "claim": "Interactive evaluation protocol: N_click=3 clicks per frame, N_frame=8 max interacted frames, T_loc=1.0s visual locate time per frame, T_click=1.5s per click; offline mode: multi-pass selects lowest-IoU frame for next prompt; online mode: single pass pauses at IoU<0.75 for correction; clicks sampled at object center then error-region centroids.",
      "source": "Appendix B, Appendix F.1.2"
    },
    {
      "id": "sam2-D1-025",
      "claim": "Evaluation benchmark coverage: 17 zero-shot video datasets (9 densely annotated) for interactive and VOS evaluation; 37 zero-shot image datasets (23 from SAM benchmark + 14 video-derived) for SA task; prompt types tested: 1-click, 3-click, 5-click, bounding box, ground-truth mask.",
      "source": "Appendix B, Appendix F.1.2, Appendix F.1.3, Appendix F.4"
    },
    {
      "id": "sam2-D1-026",
      "claim": "Architecture ablation search space (conducted at default 512 resolution): input resolutions [512,768,1024], frames per sequence [4,8,10], memories N [4,6,8], memory channel dim [64,256], memory attention blocks [(sa=2,ca=2), (sa=3,ca=2), (sa=4,ca=4)], image encoder sizes [T,S,B+,L]; evaluated on video J&F and image mIoU.",
      "source": "Appendix A.2, Table 9"
    },
    {
      "id": "sam2-D1-027",
      "claim": "Training infrastructure: 256 NVIDIA A100 GPUs for distributed training; SA-V data collection period Nov 2023 - Mar 2024, masklet annotation period Apr - Jul 2024.",
      "source": "Appendix D.2"
    },
    {
      "id": "sam2-D1-028",
      "claim": "Data engine quality validation: controlled experiment with 169 videos / 452 masklets comparing Phase 1-3 annotation quality (Phase 1 Mask Alignment Score, IoU>0.75 threshold); mask area classification thresholds: small 1-32^2 px, medium 32^2-96^2 px, large >=96^2 px.",
      "source": "Appendix E.2"
    }
  ],
  "D2": [
    {
      "id": "sam2-D2-001",
      "claim": "Image Encoder - FPN Feature Fusion with Hiera: For each video frame at time t:\n  features_stride16 = Hiera.stage3(frame_t)  # Stage 3 output\n  features_stride32 = Hiera.stage4(frame_t)  # Stage 4 output\n  image_embedding_t = FPN_fuse(upsample(features_stride32), features_stride16)\n  # Stride 4 and 8 features (stages 1, 2): reserved for mask decoder skip connections\n  skip_stride8_t = Hiera.stage2(frame_t)\n  skip_stride4_t = Hiera.stage1(frame_t)\n\nFPN_fuse: bilinear upsample stride-32 to match stride-16 spatial dims, then element-wise add or concat + projection.\nHiera stages: hierarchical ViT, global attention at sparse layers. MAE pre-trained. Absolute windowed pos embed only, no RPB.\n\nVariable definitions:\n  features_strideX: spatial feature map at stride X (spatial resolution = input/X x input/X)\n  image_embedding_t: encoder output for frame t (shared across all objects in video)\n  skip_strideX_t: high-res features passed to mask decoder for detail recovery",
      "source": "4, D.1"
    },
    {
      "id": "sam2-D2-002",
      "claim": "Memory Attention - L-Block Transformer with 2D-RoPE: For current frame t with encoder output E_t, using L=4 transformer blocks:\n  X_0 = E_t  # Image embedding from FPN\n  for l in 0..L-1:\n    X_l_norm1 = LayerNorm(X_l)\n    X_l_self  = X_l + SelfAttention(X_l_norm1, RoPE=2D_RoPE)  # 2D RoPE applied\n    X_l_norm2 = LayerNorm(X_l_self)\n    X_l_cross_spatial = X_l_self + CrossAttention(X_l_norm2, K=mem_spatial, V=mem_spatial)\n    X_l_norm3 = LayerNorm(X_l_cross_spatial)\n    X_l_cross_obj = X_l_cross_spatial + CrossAttention(X_l_norm3, K=mem_obj_ptr, V=mem_obj_ptr)  # object pointers, no RoPE\n    X_l_norm4 = LayerNorm(X_l_cross_obj)\n    X_{l+1} = X_l_cross_obj + MLP(X_l_norm4)  # FFN with GeLU\n  output = X_L  # conditioned frame embedding [C, H, W]",
      "source": "4, D.1, A.2.2"
    },
    {
      "id": "sam2-D2-003",
      "claim": "Prompt Encoder - Click / Box / Mask Encoding: For frame t with conditioned embedding C_t = conditioned_embedding_t:\n\n  # Sparse prompts (clicks, boxes):\n  pos_enc_pt = sinusoidal_positional_encoding(x_norm, y_norm)  # per (x,y) coordinate\n  sparse_embed = sum_{prompts}[ learned_emb[prompt_type] + pos_enc_pt ]\n  # prompt_type in {pos_click=0, neg_click=1, box_corner=2}\n\n  # Dense prompt (mask):\n  mask_embed = ConvModule(input_mask)  # 2-layer Conv2D, same resolution as frame embedding\n  conditioned_embedding_t = C_t + mask_embed + sparse_embed  # element-wise sum",
      "source": "4"
    },
    {
      "id": "sam2-D2-004",
      "claim": "Mask Decoder - Two-Way Transformer with Skip Connections: Input: frame_with_prompts_t, skip_stride4_t, skip_stride8_t\n\n  # Step 1: Two-way transformer (bidirectional prompt-to-image and image-to-prompt attention)\n  prompt_tokens, image_tokens = TwoWayTransformer(frame_with_prompts_t, num_blocks=2)\n  # Each block: self-attn on prompts + cross-attn prompts->image + self-attn on image + cross-attn image->prompts + MLP\n\n  # Step 2: Upsample with skip connections - inject stride-8 (stage 2) then stride-4 (stage 1) features from Hiera image encoder into decoder upsampling layers for high-resolution mask detail (see Fig. 8)\n  upsampled = bilinear_upsample(image_tokens)\n  upsampled = upsampled + conv_proj(skip_stride8_t)  # add high-res features from encoder stage 2 (stride 8)\n  upsampled = bilinear_upsample(upsampled)\n  upsampled = upsampled + conv_proj(skip_stride4_t)  # add high-res features from encoder stage 1 (stride 4)\n\n  # Step 3: Output heads - produce K=3 masks (for ambiguous prompts, e.g. single click), IoU scores, and occlusion prediction\n  masks = conv_head(upsampled)  # 3 masks [K, H, W]\n  iou_scores = sigmoid(MLP_iou(mask_tokens))  # predicted IoU per mask, sigmoid constrains to [0,1]\n  occlusion_score = sigmoid(MLP_occ(occlusion_token))  # object visibility likelihood on current frame\n  # mask token corresponding to output mask stored as object pointer in memory bank (Sec 4, Appendix D.1)\n\n  # Step 4: Multi-mask selection - if no follow-up prompts resolve ambiguity, propagate mask with highest predicted IoU\n  if not has_follow_up_prompt:\n    best_k = argmax(iou_scores)\n    output_mask = masks[best_k]\n\nVariable definitions:\n  skip_stride4_t, skip_stride8_t: high-resolution feature maps from Hiera stages 1 and 2 (not passed through memory attention), used only in mask decoder upsampling\n  occlusion_token: additional learnable token alongside mask and IoU output tokens, fed to MLP head for object presence prediction\n  mask_tokens: output tokens from two-way transformer decoder, one used as 256-dim object pointer stored in memory bank",
      "source": "4, D.1, D.2"
    },
    {
      "id": "sam2-D2-005",
      "claim": "Memory Encoder - Mask-Image Fusion with Conv: For frame t, after mask prediction:\n\n  # Step 1: Downsample predicted mask to match memory spatial resolution\n  mask_down = ConvDownsample(output_mask_logits)  # conv stride ~16-32 to match memory resolution\n  # output_mask_logits: from mask decoder (raw logits, no sigmoid during training)\n\n  # Step 2: Element-wise add with unconditioned image encoder embedding (Hiera FPN output, NOT memory-conditioned)\n  fused = mask_down + image_embedding_t  # image_embedding_t reused from image encoder (no extra encoder needed)\n\n  # Step 3: Lightweight convolutional fusion to combine mask and image information\n  memory_feats = ConvFusion(fused)  # 2-3 light-weight conv layers (3x3, GeLU activation)\n\n  # Step 4: Project to 64-dim channel for efficient memory bank storage (Appendix D.1)\n  memory_feats = ConvProj(memory_feats, out_channels=64)  # 64-dim spatial feature map\n\nVariable definitions:\n  output_mask_logits: raw logit mask from mask decoder BEFORE sigmoid binarization\n  image_embedding_t: unconditioned frame embedding from image encoder (Hiera + FPN, stride 16), shared across all objects in video\n  memory_feats: final 64-channel spatial feature map stored in memory bank for cross-attention by subsequent frames\n  ConvDownsample: convolutional downsampling module (stride 16 or 32) to match memory spatial resolution\n  ConvFusion: lightweight conv layers (no additional image encoder) that fuse downsampled mask with image embedding",
      "source": "4, D.1"
    },
    {
      "id": "sam2-D2-006",
      "claim": "Memory Bank - FIFO Queue Management: MemoryBank state:\n  spatial_memory_queue: deque(maxlen=N)  # N=6 recent frames (default)\n  prompted_memory_queue: deque(maxlen=M)  # M = same as N\n  object_pointers_list: list  # lightweight semantic vectors\n  temporal_position_counter: int = 0\n\n  def update(memory_feats_t, obj_ptr_256, is_prompted, occ_pred):\n    # memory_feats_t: 64-dim spatial features from MemoryEncoder\n    # obj_ptr_256: 256-dim semantic vector from mask decoder output token\n    # Split obj_ptr into 4 tokens of 64-dim for cross-attention compatibility (Appendix D.1)\n    obj_ptr_4tokens = reshape(obj_ptr_256, [4, 64])  # [256] -> [4, 64]\n    \n    if is_prompted:\n      # Prompted frame: NO temporal positional encoding added\n      # (training signal from prompted frames is sparser, harder to generalize temporal range)\n      if occ_pred < 0.5:\n        # Object predicted occluded/invisible: add learned occlusion embedding to memory features\n        memory_feats_t = memory_feats_t + learned_occlusion_embed\n      prompted_memory_queue.append({'features': memory_feats_t, 'obj_ptr': obj_ptr_4tokens})\n    else:\n      # Recent (unprompted) frame: add temporal positional encoding for short-term motion representation\n      memory_feats_t = memory_feats_t + temporal_pos_encoding[temporal_position_counter]\n      temporal_position_counter += 1\n      spatial_memory_queue.append({'features': memory_feats_t, 'obj_ptr': obj_ptr_4tokens})\n    \n    object_pointers_list.append(obj_ptr_4tokens)  # stored for cross-attention in subsequent frames",
      "source": "4, D.1"
    },
    {
      "id": "sam2-D2-007",
      "claim": "Memory Bank Retrieval - Feature Assembly for Cross-Attention: def get_cross_attention_inputs():\n  # Assemble spatial memory features (keys = values):\n  spatial_features = []\n  for m in spatial_memory_queue:  # recent frames (with temporal PE)\n    spatial_features.append(m['features'])  # shape [C, H_mem, W_mem] where C=64\n  for m in prompted_memory_queue:  # prompted frames (NO temporal PE)\n    spatial_features.append(m['features'])\n  spatial_KV = concat_and_reshape(spatial_features)  # flatten each [64, H, W] -> [64, H*W], concat -> [total_tokens, 64] for cross-attention\n\n  # Assemble object pointer features (lightweight semantic vectors):\n  obj_ptr_tokens = []\n  for obj_ptr in object_pointers_list:  # each obj_ptr is [4, 64]\n    obj_ptr_tokens.append(obj_ptr)  # 4 tokens per frame, 64-dim each\n  obj_ptr_KV = concat_along_token_dim(obj_ptr_tokens)  # [total_frames * 4, 64]\n\n  return spatial_KV, obj_ptr_KV  # both used as keys and values in memory attention cross-attention layers (no RoPE on object pointers)",
      "source": "4, D.1"
    },
    {
      "id": "sam2-D2-008",
      "claim": "Streaming Inference - Full Forward Pass for One Frame: # Complete per-frame inference loop for single object in streaming mode:\n  memory_bank = MemoryBank(N=6)\n  \n  for t in 0..num_frames:\n    # 1. Image encoder (run once per frame, cached for multi-object):\n    if image_embedding_cache[t] is None:\n      image_embedding_t, skip_feats_t = ImageEncoder(frame_t)\n      image_embedding_cache[t] = (image_embedding_t, skip_feats_t)\n    else:\n      image_embedding_t, skip_feats_t = image_embedding_cache[t]  # reuse cached features for multi-object inference\n    \n    # 2. Memory attention: condition frame embedding on memory bank (spatial features + object pointers)\n    spatial_KV, obj_ptr_KV = memory_bank.get_cross_attention_inputs()\n    conditioned_t = MemoryAttention(image_embedding_t, spatial_KV, obj_ptr_KV)  # L=4 blocks with 2D-RoPE\n    \n    # 3. Prompt encoding (if any prompts provided on frame t):\n    if prompts[t] is not None:\n      conditioned_with_prompts_t = PromptEncoder(conditioned_t, prompts[t])  # clicks/boxes/masks\n    else:\n      conditioned_with_prompts_t = conditioned_t  # no prompt on this frame, propagate from memory\n    \n    # 4. Mask decoder with skip connections (high-res detail from encoder stages 1+2, bypassing memory attention):\n    masks_t, iou_scores_t, occ_score_t = MaskDecoder(\n        conditioned_with_prompts_t, skip_feats_t['stride4'], skip_feats_t['stride8'])\n    \n    # 5. Multi-mask selection and memory encoding:\n    if has_new_prompt_on_frame(t):\n      best_k = select_best_by_prompt(masks_t)  # user prompt may resolve ambiguity\n    else:\n      best_k = argmax(iou_scores_t)  # select mask with highest predicted IoU\n    output_mask_t = masks_t[best_k]\n    memory_feats_t = MemoryEncoder(output_mask_t, image_embedding_t)  # fuse mask + embedding for next frames\n    \n    # 6. Update memory bank for future frames:\n    obj_ptr_256 = extract_mask_token_from_decoder()  # 256-dim semantic vector from mask decoder output token\n    memory_bank.update(memory_feats_t, obj_ptr_256, is_prompted=(prompts[t] is not None), occ_pred=occ_score_t[best_k])\n\nNote: For multi-object inference, image encoder runs once and its features are shared. Memory bank, memory attention, mask decoder run independently per object. (Appendix D.1)",
      "source": "4, D.1, D.3"
    },
    {
      "id": "sam2-D2-009",
      "claim": "Training Loss - Focal Loss (Pixel-Level Mask Supervision): def focal_loss(pred_logits, gt_mask, alpha=0.25, gamma=2.0):\n  pred_prob = sigmoid(pred_logits)\n  # Where GT = 1:\n  pt_pos = pred_prob[gt_mask == 1]\n  loss_pos = -alpha * (1 - pt_pos)^gamma * log(pt_pos + epsilon)\n  # Where GT = 0:\n  pt_neg = 1 - pred_prob[gt_mask == 0]\n  loss_neg = -(1 - alpha) * pt_neg^gamma * log(pt_neg + epsilon)\n  return mean(loss_pos) + mean(loss_neg)\n\nVariable definitions:\n  pred_logits: raw output logits from mask decoder (pre-sigmoid), shape [H, W]\n  pred_prob: predicted probability mask after sigmoid activation, shape [H, W]\n  gt_mask: binary ground-truth mask, shape [H, W], values in {0, 1}\n  alpha: positive class weighting factor (default 0.25), balances foreground vs background\n  gamma: focusing parameter (default 2.0), down-weights loss on well-classified pixels\n  epsilon: small constant for numerical stability (~1e-7)\n  pt_pos: predicted probability p_t for positive (foreground) pixels, closer to 1 is better\n  pt_neg: predicted probability p_t for negative (background) pixels after flip (1 - pred_prob), closer to 1 is better",
      "source": "D.2"
    },
    {
      "id": "sam2-D2-010",
      "claim": "Training Loss - Dice Loss (Global Mask-Level Supervision): def dice_loss(pred_logits, gt_mask, epsilon=1e-6):\n  pred_prob = sigmoid(pred_logits)\n  numerator = 2 * sum(pred_prob * gt_mask)\n  denominator = sum(pred_prob) + sum(gt_mask)\n  dice_coeff = (numerator + epsilon) / (denominator + epsilon)\n  return 1 - dice_coeff\n\nVariable definitions:\n  pred_prob: predicted probability mask (after sigmoid), [H, W]\n  gt_mask: binary ground-truth mask [H, W]",
      "source": "D.2"
    },
    {
      "id": "sam2-D2-011",
      "claim": "Training Loss - L1/MAE IoU Supervision: # For each of K predicted masks:\n  for k in 0..K-1:\n    pred_iou[k] = sigmoid(iou_logits[k])  # sigmoid constrains output to [0,1]\n    pred_mask_bin = sigmoid(mask_logits[k]) > 0.5\n    true_iou[k] = IoU(pred_mask_bin, gt_mask)  # = |intersection| / |union|\n    L_iou[k] = |pred_iou[k] - true_iou[k]|  # L1 / MAE\n\n  # First click (multi-mask): supervise IoU of ALL masks\n  if is_first_click:\n    L_iou_total += sum(L_iou[k] for k in 0..K-1)  # all K IoU predictions supervised (encourages learning of bad masks)\n  else:\n    L_iou_total += L_iou[best_k]  # supervise only best mask IoU for correction clicks",
      "source": "D.2"
    },
    {
      "id": "sam2-D2-012",
      "claim": "Training Loss - Occlusion / Existence Prediction (Binary Cross-Entropy): # For each frame t in the training sequence:\n  pred_occ[t] = sigmoid(occlusion_logit[t])\n  true_occ[t] = 1 if GT_mask_exists[t] else 0\n  L_occ[t] = -[true_occ[t] * log(pred_occ[t]) + (1 - true_occ[t]) * log(1 - pred_occ[t])]\n  L_occ = (1/T) * sum_{t=0}^{T-1} L_occ[t]  # average over all frames\n\n  # CRITICAL RULE: if GT has NO mask for frame t (true_occ=0):\n  #   mask outputs: NOT supervised (no mask loss for that frame)\n  #   occlusion prediction head: ALWAYS supervised regardless of mask presence (Sec D.2.2)",
      "source": "4, D.1, D.2"
    },
    {
      "id": "sam2-D2-013",
      "claim": "Training Loss - Total Loss Aggregation: # Full loss with weight ratio 20 : 1 : 1 : 1\n\n  # Per-frame mask selection for loss computation:\n  for t in 0..T-1:\n    if GT_mask_exists[t]:\n      for k in 0..K-1:\n        L_seg[k] = 20 * L_focal[k] + 1 * L_dice[k]  # k-th mask segmentation loss\n      best_k = argmin_k(L_seg[k])\n      L_mask_total += 20 * L_focal[best_k] + 1 * L_dice[best_k]\n      L_iou_total += L_iou[best_k]  # or all K masks on first click (all-K IoU supervision; correction: only best mask)\n    else:\n      L_mask_total += 0  # GT mask absent: skip mask losses, occlusion only\n  L_total = L_mask_total + 1 * L_iou_total + 1 * L_occ[all]  # ratio 20:1:1:1",
      "source": "D.2"
    },
    {
      "id": "sam2-D2-014",
      "claim": "Training - Interactive Prompt Sampling Strategy: # Training data construction per 8-frame sequence:\n  seq_frames = sample_8_consecutive_frames(video)\n  \n  # Randomly select up to 2 frames for prompting:\n  num_prompted = randint(0, min(2, 8))\n  prompted_idx = random_sample(range(8), num_prompted)\n  \n  for idx in prompted_idx:\n    # Initial prompt type sampling:\n    init_type = categorical_sample({\n      'ground_truth_mask':   0.50,\n      'positive_click':      0.25,\n      'bounding_box':        0.25})\n    # Reverse temporal order with 50% probability for bidirectional generalization\n    if random() < 0.50:\n      seq_frames = reverse(seq_frames)\n    # Random correction click (10% prob): sample from GT irrespective of model prediction\n    if random() < 0.10:\n      correction_click = sample_random_click_from_gt(gt_masklet)",
      "source": "4, D.2"
    },
    {
      "id": "sam2-D2-015",
      "claim": "Training - AdamW Optimizer with Layer-Wise Decay: # Optimizer instantiation:\n  optimizer = AdamW(model.parameters(),\n    lr=base_lr,  betas=(0.9, 0.999),  weight_decay=0.1)\n\n  # Layer-wise learning rate decay (applied to image encoder):\n  encoder_layers = image_encoder.get_all_layers()  # ordered from top to bottom\n  num_layers = len(encoder_layers)\n  for i, layer in enumerate(encoder_layers):\n    layer_lr_ratio = layer_decay ^ (num_layers - 1 - i)  # deeper layers get lower LR (i=0 is top)\n    param_group = {'params': layer.parameters(), 'lr': base_lr * layer_lr_ratio}\n    optimizer.param_groups.append(param_group)\n  # layer_decay values: T/S=0.8, B+=0.9, L=0.925 (Table 12a)",
      "source": "D.2"
    },
    {
      "id": "sam2-D2-016",
      "claim": "Training - Reciprocal Square-Root LR Schedule: def reciprocal_sqrt_schedule(iteration, base_lr=4e-4, timescale=1000,\n                              warmup_iters=1000, cooldown_iters=5000, total_iters=180000):\n  # Linear warmup (0 -> base_lr):\n  if iteration < warmup_iters:\n    warmup_factor = iteration / warmup_iters\n  else:\n    warmup_factor = 1.0\n  \n  # Reciprocal sqrt main schedule:\n  sqrt_factor = sqrt(timescale / max(iteration, 1))  # sqrt(1000 / iter)\n  \n  # Linear cooldown (base_lr -> 0 over last cooldown_iters):\n  if iteration > total_iters - cooldown_iters:\n    cooldown_factor = max(0, total_iters - iteration) / cooldown_iters\n  else:\n    cooldown_factor = 1.0\n  \n  lr = base_lr * warmup_factor * sqrt_factor * cooldown_factor\n  return lr",
      "source": "D.2"
    },
    {
      "id": "sam2-D2-017",
      "claim": "Mosaic Transform - 2x2 Same-Video Augmentation: # Applied with 10% probability during full training only:\n  if rand() < 0.10:\n    # Duplicate the same training video into 2x2 tiled grid:\n    video_tiled = tile_2x2_grid(same_video)  # each tile = original video at half W, H\n    \n    # Select random quadrant as target object:\n    target_quadrant = randint(0, 3)\n    gt_masklet = masklets_list[target_quadrant]  # corresponding ground-truth\n    \n    # Model must use motion/temporal continuity to distinguish target from\n    # identical-looking counterparts in other quadrants. Reduced object size\n    # (half width/height) also facilitates small-object segmentation (Sec D.2.2).\n",
      "source": "D.2.2"
    },
    {
      "id": "sam2-D2-018",
      "claim": "16-Frame Fine-Tuning for Long Videos: # Fine-tuning stage to improve long-video performance:\n\n  # Data selection: top 50% most-edited (most challenging) masklets\n  masklets_sorted = sort_by_desc(num_edited_frames(all_masklets))\n  challenging_masklets = masklets_sorted[0 : len(masklets_sorted) // 2]\n  # Keep full OSS datasets (DAVIS, MOSE, YouTubeVOS) in mix\n\n  # Training config:\n  sequence_length = 16  # doubled from 8\n  total_iterations = 50000  # ~1/3 of full training schedule\n  base_lr = 2e-4  # half of original 4e-4\n  freeze(image_encoder)  # to fit 16-frame sequences into 80GB A100 GPUs",
      "source": "D.2.2"
    },
    {
      "id": "sam2-D2-019",
      "claim": "Offline Interactive Evaluation - Multi-Pass Algorithm: # Simulates annotator iteratively refining worst frames:\n  prompts_storage = dict()  # frame_idx -> list of (x, y, type)\n  \n  # First pass: initial prompts on first frame\n  prompts_storage[0] = sample_center_click(GT_mask[0]) + 2 correction clicks\n  \n  for pass_id in 1..8:  # N_frame = 8 passes max\n    # Run full video segmentation with accumulated prompts\n    masklet = run_full_video(video, prompts_storage)\n    # Find frame with lowest IoU for next-pass prompting\n    errors = [IoU(masklet[t], GT_mask[t]) for t in 0..T-1]\n    worst_frame = argmin(errors)\n    # Sample 3 correction clicks at error-region centroids\n    correction_clicks = sample_3_clicks_from_error(masklet[worst_frame], GT_mask[worst_frame])\n    prompts_storage[worst_frame].extend(correction_clicks)\n  return masklet",
      "source": "6.1, F.1.2"
    },
    {
      "id": "sam2-D2-020",
      "claim": "Online Interactive Evaluation - Single Pass with Pausing: # Single forward pass with IoU-gated pausing for corrections:\n  prompts_storage = dict()\n  prompts_storage[0] = sample_center_click(GT_mask[0]) + 2 correction clicks\n  num_prompted = 1\n  \n  for t in 0..num_frames:\n    # Run frame t conditioned on memory + any prompts at t\n    mask_t = forward_one_frame(frame_t, prompts_storage.get(t, None), memory_bank)\n    iou_t = IoU(mask_t, GT_mask[t])\n    \n    if iou_t < 0.75 and num_prompted < 8:\n      # Pause: sample 3 correction clicks at error region centroids\n      correction_clicks = sample_3_clicks_from_error(mask_t, GT_mask[t])\n      prompts_storage[t] = correction_clicks\n      num_prompted += 1\n      # Re-run frame t with new prompts (only affects t onwards, not previous frames)\n      mask_t = forward_one_frame(frame_t, prompts_storage[t], memory_bank)\n    memory_bank.update(mask_t)  # push into memory for subsequent frames\n  return masklet",
      "source": "6.1, F.1.2"
    },
    {
      "id": "sam2-D2-021",
      "claim": "Semi-Supervised VOS - First-Frame-Only Prompt Evaluation: # Standard VOS protocol: prompts only on first frame (no interactive refinement):\n  \n  # CLICK mode (1, 3, or 5 clicks):\n  clicks = []\n  # First click: center of GT mask\n  clicks.append(center_of_mass(GT_mask_first_frame))\n  # Additional clicks: center of error region (iterative)\n  for i in 1..N_clicks-1:\n    current_mask = SAM2.predict(first_frame, clicks)\n    error = XOR(current_mask, GT_mask_first_frame)\n    next_center = center_of_mass(error)\n    clicks.append(next_center)\n  # Segment entire video with accumulated first-frame clicks only\n  masklet = SAM2.run_video(first_frame_prompts=clicks)\n  return masklet",
      "source": "6.2, F.1.3"
    },
    {
      "id": "sam2-D2-022",
      "claim": "Automatic Masklet Generation - Grid Prompting + Post-Processing: # Generate candidate masklets from first frame, propagate, post-process:\n  # Step 1: Multi-scale grid prompting on first frame\n  grid_32 = make_grid(32, 32)                     # 1024 points, full frame\n  grid_16a = make_grid(16, 16) on crop_2x2[0]    # 256 pts * 4 crops = 1024 pts\n  grid_4a = make_grid(4, 4) on crop_4x4[0]       # 16 pts * 16 crops = 256 pts\n  all_prompts = flatten(grid_32 + grid_16a + grid_4a)  # combine all grid prompts from 3 scales\n\n  # Step 2: Propagate each candidate through full video and post-process\n  for prompt in all_prompts:\n    masklet = SAM2.run_video(first_frame_prompt=prompt)\n    # Remove tiny disconnected components (<200 px) and fill small holes (<200 px)\n    for t in 0..T-1:\n      masklet[t] = remove_small_components(masklet[t], min_area=200)\n      masklet[t] = fill_holes(masklet[t], max_hole=200)\n  \n  # Step 3: Verification - satisfactory masklets added to SA-V dataset;\n  # unsatisfactory ones (model failures) sent to human annotators for Phase 3 refinement (Sec 5.1, App E.1)",
      "source": "5.1, E.1"
    },
    {
      "id": "sam2-D2-023",
      "claim": "SAM+Tracker Baseline - Click-to-Mask Reconstruction for Correction: # Baseline correction strategy for SAM+XMem++ and SAM+Cutie:\n  # SAM handles per-frame mask prediction, tracker handles temporal propagation.\n  # Correction on an intermediate frame requires reconstructing tracker output in SAM:\n\n  def apply_correction(tracker_mask_current, new_correction_clicks, frame_img):\n    # Step 1: Reconstruct tracker's output mask inside SAM via iterative click sampling from the tracker output mask, feeding sampled clicks to SAM until the reconstructed mask reaches IoU > 0.8 with the tracker output mask (following the EVA-VOS strategy, Delatolas et al., 2024):\n    reconstruction_clicks = []\n    sam_mask = None\n    while IoU(sam_mask, tracker_mask_current) < 0.8:\n      next_click = sample_click_from_error_region(sam_mask, tracker_mask_current)\n      reconstruction_clicks.append(next_click)\n      sam_mask = SAM.predict(frame_img, reconstruction_clicks)\n    \n    # Step 2: Concatenate new correction clicks with initial reconstruction clicks\n    all_clicks = reconstruction_clicks + new_correction_clicks\n    corrected_mask = SAM.predict(frame_img, all_clicks)\n    return corrected_mask\n\nNote: This approach (reconstruct SAM mask then add correction clicks) works better than alternatives such as feeding tracker output mask as a mask prompt directly, or using only correction clicks while ignoring the tracker output mask (Appendix F.1.4).\n\nVariable definitions:\n  tracker_mask_current: mask predicted by XMem++ or Cutie tracker on the current frame\n  new_correction_clicks: list of (x, y, type) correction clicks provided by user for this interaction round\n  reconstruction_clicks: clicks iteratively sampled from error region between SAM mask and tracker mask to reconstruct tracker output inside SAM\n  sam_mask: intermediate mask predicted by SAM during iterative reconstruction step\n  IoU_threshold: 0.8 threshold for reconstruction fidelity (following EVA-VOS strategy)\n  all_clicks: concatenated list of reconstruction_clicks + new_correction_clicks fed to SAM for final corrected mask",
      "source": "6.1, F.1.4"
    }
  ],
  "D3": [
    {
      "id": "sam2-D3-001",
      "claim": "Data engine Phase 1 (SAM per frame baseline). Annotators segment a target object in every video frame individually at 6 FPS using image-based interactive SAM with pixel-precise manual editing tools (brush and eraser). No temporal tracking model is involved; all frames are annotated from scratch. This phase yields high-quality per-frame spatial annotations used as ground-truth reference for quality evaluation and for annotating SA-V val/test sets.",
      "source": "Section 5.1 Data Engine Phase 1, Section E.2"
    },
    {
      "id": "sam2-D3-002",
      "claim": "Data engine Phase 2 (SAM + SAM 2 Mask). Annotators use SAM to create a spatial mask in the first frame, then use SAM 2 Mask (accepting only mask prompts) to temporally propagate the mask to subsequent frames. At any frame, annotators can edit predictions by re-annotating with SAM from scratch and re-propagating with SAM 2 Mask. SAM 2 Mask was initially trained on Phase 1 data and public datasets, then retrained twice during Phase 2 on newly collected data.",
      "source": "Section 5.1 Data Engine Phase 2"
    },
    {
      "id": "sam2-D3-003",
      "claim": "Data engine Phase 3 (fully-featured SAM 2). Utilizes the complete SAM 2 model accepting various prompt types (points, masks) with memory context across frames. Annotators provide occasional refinement clicks (not full re-annotation) to correct predicted masklets in intermediate frames. SAM 2 was retrained and updated five times during Phase 3. Annotators focus on challenging objects requiring at least 2 edited frames; videos are pre-filled with verified auto masklets, and annotators find additional un-annotated challenging objects.",
      "source": "Section 5.1 Data Engine Phase 3"
    },
    {
      "id": "sam2-D3-004",
      "claim": "Auto masklet generation. SAM 2 is prompted with regular grid points in the first frame to generate candidate masklets. These undergo post-processing (remove tiny components <200 px, fill holes <200 px) and are sent to the verification step. Masklets tagged as 'satisfactory' are added to the dataset; 'unsatisfactory' ones are sampled and sent to annotators for refinement in Phase 3.",
      "source": "Section 5.1 Auto masklet generation, Section E.1"
    },
    {
      "id": "sam2-D3-005",
      "claim": "Training data engine progression evaluation. Evaluate SAM 2 trained on progressively accumulated data from each data engine phase (keeping training iterations fixed) to measure the performance impact of additional data. Metrics reported on SA-V val set and 9 zero-shot video benchmarks using 3-click prompts on the first frame.",
      "source": "Section 5.1 Table 2, Section F.1"
    },
    {
      "id": "sam2-D3-006",
      "claim": "Promptable Video Segmentation (PVS) -- Interactive offline evaluation. Multi-pass interactive evaluation over the entire video. Start with 3 clicks on first frame, segment the object throughout the entire video. In subsequent passes, select the frame with lowest segmentation IoU w.r.t. ground-truth as the new prompting frame. Model re-segments the entire video based on all accumulated prompts, repeating up to N_frame=8 passes. Clicks are sampled at object center for initial pass, then at centroid of error region for correction passes.",
      "source": "Section 6.1, Section F.1.2, Figure 5a"
    },
    {
      "id": "sam2-D3-007",
      "claim": "Promptable Video Segmentation (PVS) -- Interactive online evaluation. Single forward pass through the video. Start with 3 clicks on the first frame, propagate forward. Pause propagation when frame has low-quality prediction (IoU < 0.75 with GT), add 3 correction clicks on that frame, resume forward propagation. New prompts only affect subsequent frames (not previous). Repeat until N_frame=8 prompted frames.",
      "source": "Section 6.1, Section F.1.2, Figure 5b"
    },
    {
      "id": "sam2-D3-008",
      "claim": "Semi-supervised VOS evaluation. Prompts (1/3/5 clicks, bounding box, or ground-truth mask) are provided only on the first video frame. The model must track the object throughout the video without further interaction. For click prompts, the initial click is at the object center and subsequent clicks are at the centroid of the error region between prediction and GT.",
      "source": "Section 6.2, Section F.1.3, Table 4"
    },
    {
      "id": "sam2-D3-009",
      "claim": "Image segmentation (SA task) zero-shot evaluation. Evaluate on 37 datasets (23 from SAM's original benchmark + 14 new video-derived datasets) using 1-click and 5-click interactive segmentation with mIoU metric. Models are compared on a single A100 GPU with batch size 10 for FPS measurement. All image encoders compiled with torch.compile.",
      "source": "Section 6.3, Section F.4, Table 5, Table 16"
    },
    {
      "id": "sam2-D3-010",
      "claim": "Semi-supervised VOS state-of-the-art comparison. Evaluate SAM 2 against prior VOS methods using ground-truth first-frame mask prompts (standard VOS protocol). Compare two SAM 2 variants (Hiera-B+ and Hiera-L) on multiple VOS benchmarks. Models run at batch size 1 on a single A100 GPU for speed benchmarking.",
      "source": "Section 7, Table 6, Section H Table 19"
    },
    {
      "id": "sam2-D3-011",
      "claim": "Data mixture ablation. Train SAM 2 on different combinations of VOS datasets (DAVIS, MOSE, YouTubeVOS), Internal-train, SA-V, and SA-1B. Fix training iterations (200k) and batch size (128); only training data changes. Pre-train on SA-1B then train separate model for each data mix setting. Report J&F with 3-click first-frame prompts and 1-click mIoU on SA-23.",
      "source": "Section A.1, Table 7"
    },
    {
      "id": "sam2-D3-012",
      "claim": "Data quantity scaling ablation. Pre-train SAM 2 on SA-1B, then train on varying sizes of SA-V data to study power-law scaling of video segmentation accuracy with training data quantity. Report J&F with 3-click first-frame prompts.",
      "source": "Section A.1 Data quantity ablation, Figure 6"
    },
    {
      "id": "sam2-D3-013",
      "claim": "Data quality (filtered subsets) ablation. Compare training on: (1) 50K randomly sampled SA-V masklets, (2) 50K most-edited masklets (hard examples), (3) full 190K SA-V masklets. All variants also include SA-1B.",
      "source": "Section A.1 Table 8"
    },
    {
      "id": "sam2-D3-014",
      "claim": "Architecture capacity abatements -- Input size and memory. Conducted at 512 resolution (default for ablations). Test input resolution (512, 768, 1024), number of frames per sequence (4, 8, 10), number of memories N (4, 6, 8), memory channel dimension (64, 256), memory attention layers ((sa=2,ca=2), (sa=3,ca=2), (sa=4,ca=4)), and image encoder size (T, S, B+, L). Report J&F for video and mIoU for image, plus relative speed.",
      "source": "Section A.2.1, Table 9"
    },
    {
      "id": "sam2-D3-015",
      "claim": "Relative positional encoding ablation. Test: (1) default (no RPB in image encoder, no 2d-RoPE in memory attention), (2) 2d-RoPE in memory attention, (3) 2d-RoPE in both memory attention and image encoder (replacing RPB). Evaluate on standard video benchmarks plus LVOSv2 for long-term VOS assessment.",
      "source": "Section A.2.2, Table 10"
    },
    {
      "id": "sam2-D3-016",
      "claim": "Memory architecture ablation -- GRU and object pointers. Test: (1) baseline (no GRU, no object pointers), (2) GRU for recurrent memory, (3) object pointer cross-attention from mask decoder output tokens. Evaluate on standard benchmarks plus LVOSv2 for long-term assessment.",
      "source": "Section A.2.3, Table 11"
    },
    {
      "id": "sam2-D3-017",
      "claim": "SA-V data transferability to other models (Cutie experiment). Train Cutie on two data mixtures: (1) standard VOS data (DAVIS, YouTubeVOS, MOSE) per its official recipe, (2) standard VOS data + SA-V using the same mixture ratio as SAM 2. Compare for mask-input VOS and interactive click/box-input settings on SA-V test, standard VOS benchmarks, and 17 zero-shot datasets.",
      "source": "Section G, Table 17"
    },
    {
      "id": "sam2-D3-018",
      "claim": "DAVIS interactive benchmark evaluation. Evaluate SAM 2 on the DAVIS interactive benchmark which provides scribble prompts during sequential interaction rounds. Follow CiVOS strategy to convert scribbles to positive/negative clicks. Official server selects the frame with worst segmentation for next interaction. Report AUC-J&F and J&F@60s.",
      "source": "Section F.2, Table 14"
    },
    {
      "id": "sam2-D3-019",
      "claim": "VIPOSeg benchmark evaluation. Evaluate SAM 2 on VIPOSeg in both zero-shot (no training on VIPOSeg) and fine-tuned (training on VIPOSeg training split) settings. Report overall G metric and decay lambda (robustness in crowded scenes, lower is better). Compare against PAOT (prior best model trained on VIPOSeg).",
      "source": "Section F.3, Table 15"
    },
    {
      "id": "sam2-D3-020",
      "claim": "Fairness evaluation on demographic groups. Collect annotations for the people category in Ego-Exo4D dataset (contains self-reported demographics). Use Phase 1 annotation setup (per-frame high quality SAM). Evaluate SAM 2 with 1-click, 3-click, and GT mask prompts on first frame. Compare J&F across gender (male/female) and age groups (18-26, 26-50, 50+).",
      "source": "Section E.1.1, Table 13"
    },
    {
      "id": "sam2-D3-021",
      "claim": "SAM 2 full training protocol (SA-1B pre-training + joint video/image training + 16-frame fine-tuning). Stage 1: pre-train on SA-1B static images (AdamW, lr=4e-4, reciprocal sqrt schedule, 90K steps, batch=256, 1024 resolution, 7 correction clicks). Stage 2: joint training on SA-V + Internal + SA-1B subset + optional OSS VOS datasets with alternating image/video batches, 8-frame sequences, interactive simulation with up to 2 prompted frames, mosaic transform (10% prob), reverse temporal order (50% prob). Stage 3: fine-tune on 16-frame sequences from most-challenging masklets (top 50% edited), 50K iters, half lr, freeze image encoder.",
      "source": "Section 4 Training, Section D.2, Table 12"
    }
  ],
  "D4": [
    {
      "id": "sam2-D4-001",
      "claim": "SAM 2 Training Pipeline: Stage 1 — Pre-train on SA-1B images with image encoder + mask decoder (Appendix D.2.1). Stage 2 — Full training on mixed video (SA-V) + image data, jointly optimizing image encoder, memory attention, mask decoder, and prompt encoder (Appendix D.2.2). Stage 3 — Fine-tune on long video sequences (>16 frames) to improve temporal consistency and long-range tracking quality (Appendix D.2.2).",
      "source": "Section 4, Appendix D.2"
    },
    {
      "id": "sam2-D4-002",
      "claim": "Data Engine Pipeline: Phase 1 — Human annotators label every frame with pixel-perfect masks using SAM 2 interactive mode (high quality, slow). Phase 2 — SAM 2 assists: model propagates masks across frames, annotators correct errors at ~7.4s per frame (medium quality, faster). Phase 3 — Fully automatic masklet generation: SAM 2 processes video without human input at <1s per frame (lower quality but massive scale, generating SA-V dataset).",
      "source": "Section 3, Appendix E"
    },
    {
      "id": "sam2-D4-003",
      "claim": "PVS Interactive Evaluation Protocol: (1) Annotator clicks on one frame to select object. (2) SAM 2 propagates mask bidirectionally across all frames. (3) Annotator reviews and clicks again on any frame where correction is needed. (4) Model re-propagates with updated prompt. (5) Repeat up to N_frame=8 frames with N_click=3 clicks per frame. (6) Final mask accepted when annotator approves or click budget exhausted.",
      "source": "Section 6.1, Appendix F.1.2"
    },
    {
      "id": "sam2-D4-004",
      "claim": "SA-V Dataset Construction Pipeline: (1) Sample ~50K videos from diverse sources. (2) Phase 1 human annotation produces ~15K high-quality masklets. (3) Phase 2 model-assisted annotation scales to ~150K masklets. (4) Phase 3 fully automatic generation produces ~35M masklets for pre-training data. (5) Quality filtering removes low-confidence masklets via IoU and temporal consistency checks.",
      "source": "Section 3, Appendix E"
    },
    {
      "id": "sam2-D4-005",
      "claim": "Evaluation Protocol: (1) Zero-shot video object segmentation on DAVIS 2017, YouTube-VOS, MOSE, SA-V test. (2) Interactive evaluation via PVS benchmark with varying click budgets (1/3/5/8 frames). (3) Ablation studies on memory bank size (N), number of frames per training clip, image encoder variants (Hiera T/S/B+/L), and resolution. (4) Metrics: J&F (region + boundary), IoU, human-annotated quality ratings.",
      "source": "Section 6, Appendix F"
    }
  ]
}