Add files using upload-large-folder tool

之前的代码版本/HuatuoGPT-Vision/MedSAM3/lora_layers.py

@@ -0,0 +1,541 @@
+"""
+LoRA (Low-Rank Adaptation) implementation for SAM3 model fine-tuning.
+Supports selective application to different transformer components.
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from typing import Dict, List, Optional, Set, Tuple
+import math
+
+
+class MultiheadAttentionLoRA(nn.Module):
+    """
+    Custom MultiheadAttention that doesn't use F.multi_head_attention_forward,
+    allowing LoRA to be properly applied to Q, K, V, and output projections.
+
+    This replaces nn.MultiheadAttention to enable LoRA on all projection layers.
+    """
+
+    def __init__(
+        self,
+        embed_dim: int,
+        num_heads: int,
+        dropout: float = 0.0,
+        bias: bool = True,
+        batch_first: bool = False,
+        # Copy weights from existing MHA
+        in_proj_weight: Optional[torch.Tensor] = None,
+        in_proj_bias: Optional[torch.Tensor] = None,
+        out_proj_weight: Optional[torch.Tensor] = None,
+        out_proj_bias: Optional[torch.Tensor] = None,
+    ):
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.num_heads = num_heads
+        self.head_dim = embed_dim // num_heads
+        self.batch_first = batch_first
+        self.dropout = dropout
+
+        assert self.head_dim * num_heads == embed_dim, "embed_dim must be divisible by num_heads"
+
+        # Separate Q, K, V projections (instead of fused in_proj)
+        self.q_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+        self.k_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+        self.v_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+        self.out_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+
+        # Initialize from existing MHA weights if provided
+        if in_proj_weight is not None:
+            # Split in_proj_weight into q, k, v
+            self.q_proj.weight.data = in_proj_weight[:embed_dim, :].clone()
+            self.k_proj.weight.data = in_proj_weight[embed_dim:2*embed_dim, :].clone()
+            self.v_proj.weight.data = in_proj_weight[2*embed_dim:, :].clone()
+
+        if in_proj_bias is not None:
+            self.q_proj.bias.data = in_proj_bias[:embed_dim].clone()
+            self.k_proj.bias.data = in_proj_bias[embed_dim:2*embed_dim].clone()
+            self.v_proj.bias.data = in_proj_bias[2*embed_dim:].clone()
+
+        if out_proj_weight is not None:
+            self.out_proj.weight.data = out_proj_weight.clone()
+
+        if out_proj_bias is not None:
+            self.out_proj.bias.data = out_proj_bias.clone()
+
+        self.dropout_layer = nn.Dropout(dropout) if dropout > 0 else nn.Identity()
+
+    def forward(
+        self,
+        query: torch.Tensor,
+        key: torch.Tensor,
+        value: torch.Tensor,
+        key_padding_mask: Optional[torch.Tensor] = None,
+        need_weights: bool = False,
+        attn_mask: Optional[torch.Tensor] = None,
+        average_attn_weights: bool = True,
+        is_causal: bool = False,
+    ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]:
+        """
+        Forward pass using separate Q, K, V projections so LoRA works.
+        """
+        # Handle batch_first
+        if self.batch_first:
+            # Input: (batch, seq, embed_dim)
+            batch_size, tgt_len, _ = query.shape
+            src_len = key.shape[1]
+        else:
+            # Input: (seq, batch, embed_dim)
+            tgt_len, batch_size, _ = query.shape
+            src_len = key.shape[0]
+            # Convert to batch_first for easier processing
+            query = query.transpose(0, 1)
+            key = key.transpose(0, 1)
+            value = value.transpose(0, 1)
+
+        # Project Q, K, V - LoRA is applied here through the Linear layers
+        q = self.q_proj(query)
+        k = self.k_proj(key)
+        v = self.v_proj(value)
+
+        # Reshape for multi-head attention
+        # (batch, seq, embed_dim) -> (batch, num_heads, seq, head_dim)
+        q = q.view(batch_size, tgt_len, self.num_heads, self.head_dim).transpose(1, 2)
+        k = k.view(batch_size, src_len, self.num_heads, self.head_dim).transpose(1, 2)
+        v = v.view(batch_size, src_len, self.num_heads, self.head_dim).transpose(1, 2)
+
+        # Scaled dot-product attention
+        scale = 1.0 / math.sqrt(self.head_dim)
+        attn_weights = torch.matmul(q, k.transpose(-2, -1)) * scale
+
+        # Apply attention mask - handle various input formats
+        if attn_mask is not None:
+            # attn_weights shape: (batch, num_heads, tgt_len, src_len)
+            if attn_mask.dim() == 2:
+                # (tgt_len, src_len) -> (1, 1, tgt_len, src_len)
+                attn_mask = attn_mask.unsqueeze(0).unsqueeze(0)
+            elif attn_mask.dim() == 3:
+                # Could be (batch, tgt_len, src_len) or (batch*num_heads, tgt_len, src_len)
+                if attn_mask.shape[0] == batch_size:
+                    # (batch, tgt_len, src_len) -> (batch, 1, tgt_len, src_len)
+                    attn_mask = attn_mask.unsqueeze(1)
+                elif attn_mask.shape[0] == batch_size * self.num_heads:
+                    # (batch*num_heads, tgt_len, src_len) -> (batch, num_heads, tgt_len, src_len)
+                    attn_mask = attn_mask.view(batch_size, self.num_heads, tgt_len, src_len)
+                else:
+                    # Unknown format, try to broadcast
+                    attn_mask = attn_mask.unsqueeze(1)
+            elif attn_mask.dim() == 4:
+                # Already (batch, num_heads, tgt_len, src_len) or similar
+                pass
+
+            # Expand to match attn_weights if needed
+            if attn_mask.shape != attn_weights.shape:
+                attn_mask = attn_mask.expand_as(attn_weights)
+
+            if attn_mask.dtype == torch.bool:
+                attn_weights = attn_weights.masked_fill(attn_mask, float('-inf'))
+            else:
+                attn_weights = attn_weights + attn_mask
+
+        # Apply key padding mask
+        if key_padding_mask is not None:
+            # key_padding_mask: (batch, src_len), True = ignore
+            attn_weights = attn_weights.masked_fill(
+                key_padding_mask.unsqueeze(1).unsqueeze(2),
+                float('-inf')
+            )
+
+        # Softmax and dropout
+        attn_weights = F.softmax(attn_weights, dim=-1)
+        attn_weights = self.dropout_layer(attn_weights)
+
+        # Apply attention to values
+        attn_output = torch.matmul(attn_weights, v)
+
+        # Reshape back: (batch, num_heads, seq, head_dim) -> (batch, seq, embed_dim)
+        attn_output = attn_output.transpose(1, 2).contiguous().view(batch_size, tgt_len, self.embed_dim)
+
+        # Output projection - LoRA is applied here
+        attn_output = self.out_proj(attn_output)
+
+        # Convert back if not batch_first
+        if not self.batch_first:
+            attn_output = attn_output.transpose(0, 1)
+
+        if need_weights:
+            if average_attn_weights:
+                attn_weights = attn_weights.mean(dim=1)
+            return attn_output, attn_weights
+        else:
+            return attn_output, None
+
+
+class LoRALayer(nn.Module):
+    """
+    LoRA layer that replaces a linear layer with low-rank adaptation.
+
+    Args:
+        in_features: Input dimension
+        out_features: Output dimension
+        rank: Rank of the low-rank matrices (r in the paper)
+        alpha: Scaling factor (typically set to rank)
+        dropout: Dropout probability for LoRA weights
+    """
+
+    def __init__(
+        self,
+        in_features: int,
+        out_features: int,
+        rank: int = 8,
+        alpha: int = 16,
+        dropout: float = 0.0,
+    ):
+        super().__init__()
+        self.rank = rank
+        self.alpha = alpha
+        self.scaling = alpha / rank
+
+        # LoRA low-rank matrices
+        self.lora_A = nn.Parameter(torch.zeros(in_features, rank))
+        self.lora_B = nn.Parameter(torch.zeros(rank, out_features))
+
+        # Dropout
+        self.dropout = nn.Dropout(p=dropout) if dropout > 0 else nn.Identity()
+
+        # Initialize weights
+        nn.init.kaiming_uniform_(self.lora_A, a=math.sqrt(5))
+        nn.init.zeros_(self.lora_B)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Apply LoRA transformation: x @ (A @ B) * scaling
+        """
+        # x shape: (..., in_features)
+        lora_out = self.dropout(x) @ self.lora_A @ self.lora_B
+        return lora_out * self.scaling
+
+
+class LoRALinear(nn.Module):
+    """
+    Linear layer with LoRA adaptation.
+    Combines the original frozen linear layer with a LoRA layer.
+
+    Exposes weight/bias properties to maintain compatibility with modules
+    that access these attributes directly (e.g., nn.MultiheadAttention).
+    """
+
+    def __init__(
+        self,
+        original_layer: nn.Linear,
+        rank: int = 8,
+        alpha: int = 16,
+        dropout: float = 0.0,
+    ):
+        super().__init__()
+
+        # Freeze the original layer
+        self.original_layer = original_layer
+        for param in self.original_layer.parameters():
+            param.requires_grad = False
+
+        # Store original layer attributes for compatibility
+        self.in_features = original_layer.in_features
+        self.out_features = original_layer.out_features
+
+        # Create LoRA layer
+        self.lora = LoRALayer(
+            in_features=original_layer.in_features,
+            out_features=original_layer.out_features,
+            rank=rank,
+            alpha=alpha,
+            dropout=dropout,
+        )
+
+    @property
+    def weight(self) -> torch.Tensor:
+        """Proxy to original layer's weight for compatibility with nn.MultiheadAttention."""
+        return self.original_layer.weight
+
+    @property
+    def bias(self) -> Optional[torch.Tensor]:
+        """Proxy to original layer's bias for compatibility with nn.MultiheadAttention."""
+        return self.original_layer.bias
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        """
+        Forward pass: original output + LoRA output
+        """
+        return self.original_layer(x) + self.lora(x)
+
+
+class LoRAConfig:
+    """
+    Configuration for LoRA application to SAM3 model.
+
+    Args:
+        rank: Rank of LoRA matrices
+        alpha: Scaling factor
+        dropout: Dropout probability
+        target_modules: Which modules to apply LoRA to
+        apply_to_vision_encoder: Whether to apply LoRA to vision encoder
+        apply_to_text_encoder: Whether to apply LoRA to text encoder
+        apply_to_geometry_encoder: Whether to apply LoRA to geometry encoder
+        apply_to_detr_encoder: Whether to apply LoRA to DETR encoder
+        apply_to_detr_decoder: Whether to apply LoRA to DETR decoder
+        apply_to_mask_decoder: Whether to apply LoRA to mask decoder
+    """
+
+    def __init__(
+        self,
+        rank: int = 8,
+        alpha: int = 16,
+        dropout: float = 0.0,
+        target_modules: Optional[List[str]] = None,
+        # Component-level control
+        apply_to_vision_encoder: bool = True,
+        apply_to_text_encoder: bool = True,
+        apply_to_geometry_encoder: bool = False,
+        apply_to_detr_encoder: bool = True,
+        apply_to_detr_decoder: bool = True,
+        apply_to_mask_decoder: bool = False,
+    ):
+        self.rank = rank
+        self.alpha = alpha
+        self.dropout = dropout
+
+        # Default target modules: Q, K, V projections for different architectures
+        # - q_proj, k_proj, v_proj: Standard separate projections (LLaMA-style)
+        # - qkv: Fused Q/K/V projection (ViT-style, used in SAM3 vision backbone)
+        # - proj: Output projection in vision backbone (different from out_proj)
+        # - out_proj: Output projection in MultiheadAttention
+        # - c_fc, c_proj: MLP layers in CLIP-style language backbone
+        # - linear1, linear2: FFN layers in transformer encoder/decoder
+        if target_modules is None:
+            target_modules = [
+                # Standard attention projections
+                "q_proj", "k_proj", "v_proj", "out_proj",
+                # Vision backbone (ViT-style)
+                "qkv",  # Fused Q/K/V projection
+                "proj",  # Output projection (note: will also match out_proj, c_proj)
+                "fc1", "fc2",  # MLP layers in vision backbone
+                # Language backbone (CLIP-style) MLP
+                "c_fc", "c_proj",
+                # Transformer FFN layers
+                "linear1", "linear2",
+            ]
+        self.target_modules = set(target_modules)
+
+        # Component flags
+        self.apply_to_vision_encoder = apply_to_vision_encoder
+        self.apply_to_text_encoder = apply_to_text_encoder
+        self.apply_to_geometry_encoder = apply_to_geometry_encoder
+        self.apply_to_detr_encoder = apply_to_detr_encoder
+        self.apply_to_detr_decoder = apply_to_detr_decoder
+        self.apply_to_mask_decoder = apply_to_mask_decoder
+
+    def to_dict(self) -> Dict:
+        """Convert config to dictionary."""
+        return {
+            "rank": self.rank,
+            "alpha": self.alpha,
+            "dropout": self.dropout,
+            "target_modules": list(self.target_modules),
+            "apply_to_vision_encoder": self.apply_to_vision_encoder,
+            "apply_to_text_encoder": self.apply_to_text_encoder,
+            "apply_to_geometry_encoder": self.apply_to_geometry_encoder,
+            "apply_to_detr_encoder": self.apply_to_detr_encoder,
+            "apply_to_detr_decoder": self.apply_to_detr_decoder,
+            "apply_to_mask_decoder": self.apply_to_mask_decoder,
+        }
+
+
+def apply_lora_to_model(model: nn.Module, config: LoRAConfig) -> nn.Module:
+    """
+    Apply LoRA to specified modules in the SAM3 model.
+
+    This function:
+    1. Replaces nn.MultiheadAttention with MultiheadAttentionLoRA (enables LoRA on Q/K/V/out_proj)
+    2. Applies LoRA to all matching Linear layers
+
+    Args:
+        model: SAM3 model to apply LoRA to
+        config: LoRA configuration
+
+    Returns:
+        Model with LoRA applied
+    """
+
+    # CRITICAL: Freeze all base model parameters first
+    for param in model.parameters():
+        param.requires_grad = False
+
+    def should_apply_lora_to_component(module_name: str) -> bool:
+        """Check component-level flags to determine if we should apply LoRA."""
+        if ("vision_encoder" in module_name or "vision_backbone" in module_name) and not config.apply_to_vision_encoder:
+            return False
+        if ("text_encoder" in module_name or "language_backbone" in module_name) and not config.apply_to_text_encoder:
+            return False
+        if "geometry_encoder" in module_name and not config.apply_to_geometry_encoder:
+            return False
+        if ("detr_encoder" in module_name or "transformer.encoder" in module_name) and not config.apply_to_detr_encoder:
+            return False
+        if ("detr_decoder" in module_name or "transformer.decoder" in module_name) and not config.apply_to_detr_decoder:
+            return False
+        if "mask_decoder" in module_name and not config.apply_to_mask_decoder:
+            return False
+        return True
+
+    def should_apply_lora(module_name: str) -> bool:
+        """Determine if LoRA should be applied to this module."""
+        if not should_apply_lora_to_component(module_name):
+            return False
+
+        # Check if module name matches target modules
+        module_basename = module_name.split('.')[-1]
+
+        # Direct basename match (e.g., "qkv", "proj", "linear1", etc.)
+        if module_basename in config.target_modules:
+            return True
+
+        # Also check for substring match for flexibility
+        for target in config.target_modules:
+            if target in module_basename:
+                return True
+
+        return False
+
+    # Track replacements
+    mha_replaced = []
+    lora_modules_applied = []
+
+    # STEP 1: Replace nn.MultiheadAttention with MultiheadAttentionLoRA
+    # This enables LoRA to be applied to Q, K, V, and out_proj inside MHA
+    mha_to_replace = []
+    for name, module in model.named_modules():
+        if isinstance(module, nn.MultiheadAttention):
+            if should_apply_lora_to_component(name):
+                mha_to_replace.append((name, module))
+
+    for name, mha in mha_to_replace:
+        # Get parent module and attribute name
+        *parent_path, attr_name = name.split('.')
+        parent = model
+        for p in parent_path:
+            parent = getattr(parent, p)
+
+        # Create replacement with separate Q, K, V projections
+        new_mha = MultiheadAttentionLoRA(
+            embed_dim=mha.embed_dim,
+            num_heads=mha.num_heads,
+            dropout=mha.dropout,
+            bias=mha.in_proj_bias is not None,
+            batch_first=mha.batch_first,
+            in_proj_weight=mha.in_proj_weight,
+            in_proj_bias=mha.in_proj_bias,
+            out_proj_weight=mha.out_proj.weight,
+            out_proj_bias=mha.out_proj.bias if mha.out_proj.bias is not None else None,
+        )
+
+        # Freeze the new MHA parameters
+        for param in new_mha.parameters():
+            param.requires_grad = False
+
+        setattr(parent, attr_name, new_mha)
+        mha_replaced.append(name)
+
+    print(f"Replaced {len(mha_replaced)} nn.MultiheadAttention modules with MultiheadAttentionLoRA")
+
+    # STEP 2: Apply LoRA to all matching Linear layers
+    # Now includes q_proj, k_proj, v_proj, out_proj from the replaced MHA modules
+    for name, module in model.named_modules():
+        if isinstance(module, nn.Linear) and should_apply_lora(name):
+            # Get parent module and attribute name
+            *parent_path, attr_name = name.split('.')
+            parent = model
+            for p in parent_path:
+                parent = getattr(parent, p)
+
+            # Replace with LoRA linear
+            lora_linear = LoRALinear(
+                module,
+                rank=config.rank,
+                alpha=config.alpha,
+                dropout=config.dropout,
+            )
+            setattr(parent, attr_name, lora_linear)
+            lora_modules_applied.append(name)
+
+    print(f"Applied LoRA to {len(lora_modules_applied)} modules:")
+    for module_name in lora_modules_applied[:15]:  # Show first 15
+        print(f"  - {module_name}")
+    if len(lora_modules_applied) > 15:
+        print(f"  ... and {len(lora_modules_applied) - 15} more")
+
+    return model
+
+
+def get_lora_parameters(model: nn.Module) -> List[nn.Parameter]:
+    """
+    Get all LoRA parameters from the model.
+
+    Args:
+        model: Model with LoRA layers
+
+    Returns:
+        List of LoRA parameters
+    """
+    lora_params = []
+    for module in model.modules():
+        if isinstance(module, LoRALayer):
+            lora_params.extend([module.lora_A, module.lora_B])
+    return lora_params
+
+
+def count_parameters(model: nn.Module) -> Dict[str, int]:
+    """
+    Count total and trainable parameters in the model.
+
+    Returns:
+        Dictionary with parameter counts
+    """
+    total_params = sum(p.numel() for p in model.parameters())
+    trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+
+    return {
+        "total_parameters": total_params,
+        "trainable_parameters": trainable_params,
+        "trainable_percentage": 100 * trainable_params / total_params if total_params > 0 else 0,
+    }
+
+
+def save_lora_weights(model: nn.Module, save_path: str):
+    """
+    Save only LoRA weights (not the full model).
+
+    Args:
+        model: Model with LoRA layers
+        save_path: Path to save LoRA weights
+    """
+    lora_state_dict = {}
+    for name, module in model.named_modules():
+        if isinstance(module, LoRALayer):
+            lora_state_dict[f"{name}.lora_A"] = module.lora_A
+            lora_state_dict[f"{name}.lora_B"] = module.lora_B
+
+    torch.save(lora_state_dict, save_path)
+    print(f"Saved LoRA weights to {save_path}")
+
+
+def load_lora_weights(model: nn.Module, load_path: str):
+    """
+    Load LoRA weights into a model.
+
+    Args:
+        model: Model with LoRA layers
+        load_path: Path to LoRA weights
+    """
+    lora_state_dict = torch.load(load_path)
+    model.load_state_dict(lora_state_dict, strict=False)
+    print(f"Loaded LoRA weights from {load_path}")

之前的代码版本/HuatuoGPT-Vision/MedSAM3/sam3/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+from .model_builder import build_sam3_image_model
+
+__version__ = "0.1.0"
+
+__all__ = ["build_sam3_image_model"]

之前的代码版本/HuatuoGPT-Vision/MedSAM3/sam3/model_builder.py

@@ -0,0 +1,793 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+import os
+from typing import Optional
+
+import torch
+import torch.nn as nn
+from huggingface_hub import hf_hub_download
+from iopath.common.file_io import g_pathmgr
+from sam3.model.decoder import (
+    TransformerDecoder,
+    TransformerDecoderLayer,
+    TransformerDecoderLayerv2,
+    TransformerEncoderCrossAttention,
+)
+from sam3.model.encoder import TransformerEncoderFusion, TransformerEncoderLayer
+from sam3.model.geometry_encoders import SequenceGeometryEncoder
+from sam3.model.maskformer_segmentation import PixelDecoder, UniversalSegmentationHead
+from sam3.model.memory import (
+    CXBlock,
+    SimpleFuser,
+    SimpleMaskDownSampler,
+    SimpleMaskEncoder,
+)
+from sam3.model.model_misc import (
+    DotProductScoring,
+    MLP,
+    MultiheadAttentionWrapper as MultiheadAttention,
+    TransformerWrapper,
+)
+from sam3.model.necks import Sam3DualViTDetNeck
+from sam3.model.position_encoding import PositionEmbeddingSine
+from sam3.model.sam1_task_predictor import SAM3InteractiveImagePredictor
+from sam3.model.sam3_image import Sam3Image, Sam3ImageOnVideoMultiGPU
+from sam3.model.sam3_tracking_predictor import Sam3TrackerPredictor
+from sam3.model.sam3_video_inference import Sam3VideoInferenceWithInstanceInteractivity
+from sam3.model.sam3_video_predictor import Sam3VideoPredictorMultiGPU
+from sam3.model.text_encoder_ve import VETextEncoder
+from sam3.model.tokenizer_ve import SimpleTokenizer
+from sam3.model.vitdet import ViT
+from sam3.model.vl_combiner import SAM3VLBackbone
+from sam3.sam.transformer import RoPEAttention
+
+
+# Setup TensorFloat-32 for Ampere GPUs if available
+def _setup_tf32() -> None:
+    """Enable TensorFloat-32 for Ampere GPUs if available."""
+    if torch.cuda.is_available():
+        device_props = torch.cuda.get_device_properties(0)
+        if device_props.major >= 8:
+            torch.backends.cuda.matmul.allow_tf32 = True
+            torch.backends.cudnn.allow_tf32 = True
+
+
+_setup_tf32()
+
+
+def _create_position_encoding(precompute_resolution=None):
+    """Create position encoding for visual backbone."""
+    return PositionEmbeddingSine(
+        num_pos_feats=256,
+        normalize=True,
+        scale=None,
+        temperature=10000,
+        precompute_resolution=precompute_resolution,
+    )
+
+
+def _create_vit_backbone(compile_mode=None):
+    """Create ViT backbone for visual feature extraction."""
+    return ViT(
+        img_size=1008,
+        pretrain_img_size=336,
+        patch_size=14,
+        embed_dim=1024,
+        depth=32,
+        num_heads=16,
+        mlp_ratio=4.625,
+        norm_layer="LayerNorm",
+        drop_path_rate=0.1,
+        qkv_bias=True,
+        use_abs_pos=True,
+        tile_abs_pos=True,
+        global_att_blocks=(7, 15, 23, 31),
+        rel_pos_blocks=(),
+        use_rope=True,
+        use_interp_rope=True,
+        window_size=24,
+        pretrain_use_cls_token=True,
+        retain_cls_token=False,
+        ln_pre=True,
+        ln_post=False,
+        return_interm_layers=False,
+        bias_patch_embed=False,
+        compile_mode=compile_mode,
+    )
+
+
+def _create_vit_neck(position_encoding, vit_backbone, enable_inst_interactivity=False):
+    """Create ViT neck for feature pyramid."""
+    return Sam3DualViTDetNeck(
+        position_encoding=position_encoding,
+        d_model=256,
+        scale_factors=[4.0, 2.0, 1.0, 0.5],
+        trunk=vit_backbone,
+        add_sam2_neck=enable_inst_interactivity,
+    )
+
+
+def _create_vl_backbone(vit_neck, text_encoder):
+    """Create visual-language backbone."""
+    return SAM3VLBackbone(visual=vit_neck, text=text_encoder, scalp=1)
+
+
+def _create_transformer_encoder() -> TransformerEncoderFusion:
+    """Create transformer encoder with its layer."""
+    encoder_layer = TransformerEncoderLayer(
+        activation="relu",
+        d_model=256,
+        dim_feedforward=2048,
+        dropout=0.1,
+        pos_enc_at_attn=True,
+        pos_enc_at_cross_attn_keys=False,
+        pos_enc_at_cross_attn_queries=False,
+        pre_norm=True,
+        self_attention=MultiheadAttention(
+            num_heads=8,
+            dropout=0.1,
+            embed_dim=256,
+            batch_first=True,
+        ),
+        cross_attention=MultiheadAttention(
+            num_heads=8,
+            dropout=0.1,
+            embed_dim=256,
+            batch_first=True,
+        ),
+    )
+
+    encoder = TransformerEncoderFusion(
+        layer=encoder_layer,
+        num_layers=6,
+        d_model=256,
+        num_feature_levels=1,
+        frozen=False,
+        use_act_checkpoint=True,
+        add_pooled_text_to_img_feat=False,
+        pool_text_with_mask=True,
+    )
+    return encoder
+
+
+def _create_transformer_decoder() -> TransformerDecoder:
+    """Create transformer decoder with its layer."""
+    decoder_layer = TransformerDecoderLayer(
+        activation="relu",
+        d_model=256,
+        dim_feedforward=2048,
+        dropout=0.1,
+        cross_attention=MultiheadAttention(
+            num_heads=8,
+            dropout=0.1,
+            embed_dim=256,
+        ),
+        n_heads=8,
+        use_text_cross_attention=True,
+    )
+
+    decoder = TransformerDecoder(
+        layer=decoder_layer,
+        num_layers=6,
+        num_queries=200,
+        return_intermediate=True,
+        box_refine=True,
+        num_o2m_queries=0,
+        dac=True,
+        boxRPB="log",
+        d_model=256,
+        frozen=False,
+        interaction_layer=None,
+        dac_use_selfatt_ln=True,
+        resolution=1008,
+        stride=14,
+        use_act_checkpoint=True,
+        presence_token=True,
+    )
+    return decoder
+
+
+def _create_dot_product_scoring():
+    """Create dot product scoring module."""
+    prompt_mlp = MLP(
+        input_dim=256,
+        hidden_dim=2048,
+        output_dim=256,
+        num_layers=2,
+        dropout=0.1,
+        residual=True,
+        out_norm=nn.LayerNorm(256),
+    )
+    return DotProductScoring(d_model=256, d_proj=256, prompt_mlp=prompt_mlp)
+
+
+def _create_segmentation_head(compile_mode=None):
+    """Create segmentation head with pixel decoder."""
+    pixel_decoder = PixelDecoder(
+        num_upsampling_stages=3,
+        interpolation_mode="nearest",
+        hidden_dim=256,
+        compile_mode=compile_mode,
+    )
+
+    cross_attend_prompt = MultiheadAttention(
+        num_heads=8,
+        dropout=0,
+        embed_dim=256,
+    )
+
+    segmentation_head = UniversalSegmentationHead(
+        hidden_dim=256,
+        upsampling_stages=3,
+        aux_masks=False,
+        presence_head=False,
+        dot_product_scorer=None,
+        act_ckpt=True,
+        cross_attend_prompt=cross_attend_prompt,
+        pixel_decoder=pixel_decoder,
+    )
+    return segmentation_head
+
+
+def _create_geometry_encoder():
+    """Create geometry encoder with all its components."""
+    # Create position encoding for geometry encoder
+    geo_pos_enc = _create_position_encoding()
+    # Create CX block for fuser
+    cx_block = CXBlock(
+        dim=256,
+        kernel_size=7,
+        padding=3,
+        layer_scale_init_value=1.0e-06,
+        use_dwconv=True,
+    )
+    # Create geometry encoder layer
+    geo_layer = TransformerEncoderLayer(
+        activation="relu",
+        d_model=256,
+        dim_feedforward=2048,
+        dropout=0.1,
+        pos_enc_at_attn=False,
+        pre_norm=True,
+        self_attention=MultiheadAttention(
+            num_heads=8,
+            dropout=0.1,
+            embed_dim=256,
+            batch_first=False,
+        ),
+        pos_enc_at_cross_attn_queries=False,
+        pos_enc_at_cross_attn_keys=True,
+        cross_attention=MultiheadAttention(
+            num_heads=8,
+            dropout=0.1,
+            embed_dim=256,
+            batch_first=False,
+        ),
+    )
+
+    # Create geometry encoder
+    input_geometry_encoder = SequenceGeometryEncoder(
+        pos_enc=geo_pos_enc,
+        encode_boxes_as_points=False,
+        points_direct_project=True,
+        points_pool=True,
+        points_pos_enc=True,
+        boxes_direct_project=True,
+        boxes_pool=True,
+        boxes_pos_enc=True,
+        d_model=256,
+        num_layers=3,
+        layer=geo_layer,
+        use_act_ckpt=True,
+        add_cls=True,
+        add_post_encode_proj=True,
+    )
+    return input_geometry_encoder
+
+
+def _create_sam3_model(
+    backbone,
+    transformer,
+    input_geometry_encoder,
+    segmentation_head,
+    dot_prod_scoring,
+    inst_interactive_predictor,
+    eval_mode,
+):
+    """Create the SAM3 image model."""
+    common_params = {
+        "backbone": backbone,
+        "transformer": transformer,
+        "input_geometry_encoder": input_geometry_encoder,
+        "segmentation_head": segmentation_head,
+        "num_feature_levels": 1,
+        "o2m_mask_predict": True,
+        "dot_prod_scoring": dot_prod_scoring,
+        "use_instance_query": False,
+        "multimask_output": True,
+        "inst_interactive_predictor": inst_interactive_predictor,
+    }
+
+    matcher = None
+    if not eval_mode:
+        from sam3.train.matcher import BinaryHungarianMatcherV2
+
+        matcher = BinaryHungarianMatcherV2(
+            focal=True,
+            cost_class=2.0,
+            cost_bbox=5.0,
+            cost_giou=2.0,
+            alpha=0.25,
+            gamma=2,
+            stable=False,
+        )
+    common_params["matcher"] = matcher
+    model = Sam3Image(**common_params)
+
+    return model
+
+
+def _create_tracker_maskmem_backbone():
+    """Create the SAM3 Tracker memory encoder."""
+    # Position encoding for mask memory backbone
+    position_encoding = PositionEmbeddingSine(
+        num_pos_feats=64,
+        normalize=True,
+        scale=None,
+        temperature=10000,
+        precompute_resolution=1008,
+    )
+
+    # Mask processing components
+    mask_downsampler = SimpleMaskDownSampler(
+        kernel_size=3, stride=2, padding=1, interpol_size=[1152, 1152]
+    )
+
+    cx_block_layer = CXBlock(
+        dim=256,
+        kernel_size=7,
+        padding=3,
+        layer_scale_init_value=1.0e-06,
+        use_dwconv=True,
+    )
+
+    fuser = SimpleFuser(layer=cx_block_layer, num_layers=2)
+
+    maskmem_backbone = SimpleMaskEncoder(
+        out_dim=64,
+        position_encoding=position_encoding,
+        mask_downsampler=mask_downsampler,
+        fuser=fuser,
+    )
+
+    return maskmem_backbone
+
+
+def _create_tracker_transformer():
+    """Create the SAM3 Tracker transformer components."""
+    # Self attention
+    self_attention = RoPEAttention(
+        embedding_dim=256,
+        num_heads=1,
+        downsample_rate=1,
+        dropout=0.1,
+        rope_theta=10000.0,
+        feat_sizes=[72, 72],
+        use_fa3=False,
+        use_rope_real=False,
+    )
+
+    # Cross attention
+    cross_attention = RoPEAttention(
+        embedding_dim=256,
+        num_heads=1,
+        downsample_rate=1,
+        dropout=0.1,
+        kv_in_dim=64,
+        rope_theta=10000.0,
+        feat_sizes=[72, 72],
+        rope_k_repeat=True,
+        use_fa3=False,
+        use_rope_real=False,
+    )
+
+    # Encoder layer
+    encoder_layer = TransformerDecoderLayerv2(
+        cross_attention_first=False,
+        activation="relu",
+        dim_feedforward=2048,
+        dropout=0.1,
+        pos_enc_at_attn=False,
+        pre_norm=True,
+        self_attention=self_attention,
+        d_model=256,
+        pos_enc_at_cross_attn_keys=True,
+        pos_enc_at_cross_attn_queries=False,
+        cross_attention=cross_attention,
+    )
+
+    # Encoder
+    encoder = TransformerEncoderCrossAttention(
+        remove_cross_attention_layers=[],
+        batch_first=True,
+        d_model=256,
+        frozen=False,
+        pos_enc_at_input=True,
+        layer=encoder_layer,
+        num_layers=4,
+        use_act_checkpoint=False,
+    )
+
+    # Transformer wrapper
+    transformer = TransformerWrapper(
+        encoder=encoder,
+        decoder=None,
+        d_model=256,
+    )
+
+    return transformer
+
+
+def build_tracker(
+    apply_temporal_disambiguation: bool, with_backbone: bool = False, compile_mode=None
+) -> Sam3TrackerPredictor:
+    """
+    Build the SAM3 Tracker module for video tracking.
+
+    Returns:
+        Sam3TrackerPredictor: Wrapped SAM3 Tracker module
+    """
+
+    # Create model components
+    maskmem_backbone = _create_tracker_maskmem_backbone()
+    transformer = _create_tracker_transformer()
+    backbone = None
+    if with_backbone:
+        vision_backbone = _create_vision_backbone(compile_mode=compile_mode)
+        backbone = SAM3VLBackbone(scalp=1, visual=vision_backbone, text=None)
+    # Create the Tracker module
+    model = Sam3TrackerPredictor(
+        image_size=1008,
+        num_maskmem=7,
+        backbone=backbone,
+        backbone_stride=14,
+        transformer=transformer,
+        maskmem_backbone=maskmem_backbone,
+        # SAM parameters
+        multimask_output_in_sam=True,
+        # Evaluation
+        forward_backbone_per_frame_for_eval=True,
+        trim_past_non_cond_mem_for_eval=False,
+        # Multimask
+        multimask_output_for_tracking=True,
+        multimask_min_pt_num=0,
+        multimask_max_pt_num=1,
+        # Additional settings
+        always_start_from_first_ann_frame=False,
+        # Mask overlap
+        non_overlap_masks_for_mem_enc=False,
+        non_overlap_masks_for_output=False,
+        max_cond_frames_in_attn=4,
+        offload_output_to_cpu_for_eval=False,
+        # SAM decoder settings
+        sam_mask_decoder_extra_args={
+            "dynamic_multimask_via_stability": True,
+            "dynamic_multimask_stability_delta": 0.05,
+            "dynamic_multimask_stability_thresh": 0.98,
+        },
+        clear_non_cond_mem_around_input=True,
+        fill_hole_area=0,
+        use_memory_selection=apply_temporal_disambiguation,
+    )
+
+    return model
+
+
+def _create_text_encoder(bpe_path: str) -> VETextEncoder:
+    """Create SAM3 text encoder."""
+    tokenizer = SimpleTokenizer(bpe_path=bpe_path)
+    return VETextEncoder(
+        tokenizer=tokenizer,
+        d_model=256,
+        width=1024,
+        heads=16,
+        layers=24,
+    )
+
+
+def _create_vision_backbone(
+    compile_mode=None, enable_inst_interactivity=True
+) -> Sam3DualViTDetNeck:
+    """Create SAM3 visual backbone with ViT and neck."""
+    # Position encoding
+    position_encoding = _create_position_encoding(precompute_resolution=1008)
+    # ViT backbone
+    vit_backbone: ViT = _create_vit_backbone(compile_mode=compile_mode)
+    vit_neck: Sam3DualViTDetNeck = _create_vit_neck(
+        position_encoding,
+        vit_backbone,
+        enable_inst_interactivity=enable_inst_interactivity,
+    )
+    # Visual neck
+    return vit_neck
+
+
+def _create_sam3_transformer(has_presence_token: bool = True) -> TransformerWrapper:
+    """Create SAM3 transformer encoder and decoder."""
+    encoder: TransformerEncoderFusion = _create_transformer_encoder()
+    decoder: TransformerDecoder = _create_transformer_decoder()
+
+    return TransformerWrapper(encoder=encoder, decoder=decoder, d_model=256)
+
+
+def _load_checkpoint(model, checkpoint_path):
+    """Load model checkpoint from file."""
+    with g_pathmgr.open(checkpoint_path, "rb") as f:
+        ckpt = torch.load(f, map_location="cpu", weights_only=True)
+    if "model" in ckpt and isinstance(ckpt["model"], dict):
+        ckpt = ckpt["model"]
+    sam3_image_ckpt = {
+        k.replace("detector.", ""): v for k, v in ckpt.items() if "detector" in k
+    }
+    if model.inst_interactive_predictor is not None:
+        sam3_image_ckpt.update(
+            {
+                k.replace("tracker.", "inst_interactive_predictor.model."): v
+                for k, v in ckpt.items()
+                if "tracker" in k
+            }
+        )
+    missing_keys, _ = model.load_state_dict(sam3_image_ckpt, strict=False)
+    if len(missing_keys) > 0:
+        print(
+            f"loaded {checkpoint_path} and found "
+            f"missing and/or unexpected keys:\n{missing_keys=}"
+        )
+
+
+def _setup_device_and_mode(model, device, eval_mode):
+    """Setup model device and evaluation mode."""
+    if device == "cuda":
+        model = model.cuda()
+    if eval_mode:
+        model.eval()
+    return model
+
+
+def build_sam3_image_model(
+    bpe_path=None,
+    device="cuda" if torch.cuda.is_available() else "cpu",
+    eval_mode=True,
+    checkpoint_path=None,
+    load_from_HF=True,
+    enable_segmentation=True,
+    enable_inst_interactivity=False,
+    compile=False,
+):
+    """
+    Build SAM3 image model
+
+    Args:
+        bpe_path: Path to the BPE tokenizer vocabulary
+        device: Device to load the model on ('cuda' or 'cpu')
+        eval_mode: Whether to set the model to evaluation mode
+        checkpoint_path: Optional path to model checkpoint
+        enable_segmentation: Whether to enable segmentation head
+        enable_inst_interactivity: Whether to enable instance interactivity (SAM 1 task)
+        compile_mode: To enable compilation, set to "default"
+
+    Returns:
+        A SAM3 image model
+    """
+    if bpe_path is None:
+        bpe_path = os.path.join(
+            os.path.dirname(__file__), "..", "assets", "bpe_simple_vocab_16e6.txt.gz"
+        )
+    # Create visual components
+    compile_mode = "default" if compile else None
+    vision_encoder = _create_vision_backbone(
+        compile_mode=compile_mode, enable_inst_interactivity=enable_inst_interactivity
+    )
+
+    # Create text components
+    text_encoder = _create_text_encoder(bpe_path)
+
+    # Create visual-language backbone
+    backbone = _create_vl_backbone(vision_encoder, text_encoder)
+
+    # Create transformer components
+    transformer = _create_sam3_transformer()
+
+    # Create dot product scoring
+    dot_prod_scoring = _create_dot_product_scoring()
+
+    # Create segmentation head if enabled
+    segmentation_head = (
+        _create_segmentation_head(compile_mode=compile_mode)
+        if enable_segmentation
+        else None
+    )
+
+    # Create geometry encoder
+    input_geometry_encoder = _create_geometry_encoder()
+    if enable_inst_interactivity:
+        sam3_pvs_base = build_tracker(apply_temporal_disambiguation=False)
+        inst_predictor = SAM3InteractiveImagePredictor(sam3_pvs_base)
+    else:
+        inst_predictor = None
+    # Create the SAM3 model
+    model = _create_sam3_model(
+        backbone,
+        transformer,
+        input_geometry_encoder,
+        segmentation_head,
+        dot_prod_scoring,
+        inst_predictor,
+        eval_mode,
+    )
+    if load_from_HF and checkpoint_path is None:
+        checkpoint_path = download_ckpt_from_hf()
+    # Load checkpoint if provided
+    if checkpoint_path is not None:
+        _load_checkpoint(model, checkpoint_path)
+
+    # Setup device and mode
+    model = _setup_device_and_mode(model, device, eval_mode)
+
+    return model
+
+
+def download_ckpt_from_hf():
+    SAM3_MODEL_ID = "facebook/sam3"
+    SAM3_CKPT_NAME = "sam3.pt"
+    SAM3_CFG_NAME = "config.json"
+    _ = hf_hub_download(repo_id=SAM3_MODEL_ID, filename=SAM3_CFG_NAME)
+    checkpoint_path = hf_hub_download(repo_id=SAM3_MODEL_ID, filename=SAM3_CKPT_NAME)
+    return checkpoint_path
+
+
+def build_sam3_video_model(
+    checkpoint_path: Optional[str] = None,
+    load_from_HF=True,
+    bpe_path: Optional[str] = None,
+    has_presence_token: bool = True,
+    geo_encoder_use_img_cross_attn: bool = True,
+    strict_state_dict_loading: bool = True,
+    apply_temporal_disambiguation: bool = True,
+    device="cuda" if torch.cuda.is_available() else "cpu",
+    compile=False,
+) -> Sam3VideoInferenceWithInstanceInteractivity:
+    """
+    Build SAM3 dense tracking model.
+
+    Args:
+        checkpoint_path: Optional path to checkpoint file
+        bpe_path: Path to the BPE tokenizer file
+
+    Returns:
+        Sam3VideoInferenceWithInstanceInteractivity: The instantiated dense tracking model
+    """
+    if bpe_path is None:
+        bpe_path = os.path.join(
+            os.path.dirname(__file__), "..", "assets", "bpe_simple_vocab_16e6.txt.gz"
+        )
+
+    # Build Tracker module
+    tracker = build_tracker(apply_temporal_disambiguation=apply_temporal_disambiguation)
+
+    # Build Detector components
+    visual_neck = _create_vision_backbone()
+    text_encoder = _create_text_encoder(bpe_path)
+    backbone = SAM3VLBackbone(scalp=1, visual=visual_neck, text=text_encoder)
+    transformer = _create_sam3_transformer(has_presence_token=has_presence_token)
+    segmentation_head: UniversalSegmentationHead = _create_segmentation_head()
+    input_geometry_encoder = _create_geometry_encoder()
+
+    # Create main dot product scoring
+    main_dot_prod_mlp = MLP(
+        input_dim=256,
+        hidden_dim=2048,
+        output_dim=256,
+        num_layers=2,
+        dropout=0.1,
+        residual=True,
+        out_norm=nn.LayerNorm(256),
+    )
+    main_dot_prod_scoring = DotProductScoring(
+        d_model=256, d_proj=256, prompt_mlp=main_dot_prod_mlp
+    )
+
+    # Build Detector module
+    detector = Sam3ImageOnVideoMultiGPU(
+        num_feature_levels=1,
+        backbone=backbone,
+        transformer=transformer,
+        segmentation_head=segmentation_head,
+        semantic_segmentation_head=None,
+        input_geometry_encoder=input_geometry_encoder,
+        use_early_fusion=True,
+        use_dot_prod_scoring=True,
+        dot_prod_scoring=main_dot_prod_scoring,
+        supervise_joint_box_scores=has_presence_token,
+    )
+
+    # Build the main SAM3 video model
+    if apply_temporal_disambiguation:
+        model = Sam3VideoInferenceWithInstanceInteractivity(
+            detector=detector,
+            tracker=tracker,
+            score_threshold_detection=0.5,
+            assoc_iou_thresh=0.1,
+            det_nms_thresh=0.1,
+            new_det_thresh=0.7,
+            hotstart_delay=15,
+            hotstart_unmatch_thresh=8,
+            hotstart_dup_thresh=8,
+            suppress_unmatched_only_within_hotstart=True,
+            min_trk_keep_alive=-1,
+            max_trk_keep_alive=30,
+            init_trk_keep_alive=30,
+            suppress_overlapping_based_on_recent_occlusion_threshold=0.7,
+            suppress_det_close_to_boundary=False,
+            fill_hole_area=16,
+            recondition_every_nth_frame=16,
+            masklet_confirmation_enable=False,
+            decrease_trk_keep_alive_for_empty_masklets=False,
+            image_size=1008,
+            image_mean=(0.5, 0.5, 0.5),
+            image_std=(0.5, 0.5, 0.5),
+            compile_model=compile,
+        )
+    else:
+        # a version without any heuristics for ablation studies
+        model = Sam3VideoInferenceWithInstanceInteractivity(
+            detector=detector,
+            tracker=tracker,
+            score_threshold_detection=0.5,
+            assoc_iou_thresh=0.1,
+            det_nms_thresh=0.1,
+            new_det_thresh=0.7,
+            hotstart_delay=0,
+            hotstart_unmatch_thresh=0,
+            hotstart_dup_thresh=0,
+            suppress_unmatched_only_within_hotstart=True,
+            min_trk_keep_alive=-1,
+            max_trk_keep_alive=30,
+            init_trk_keep_alive=30,
+            suppress_overlapping_based_on_recent_occlusion_threshold=0.7,
+            suppress_det_close_to_boundary=False,
+            fill_hole_area=16,
+            recondition_every_nth_frame=0,
+            masklet_confirmation_enable=False,
+            decrease_trk_keep_alive_for_empty_masklets=False,
+            image_size=1008,
+            image_mean=(0.5, 0.5, 0.5),
+            image_std=(0.5, 0.5, 0.5),
+            compile_model=compile,
+        )
+
+    # Load checkpoint if provided
+    if load_from_HF and checkpoint_path is None:
+        checkpoint_path = download_ckpt_from_hf()
+    if checkpoint_path is not None:
+        with g_pathmgr.open(checkpoint_path, "rb") as f:
+            ckpt = torch.load(f, map_location="cpu", weights_only=True)
+        if "model" in ckpt and isinstance(ckpt["model"], dict):
+            ckpt = ckpt["model"]
+
+        missing_keys, unexpected_keys = model.load_state_dict(
+            ckpt, strict=strict_state_dict_loading
+        )
+        if missing_keys:
+            print(f"Missing keys: {missing_keys}")
+        if unexpected_keys:
+            print(f"Unexpected keys: {unexpected_keys}")
+
+    model.to(device=device)
+    return model
+
+
+def build_sam3_video_predictor(*model_args, gpus_to_use=None, **model_kwargs):
+    return Sam3VideoPredictorMultiGPU(
+        *model_args, gpus_to_use=gpus_to_use, **model_kwargs
+    )

之前的代码版本/HuatuoGPT-Vision/MedSAM3/sam3/train/__init__.py

@@ -0,0 +1 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved

之前的代码版本/HuatuoGPT-Vision/MedSAM3/sam3/train/loss/__init__.py

@@ -0,0 +1 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved

之前的代码版本/HuatuoGPT-Vision/MedSAM3/sam3/train/loss/loss_fns.py

@@ -0,0 +1,1319 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+import logging
+import warnings
+
+import torch
+import torch.distributed
+import torch.nn.functional as F
+import torchmetrics
+
+from sam3.model import box_ops
+
+from sam3.model.data_misc import interpolate
+
+from sam3.train.loss.sigmoid_focal_loss import (
+    triton_sigmoid_focal_loss,
+    triton_sigmoid_focal_loss_reduce,
+)
+from torch import nn
+
+from .mask_sampling import (
+    calculate_uncertainty,
+    get_uncertain_point_coords_with_randomness,
+    point_sample,
+)
+
+
+CORE_LOSS_KEY = "core_loss"
+
+
+def instance_masks_to_semantic_masks(
+    instance_masks: torch.Tensor, num_instances: torch.Tensor
+) -> torch.Tensor:
+    """This function converts instance masks to semantic masks.
+    It accepts a collapsed batch of instances masks (ie all instance masks are concatenated in a single tensor) and
+    the number of instances in each image of the batch.
+    It returns a mask with the same spatial dimensions as the input instance masks, where for each batch element the
+    semantic mask is the union of all the instance masks in the batch element.
+
+    If for a given batch element there are no instances (ie num_instances[i]==0), the corresponding semantic mask will be a tensor of zeros.
+
+    Args:
+        instance_masks (torch.Tensor): A tensor of shape (N, H, W) where N is the number of instances in the batch.
+        num_instances (torch.Tensor): A tensor of shape (B,) where B is the batch size. It contains the number of instances
+            in each image of the batch.
+
+    Returns:
+        torch.Tensor: A tensor of shape (B, H, W) where B is the batch size and H, W are the spatial dimensions of the
+            input instance masks.
+    """
+    if num_instances.sum() == 0:
+        # all negative batch, create a tensor of zeros (B, 1, 1)
+        return num_instances.unsqueeze(-1).unsqueeze(-1)
+
+    masks_per_query = torch.split(instance_masks, num_instances.tolist())
+
+    return torch.stack([torch.any(masks, dim=0) for masks in masks_per_query], dim=0)
+
+
+@torch.no_grad()
+def accuracy(output, target, topk=(1,)):
+    """Computes the precision@k for the specified values of k"""
+    if target.numel() == 0:
+        return [torch.zeros([], device=output.device)]
+    maxk = max(topk)
+    batch_size = target.size(0)
+
+    _, pred = output.topk(maxk, 1, True, True)
+    pred = pred.t()
+    correct = pred.eq(target.view(1, -1).expand_as(pred))
+
+    res = []
+    for k in topk:
+        correct_k = correct[:k].view(-1).float().sum(0)
+        res.append(correct_k.mul_(100.0 / batch_size))
+    return res
+
+
+def dice_loss(inputs, targets, num_boxes, loss_on_multimask=False, reduce=True):
+    """
+    Compute the DICE loss, similar to generalized IOU for masks
+    Args:
+        inputs: A float tensor of arbitrary shape.
+                The predictions for each example.
+        targets: A float tensor with the same shape as inputs. Stores the binary
+                 classification label for each element in inputs
+                (0 for the negative class and 1 for the positive class).
+    """
+    try:
+        loss = _dice_loss(inputs, targets, num_boxes, loss_on_multimask, reduce)
+    except torch.OutOfMemoryError:
+        logging.error("GPU OOM, computing dice loss on CPU")
+        # try to recover from GPU OOM by moving tensors to CPU and computing loss there
+        orig_device = inputs.device
+        inputs = inputs.cpu()
+        targets = targets.cpu()
+        if isinstance(num_boxes, torch.Tensor):
+            num_boxes = num_boxes.cpu()
+        loss = _dice_loss(inputs, targets, num_boxes, loss_on_multimask, reduce)
+        loss = loss.to(orig_device)
+
+    return loss
+
+
+def _dice_loss(inputs, targets, num_boxes, loss_on_multimask=False, reduce=True):
+    inputs = inputs.sigmoid()
+    if loss_on_multimask:
+        # inputs and targets are [N, M, H, W] where M corresponds to multiple predicted masks
+        assert inputs.dim() == 4 and targets.dim() == 4
+        # flatten spatial dimension while keeping multimask channel dimension
+        inputs = inputs.flatten(2)
+        targets = targets.flatten(2)
+        numerator = 2 * (inputs * targets).sum(-1)
+    else:
+        inputs = inputs.flatten(1)
+        numerator = 2 * (inputs * targets).sum(1)
+    denominator = inputs.sum(-1) + targets.sum(-1)
+    loss = 1 - (numerator + 1) / (denominator + 1)
+    if loss_on_multimask:
+        return loss / num_boxes
+    if not reduce:
+        return loss
+    return loss.sum() / num_boxes
+
+
+def sigmoid_focal_loss(
+    inputs,
+    targets,
+    num_boxes,
+    alpha: float = 0.25,
+    gamma: float = 2,
+    loss_on_multimask=False,
+    reduce=True,
+    triton=True,
+):
+    """
+    Loss used in RetinaNet for dense detection: https://arxiv.org/abs/1708.02002.
+    Args:
+        inputs: A float tensor of arbitrary shape.
+                The predictions for each example.
+        targets: A float tensor with the same shape as inputs. Stores the binary
+                 classification label for each element in inputs
+                (0 for the negative class and 1 for the positive class).
+        alpha: (optional) Weighting factor in range (0,1) to balance
+                positive vs negative examples. Default = -1 (no weighting).
+        gamma: Exponent of the modulating factor (1 - p_t) to
+               balance easy vs hard examples.
+    Returns:
+        Loss tensor
+    """
+    if not (0 <= alpha <= 1) and triton:
+        raise RuntimeError(f"Alpha should be in [0,1], got {alpha}")
+    if triton:
+        if reduce and not loss_on_multimask:
+            loss = triton_sigmoid_focal_loss_reduce(inputs, targets, alpha, gamma)
+            return loss / (num_boxes * inputs.shape[1])
+
+        loss = triton_sigmoid_focal_loss(inputs, targets, alpha, gamma)
+    else:
+        prob = inputs.sigmoid()
+        ce_loss = F.binary_cross_entropy_with_logits(inputs, targets, reduction="none")
+        p_t = prob * targets + (1 - prob) * (1 - targets)
+        loss = ce_loss * ((1 - p_t) ** gamma)
+
+        if alpha >= 0:
+            alpha_t = alpha * targets + (1 - alpha) * (1 - targets)
+            loss = alpha_t * loss
+
+    if not reduce:
+        return loss
+
+    if loss_on_multimask:
+        # loss is [N, M, H, W] where M corresponds to multiple predicted masks
+        assert loss.dim() == 4
+        return loss.flatten(2).mean(-1) / num_boxes  # average over spatial dims
+    return loss.mean(1).sum() / num_boxes
+
+
+def iou_loss(
+    inputs, targets, pred_ious, num_boxes, loss_on_multimask=False, use_l1_loss=False
+):
+    """MSE loss between predicted IoUs and actual IoUs between inputs and targets."""
+    assert inputs.dim() == 4 and targets.dim() == 4
+    pred_mask = inputs.flatten(2) > 0
+    gt_mask = targets.flatten(2) > 0
+    area_i = torch.sum(pred_mask & gt_mask, dim=-1).float()
+    area_u = torch.sum(pred_mask | gt_mask, dim=-1).float()
+    actual_ious = area_i / torch.clamp(area_u, min=1.0)
+
+    if use_l1_loss:
+        loss = F.l1_loss(pred_ious, actual_ious, reduction="none")
+    else:
+        loss = F.mse_loss(pred_ious, actual_ious, reduction="none")
+    if loss_on_multimask:
+        return loss / num_boxes
+    return loss.sum() / num_boxes
+
+
+@torch.jit.script
+def _contrastive_align(logits, positive_map):
+    positive_logits = -logits.masked_fill(~positive_map, 0)
+    negative_logits = logits  # .masked_fill(positive_map, -1000000)
+
+    boxes_with_pos = positive_map.any(2)
+    pos_term = positive_logits.sum(2)
+    neg_term = negative_logits.logsumexp(2)
+
+    nb_pos = positive_map.sum(2) + 1e-6
+
+    box_to_token_loss = (
+        (pos_term / nb_pos + neg_term).masked_fill(~boxes_with_pos, 0).sum()
+    )
+
+    tokens_with_pos = positive_map.any(1)
+    pos_term = positive_logits.sum(1)
+    neg_term = negative_logits.logsumexp(1)
+
+    nb_pos = positive_map.sum(1) + 1e-6
+
+    tokens_to_boxes_loss = (
+        (pos_term / nb_pos + neg_term).masked_fill(~tokens_with_pos, 0).sum()
+    )
+    return (box_to_token_loss + tokens_to_boxes_loss) / 2
+
+
+def _get_src_permutation_idx(indices):
+    # permute predictions following indices
+    batch_idx = torch.cat(
+        [torch.full_like(src, i) for i, (src, _) in enumerate(indices)]
+    )
+    src_idx = torch.cat([src for (src, _) in indices])
+    return batch_idx, src_idx
+
+
+class LossWithWeights(nn.Module):
+    def __init__(self, weight_dict, compute_aux, supports_o2m_loss=True):
+        super().__init__()
+        # weights for each computed loss key (those losses not in weight_dict
+        # will not be aggregated in the final reduced core loss)
+        self.weight_dict = weight_dict if weight_dict is not None else {}
+        # whether this loss will be applied on auxiliary outputs
+        self.compute_aux = compute_aux
+        self.supports_o2m_loss = supports_o2m_loss
+        self.target_keys = []
+
+    def forward(self, *args, is_aux=False, **kwargs):
+        if is_aux and not self.compute_aux:
+            return {CORE_LOSS_KEY: 0.0}
+        losses = self.get_loss(*args, **kwargs)
+        losses[CORE_LOSS_KEY] = self.reduce_loss(losses)
+        return losses
+
+    def get_loss(self, **kwargs):
+        raise NotImplementedError()
+
+    def reduce_loss(self, losses):
+        reduced_loss = 0.0
+        for loss_key, weight in self.weight_dict.items():
+            if loss_key not in losses:
+                raise ValueError(f"{type(self)} doesn't compute {loss_key}")
+            if weight != 0:
+                reduced_loss += losses[loss_key] * weight
+
+        return reduced_loss
+
+
+class IABCEMdetr(LossWithWeights):
+    def __init__(
+        self,
+        pos_weight,
+        weight_dict=None,
+        compute_aux=True,
+        gamma=0,
+        weak_loss=True,
+        alpha=0.25,
+        pad_n_queries=None,
+        pad_scale_pos=1.0,
+        use_separate_loss_for_det_and_trk=False,
+        num_det_queries=None,
+        det_exhaustive_loss_scale_pos=1.0,
+        det_exhaustive_loss_scale_neg=1.0,
+        det_non_exhaustive_loss_scale_pos=1.0,
+        det_non_exhaustive_loss_scale_neg=1.0,
+        trk_loss_scale_pos=1.0,
+        trk_loss_scale_neg=1.0,
+        no_loss_for_fp_propagation=False,
+        apply_loss_to_det_queries_in_video_grounding=True,
+        use_presence=False,
+        use_presence_semgseg=False,  # If True, use presence scores from the semgseg head.
+        presence_alpha=0.5,
+        presence_gamma=0.0,
+        pos_focal: bool = False,  # for box scores, use focal loss for positives as well
+    ):
+        super().__init__(weight_dict, compute_aux)
+        self.pos_weight = pos_weight
+        self.gamma = gamma
+        self.weak_loss = weak_loss
+        self.alpha = alpha
+        self.target_keys.append("boxes_xyxy")
+        self.no_loss_for_fp_propagation = no_loss_for_fp_propagation
+        if self.weak_loss:
+            self.target_keys.append("is_exhaustive")
+        # NOTE: This is hacky solution to have the same CE loss scale across datasets where the model might predict different number of object queries for different tasks.
+        # If not None, we assume there are a total pad_n_queries object queries.
+        # For example, if the model predicts only 1 object query and pad_n_queries=100, we pad the predictions with 99 zero preds.
+        # Currently this only affects the BCE loss and not the F1 score.
+        self.pad_n_queries = pad_n_queries
+        self.pad_scale_pos = pad_scale_pos
+        if self.pad_scale_pos != 1.0:
+            assert self.pad_n_queries is not None
+        # whether to use presence scores
+        self.use_presence = use_presence
+        self.use_presence_semgseg = use_presence_semgseg
+        if self.use_presence_semgseg:
+            assert self.use_presence
+        self.presence_alpha = presence_alpha
+        self.presence_gamma = presence_gamma
+        self.pos_focal = pos_focal
+
+        # Decoupled loss for detection and tracking queries
+        self.apply_loss_to_det_queries_in_video_grounding = (
+            apply_loss_to_det_queries_in_video_grounding
+        )
+        self.use_separate_loss_for_det_and_trk = use_separate_loss_for_det_and_trk
+        if num_det_queries is not None:
+            logging.warning("note: it's not needed to set num_det_queries anymore")
+        if self.use_separate_loss_for_det_and_trk:
+            assert not self.weak_loss, "Do not use weak_loss in this case -- set separate loss for detection and tracking queries instead"
+            self.det_exhaustive_loss_scale_pos = det_exhaustive_loss_scale_pos
+            self.det_exhaustive_loss_scale_neg = det_exhaustive_loss_scale_neg
+            self.det_non_exhaustive_loss_scale_pos = det_non_exhaustive_loss_scale_pos
+            self.det_non_exhaustive_loss_scale_neg = det_non_exhaustive_loss_scale_neg
+            self.trk_loss_scale_pos = trk_loss_scale_pos
+            self.trk_loss_scale_neg = trk_loss_scale_neg
+        else:
+            assert (
+                det_exhaustive_loss_scale_pos == 1.0
+                and det_exhaustive_loss_scale_neg == 1.0
+                and det_non_exhaustive_loss_scale_pos == 1.0
+                and det_non_exhaustive_loss_scale_neg == 1.0
+                and trk_loss_scale_pos == 1.0
+                and trk_loss_scale_neg == 1.0
+            ), "If not using separate loss for detection and tracking queries, separate detection and tracking loss scales should all be 1.0"
+
+    def get_loss(self, outputs, targets, indices, num_boxes):
+        assert len(outputs["pred_logits"].shape) > 2, "Incorrect predicted logits shape"
+        assert outputs["pred_logits"].shape[-1] == 1, "Incorrect predicted logits shape"
+        src_logits = outputs["pred_logits"].squeeze(-1)
+        prob = src_logits.sigmoid()
+
+        with torch.no_grad():
+            target_classes = torch.full(
+                src_logits.shape[:2],
+                0,
+                dtype=torch.float,
+                device=src_logits.device,
+            )
+            target_classes[(indices[0], indices[1])] = 1
+            src_boxes_xyxy = outputs["pred_boxes_xyxy"][(indices[0], indices[1])]
+            target_boxes_giou = (
+                targets["boxes_xyxy"][indices[2]]
+                if indices[2] is not None
+                else targets["boxes_xyxy"]
+            )
+
+            iou = box_ops.fast_diag_box_iou(src_boxes_xyxy, target_boxes_giou)
+            t = prob[(indices[0], indices[1])] ** self.alpha * iou ** (1 - self.alpha)
+            t = torch.clamp(t, 0.01).detach()
+            positive_target_classes = target_classes.clone()
+            positive_target_classes[(indices[0], indices[1])] = t
+
+        # Soft loss on positives
+        if self.pos_focal:
+            loss_bce = sigmoid_focal_loss(
+                src_logits.contiguous(),
+                positive_target_classes,
+                num_boxes=1,
+                alpha=0.5,
+                gamma=self.gamma,
+                reduce=False,
+            )
+        else:
+            loss_bce = F.binary_cross_entropy_with_logits(
+                src_logits, positive_target_classes, reduction="none"
+            )
+        loss_bce = loss_bce * target_classes * self.pos_weight
+
+        if (
+            self.pad_n_queries is not None
+            and isinstance(self.pad_n_queries, int)
+            and loss_bce.size(1) < self.pad_n_queries
+        ):
+            loss_bce = loss_bce * self.pad_scale_pos
+        # Negatives
+        loss_bce = loss_bce + F.binary_cross_entropy_with_logits(
+            src_logits, target_classes, reduction="none"
+        ) * (1 - target_classes) * (prob**self.gamma)
+
+        # Optionally, not applying IABCEMdetr loss to detection queries in video.
+        is_video_grounding = outputs.get("is_video_grounding_batch", False)
+        if is_video_grounding and not self.apply_loss_to_det_queries_in_video_grounding:
+            Q_det = outputs["Q_det"]
+            loss_bce[:, :Q_det] *= 0.0
+        presence_loss = torch.tensor(0.0, device=src_logits.device)
+        presence_dec_acc = torch.tensor(0.0, device=src_logits.device)
+        if self.use_presence:
+            # no classifiction loss for individual tokens if no target gt
+            # cannot directly use targets["num_boxes"] to check if some
+            # GT box exists as there may be dummy boxes for "invisible objects"
+            # in video grounding data
+
+            gt_padded_object_ids = targets["object_ids_padded"]  # (B, H)
+            gt_padded_boxes = targets["boxes_padded"]  # (B, H, 4) shape, CxCyWH
+            gt_padded_is_visible = (
+                (gt_padded_object_ids >= 0)
+                & (gt_padded_boxes[..., 2] > 0)  # width > 0
+                & (gt_padded_boxes[..., 3] > 0)  # height > 0
+            )
+            keep_loss = (gt_padded_is_visible.sum(dim=-1)[..., None] != 0).float()
+
+            loss_bce = loss_bce * keep_loss
+
+            if self.use_presence_semgseg:
+                # no loss here, has it's own separate loss computation
+                assert "presence_logit_dec" not in outputs
+            elif "presence_logit_dec" in outputs:
+                presence_logits = outputs["presence_logit_dec"].view_as(keep_loss)
+                bs = presence_logits.shape[0]
+                presence_loss = sigmoid_focal_loss(
+                    presence_logits,
+                    keep_loss,
+                    # not num_boxes, but we'll use it to normalize by bs
+                    num_boxes=bs,
+                    alpha=self.presence_alpha,
+                    gamma=self.presence_gamma,
+                )
+                pred = (presence_logits.sigmoid() > 0.5).float()
+                presence_dec_acc = (pred == keep_loss).float().mean()
+            else:
+                # for o2m, nothing to do
+                pass
+
+        if self.weak_loss:
+            assert not self.use_separate_loss_for_det_and_trk, "Do not use weak_loss in this case -- set separate loss for detection and tracking queries instead"
+
+            # nullify the negative loss for the non-exhaustive classes
+            assert loss_bce.shape[0] == targets["is_exhaustive"].shape[0]
+            assert targets["is_exhaustive"].ndim == 1
+
+            loss_mask = (~targets["is_exhaustive"]).view(-1, 1).expand_as(loss_bce)
+            # restrict the mask to the negative supervision
+            loss_mask = loss_mask & (target_classes < 0.5)
+            loss_mask = ~loss_mask
+            # Mask the loss
+            loss_bce = loss_bce * loss_mask.float()
+            # Average
+            loss_bce = loss_bce.sum() / (loss_mask.sum() + 1e-6)
+        else:
+            # apply separate loss weights to detection and tracking queries
+            if self.use_separate_loss_for_det_and_trk:
+                Q_det = outputs["Q_det"]
+                assert loss_bce.size(1) >= Q_det
+                is_positive = target_classes > 0.5
+                is_positive_det = is_positive[:, :Q_det]
+                is_positive_trk = is_positive[:, Q_det:]
+                assert loss_bce.size(0) == targets["is_exhaustive"].size(0)
+                is_exhaustive = targets["is_exhaustive"].unsqueeze(1).bool()
+                loss_scales = torch.zeros_like(loss_bce)
+                # detection query loss weights
+                loss_scales[:, :Q_det] = (
+                    (is_exhaustive & is_positive_det).float()
+                    * self.det_exhaustive_loss_scale_pos
+                    + (is_exhaustive & ~is_positive_det).float()
+                    * self.det_exhaustive_loss_scale_neg
+                    + (~is_exhaustive & is_positive_det).float()
+                    * self.det_non_exhaustive_loss_scale_pos
+                    + (~is_exhaustive & ~is_positive_det).float()
+                    * self.det_non_exhaustive_loss_scale_neg
+                )
+                # tracking query weights
+                loss_scales[:, Q_det:] = (
+                    is_positive_trk.float() * self.trk_loss_scale_pos
+                    + (~is_positive_trk).float() * self.trk_loss_scale_neg
+                )
+                # apply the loss weights
+
+                # if the id is -2 means it is a fp propagation , we don't apply the loss to them
+                if self.no_loss_for_fp_propagation:
+                    is_original_queries = outputs["pred_old_obj_ids"] != -2
+                    loss_scales *= (is_exhaustive | is_original_queries).float()
+
+                loss_bce = loss_bce * loss_scales
+
+            if self.pad_n_queries is None or loss_bce.size(1) >= self.pad_n_queries:
+                loss_bce = loss_bce.mean()
+            else:
+                assert isinstance(self.pad_n_queries, int)
+                assert (
+                    loss_bce.size(1) < self.pad_n_queries
+                ), f"The number of predictions is more than the expected total after padding. Got {loss_bce.size(1)} predictions."
+                loss_bce = loss_bce.sum() / (self.pad_n_queries * loss_bce.size(0))
+
+        bce_f1 = torchmetrics.functional.f1_score(
+            src_logits.sigmoid().flatten(),
+            target=target_classes.flatten().long(),
+            task="binary",
+        )
+
+        losses = {
+            "loss_ce": loss_bce,
+            "ce_f1": bce_f1,
+            "presence_loss": presence_loss,
+            "presence_dec_acc": presence_dec_acc,
+        }
+        return losses
+
+
+class Boxes(LossWithWeights):
+    def __init__(
+        self,
+        weight_dict=None,
+        compute_aux=True,
+        apply_loss_to_det_queries_in_video_grounding=True,
+    ):
+        super().__init__(weight_dict, compute_aux)
+        self.apply_loss_to_det_queries_in_video_grounding = (
+            apply_loss_to_det_queries_in_video_grounding
+        )
+        self.target_keys.extend(["boxes", "boxes_xyxy"])
+
+    def get_loss(self, outputs, targets, indices, num_boxes):
+        """Compute the losses related to the bounding boxes, the L1 regression loss and the GIoU loss
+        targets dicts must contain the key "boxes" containing a tensor of dim [nb_target_boxes, 4]
+        The target boxes are expected in format (center_x, center_y, h, w), normalized by the image size.
+        """
+        # Optionally, not applying Boxes loss to detection queries in video.
+        is_video_grounding = outputs.get("is_video_grounding_batch", False)
+        if is_video_grounding and not self.apply_loss_to_det_queries_in_video_grounding:
+            indices = _keep_only_trk_queries_in_match_inds(
+                indices, Q_det=outputs["Q_det"]
+            )
+
+        assert "pred_boxes" in outputs
+        # idx = self._get_src_permutation_idx(indices)
+        src_boxes = outputs["pred_boxes"][(indices[0], indices[1])]
+        src_boxes_xyxy = outputs["pred_boxes_xyxy"][(indices[0], indices[1])]
+        target_boxes = (
+            targets["boxes"] if indices[2] is None else targets["boxes"][indices[2]]
+        )
+        target_boxes_giou = (
+            targets["boxes_xyxy"]
+            if indices[2] is None
+            else targets["boxes_xyxy"][indices[2]]
+        )
+
+        loss_bbox = F.l1_loss(src_boxes, target_boxes, reduction="none")
+
+        losses = {}
+        losses["loss_bbox"] = loss_bbox.sum() / num_boxes
+
+        loss_giou = 1 - box_ops.fast_diag_generalized_box_iou(
+            src_boxes_xyxy, target_boxes_giou
+        )
+        losses["loss_giou"] = loss_giou.sum() / num_boxes
+        return losses
+
+
+class Masks(LossWithWeights):
+    def __init__(
+        self,
+        weight_dict=None,
+        compute_aux=False,
+        focal_alpha=0.25,
+        focal_gamma=2,
+        num_sample_points=None,
+        oversample_ratio=None,
+        importance_sample_ratio=None,
+        apply_loss_to_det_queries_in_video_grounding=True,
+    ):
+        super().__init__(weight_dict, compute_aux)
+        if compute_aux:
+            warnings.warn("Masks loss usually shouldn't be applied to aux outputs")
+        self.focal_alpha = focal_alpha
+        self.focal_gamma = focal_gamma
+        self.num_sample_points = num_sample_points
+        self.oversample_ratio = oversample_ratio
+        self.importance_sample_ratio = importance_sample_ratio
+        self.apply_loss_to_det_queries_in_video_grounding = (
+            apply_loss_to_det_queries_in_video_grounding
+        )
+        self.target_keys.extend(["masks", "is_valid_mask"])
+
+    def _sampled_loss(self, src_masks, target_masks, num_boxes):
+        assert len(src_masks.shape) == 3 and len(target_masks.shape) == 3
+        src_masks = src_masks[:, None]
+        target_masks = target_masks[:, None]
+        with torch.no_grad():
+            # Sample point_coords
+            point_coords = get_uncertain_point_coords_with_randomness(
+                src_masks,
+                calculate_uncertainty,
+                self.num_sample_points,
+                self.oversample_ratio,
+                self.importance_sample_ratio,
+            )
+
+            # get GT labels
+            sampled_target_masks = point_sample(
+                target_masks,
+                point_coords,
+                align_corners=False,
+            ).squeeze(1)
+
+        sampled_src_masks = point_sample(
+            src_masks,
+            point_coords,
+            align_corners=False,
+        ).squeeze(1)
+
+        losses = {
+            "loss_mask": sigmoid_focal_loss(
+                sampled_src_masks,
+                sampled_target_masks,
+                num_boxes,
+                alpha=self.focal_alpha,
+                gamma=self.focal_gamma,
+            ),
+            "loss_dice": dice_loss(sampled_src_masks, sampled_target_masks, num_boxes),
+        }
+        # Not needed for backward
+        del src_masks
+        del target_masks
+
+        return losses
+
+    def get_loss(self, outputs, targets, indices, num_boxes):
+        """Compute the losses related to the masks: the focal loss and the dice loss.
+        targets dicts must contain the key "masks" containing a tensor of dim [nb_target_boxes, h, w]
+        """
+        assert "pred_masks" in outputs
+        assert "is_valid_mask" in targets
+        # Optionally, not applying Masks loss to detection queries in video.
+        is_video_grounding = outputs.get("is_video_grounding_batch", False)
+        if is_video_grounding and not self.apply_loss_to_det_queries_in_video_grounding:
+            indices = _keep_only_trk_queries_in_match_inds(
+                indices, Q_det=outputs["Q_det"]
+            )
+
+        src_masks = outputs["pred_masks"]
+
+        # Dataset doesn't have segmentation masks
+        if targets["masks"] is None:
+            return {
+                "loss_mask": torch.tensor(0.0, device=src_masks.device),
+                "loss_dice": torch.tensor(0.0, device=src_masks.device),
+            }
+
+        target_masks = (
+            targets["masks"] if indices[2] is None else targets["masks"][indices[2]]
+        )
+        target_masks = target_masks.to(src_masks)
+        keep = (
+            targets["is_valid_mask"]
+            if indices[2] is None
+            else targets["is_valid_mask"][indices[2]]
+        )
+
+        src_masks = src_masks[(indices[0], indices[1])]
+
+        # Remove invalid masks from loss
+        src_masks = src_masks[keep]
+        target_masks = target_masks[keep]
+
+        if self.num_sample_points is not None:
+            # Compute loss on sampled points for the Mask
+            losses = self._sampled_loss(src_masks, target_masks, num_boxes)
+
+        else:
+            # upsample predictions to the target size
+            if target_masks.shape[0] == 0 and src_masks.shape[0] == 0:
+                src_masks = src_masks.flatten(1)
+                target_masks = target_masks.reshape(src_masks.shape)
+            else:
+                if len(src_masks.shape) == 3:
+                    src_masks = src_masks[:, None]
+                if src_masks.dtype == torch.bfloat16:
+                    # Bilinear interpolation does not support bf16
+                    src_masks = src_masks.to(dtype=torch.float32)
+                src_masks = interpolate(
+                    src_masks,
+                    size=target_masks.shape[-2:],
+                    mode="bilinear",
+                    align_corners=False,
+                )
+                src_masks = src_masks[:, 0].flatten(1)
+                target_masks = target_masks.flatten(1)
+
+            losses = {
+                "loss_mask": sigmoid_focal_loss(
+                    src_masks,
+                    target_masks,
+                    num_boxes,
+                    alpha=self.focal_alpha,
+                    gamma=self.focal_gamma,
+                ),
+                "loss_dice": dice_loss(src_masks, target_masks, num_boxes),
+            }
+
+        return losses
+
+
+# class MultiStepIteractiveMasks(LossWithWeights):
+#     def __init__(
+#         self,
+#         weight_dict=None,
+#         compute_aux=False,
+#         focal_alpha=0.25,
+#         focal_gamma=2,
+#     ):
+#         warnings.warn(
+#             "MultiStepIteractiveMasks is deprecated. Please use MultiStepMultiMasksAndIous",
+#             DeprecationWarning,
+#         )
+#         super().__init__(weight_dict, compute_aux)
+#         self.focal_alpha = focal_alpha
+#         self.focal_gamma = focal_gamma
+#         self.target_keys.extend(["masks"])
+
+#     def get_loss(self, outputs, targets, indices, num_boxes):
+#         """Compute the losses related to the masks: the focal loss and the dice loss.
+#         targets dicts must contain the key "masks" containing a tensor of dim [nb_target_boxes, h, w]
+
+#         Unlike `Masks`, here the "multistep_pred_masks" can have multiple channels, each
+#         corresponding to one iterative prediction step in SAM-style training. We treat each
+#         channel as a mask prediction and sum the loss across channels.
+#         """
+#         src_masks = outputs["multistep_pred_masks"]
+#         target_masks = targets["masks"]
+#         assert src_masks.size(0) == target_masks.size(0)
+#         assert src_masks.dim() == 4
+#         assert target_masks.dim() == 3
+
+#         # tile target_masks according to the number of
+#         # channels `src_masks`.
+#         num_steps = src_masks.size(1)
+#         target_masks = target_masks.unsqueeze(1).to(src_masks.dtype)
+#         if num_steps > 1:
+#             target_masks = target_masks.repeat(1, num_steps, 1, 1)
+
+#         # resize `src_masks` to target mask resolution
+#         if src_masks.shape != target_masks.shape:
+#             src_masks = interpolate(
+#                 src_masks,
+#                 size=target_masks.shape[-2:],
+#                 mode="bilinear",
+#                 align_corners=False,
+#             )
+#             assert src_masks.shape == target_masks.shape
+
+#         # flatten the multiple steps in to the batch dimension
+#         src_masks = src_masks.flatten(0, 1).flatten(1)
+#         target_masks = target_masks.flatten(0, 1).flatten(1)
+#         losses = {
+#             "loss_mask": sigmoid_focal_loss(
+#                 src_masks,
+#                 target_masks,
+#                 num_boxes,
+#                 alpha=self.focal_alpha,
+#                 gamma=self.focal_gamma,
+#             ),
+#             "loss_dice": dice_loss(src_masks, target_masks, num_boxes),
+#         }
+
+#         return losses
+
+
+# class MultiStepMultiMasksAndIous(LossWithWeights):
+#     def __init__(
+#         self,
+#         weight_dict=None,
+#         compute_aux=False,
+#         focal_alpha=0.25,
+#         focal_gamma=2,
+#         # if True, back-prop on all predicted ious
+#         # not just the one with lowest loss_combo
+#         supervise_all_iou=False,
+#         # Less slack vs MSE loss in [-1, 1] error range
+#         iou_use_l1_loss=False,
+#         # Settings for obj score prediction
+#         pred_obj_scores=False,
+#         focal_gamma_obj_score=0.0,
+#         focal_alpha_obj_score=-1,
+#     ):
+#         super().__init__(weight_dict, compute_aux)
+#         self.focal_alpha = focal_alpha
+#         self.focal_gamma = focal_gamma
+#         self.target_keys.extend(["masks"])
+#         assert "loss_mask" in self.weight_dict
+#         assert "loss_dice" in self.weight_dict
+#         assert "loss_iou" in self.weight_dict
+#         if "loss_class" not in self.weight_dict:
+#             self.weight_dict["loss_class"] = 0.0
+#         self.focal_alpha_obj_score = focal_alpha_obj_score
+#         self.focal_gamma_obj_score = focal_gamma_obj_score
+#         self.supervise_all_iou = supervise_all_iou
+#         self.iou_use_l1_loss = iou_use_l1_loss
+#         self.pred_obj_scores = pred_obj_scores
+
+#     def get_loss(self, outputs, targets, indices, num_boxes):
+#         """
+#         Compute the losses related to the masks: the focal loss and the dice loss.
+#         and also the MSE loss between predicted IoUs and actual IoUs.
+
+#         Here "multistep_pred_multimasks_high_res" is a list of multimasks (tensors
+#         of shape [N, M, H, W], where M could be 1 or larger, corresponding to
+#         one or multiple predicted masks from a click.
+
+#         We back-propagate focal, dice and iou losses only on the prediction channel
+#         with the lowest focal+dice loss between predicted mask and ground-truth.
+#         """
+
+#         target_masks = targets["masks"].unsqueeze(1).float()
+#         assert target_masks.dim() == 4  # [N, 1, H, W]
+#         src_masks_list = outputs["multistep_pred_multimasks_high_res"]
+#         ious_list = outputs["multistep_pred_ious"]
+#         object_score_logits_list = outputs["multistep_object_score_logits"]
+
+#         assert len(src_masks_list) == len(ious_list)
+#         assert len(object_score_logits_list) == len(ious_list)
+
+#         # Remove invalid masks from loss
+#         keep = targets["is_valid_mask"]
+#         target_masks = target_masks[keep]
+
+#         # accumulate the loss over prediction steps
+#         losses = {"loss_mask": 0, "loss_dice": 0, "loss_iou": 0, "loss_class": 0}
+#         for src_masks, ious, object_score_logits in zip(
+#             src_masks_list, ious_list, object_score_logits_list
+#         ):
+#             object_score_logits = object_score_logits[keep]
+#             ious = ious[keep]
+#             src_masks = src_masks[keep]
+#             self._update_losses(
+#                 losses, src_masks, target_masks, ious, num_boxes, object_score_logits
+#             )
+#         return losses
+
+#     def _update_losses(
+#         self, losses, src_masks, target_masks, ious, num_boxes, object_score_logits
+#     ):
+#         target_masks = target_masks.expand_as(src_masks)
+#         # get focal, dice and iou loss on all output masks in a prediction step
+#         loss_multimask = sigmoid_focal_loss(
+#             src_masks,
+#             target_masks,
+#             num_boxes,
+#             alpha=self.focal_alpha,
+#             gamma=self.focal_gamma,
+#             loss_on_multimask=True,
+#             triton=False,  # only use triton if alpha > 0
+#         )
+#         loss_multidice = dice_loss(
+#             src_masks, target_masks, num_boxes, loss_on_multimask=True
+#         )
+#         if not self.pred_obj_scores:
+#             loss_class = torch.tensor(
+#                 0.0, dtype=loss_multimask.dtype, device=loss_multimask.device
+#             )
+#             target_obj = torch.ones(
+#                 loss_multimask.shape[0],
+#                 1,
+#                 dtype=loss_multimask.dtype,
+#                 device=loss_multimask.device,
+#             )
+#         else:
+#             target_obj = torch.any((target_masks[:, 0] > 0).flatten(1), dim=-1)[
+#                 ..., None
+#             ].float()
+#             loss_class = sigmoid_focal_loss(
+#                 object_score_logits,
+#                 target_obj,
+#                 num_boxes,
+#                 alpha=self.focal_alpha_obj_score,
+#                 gamma=self.focal_gamma_obj_score,
+#                 triton=False,
+#             )
+
+#         loss_multiiou = iou_loss(
+#             src_masks,
+#             target_masks,
+#             ious,
+#             num_boxes,
+#             loss_on_multimask=True,
+#             use_l1_loss=self.iou_use_l1_loss,
+#         )
+#         assert loss_multimask.dim() == 2
+#         assert loss_multidice.dim() == 2
+#         assert loss_multiiou.dim() == 2
+#         if loss_multimask.size(1) > 1:
+#             # take the mask indices with the smallest focal + dice loss for back propagation
+#             loss_combo = (
+#                 loss_multimask * self.weight_dict["loss_mask"]
+#                 + loss_multidice * self.weight_dict["loss_dice"]
+#             )
+#             best_loss_inds = torch.argmin(loss_combo, dim=-1)
+#             batch_inds = torch.arange(loss_combo.size(0), device=loss_combo.device)
+#             loss_mask = loss_multimask[batch_inds, best_loss_inds].unsqueeze(1)
+#             loss_dice = loss_multidice[batch_inds, best_loss_inds].unsqueeze(1)
+#             # calculate the iou prediction and slot losses only in the index
+#             # with the minimum loss for each mask (to be consistent w/ SAM)
+#             if self.supervise_all_iou:
+#                 loss_iou = loss_multiiou.mean(dim=-1).unsqueeze(1)
+#             else:
+#                 loss_iou = loss_multiiou[batch_inds, best_loss_inds].unsqueeze(1)
+#         else:
+#             loss_mask = loss_multimask
+#             loss_dice = loss_multidice
+#             loss_iou = loss_multiiou
+
+#         # backprop focal, dice and iou loss only if obj present
+#         loss_mask = loss_mask * target_obj
+#         loss_dice = loss_dice * target_obj
+#         loss_iou = loss_iou * target_obj
+
+#         # sum over batch dimension (note that the losses are already divided by num_boxes)
+#         losses["loss_mask"] += loss_mask.sum()
+#         losses["loss_dice"] += loss_dice.sum()
+#         losses["loss_iou"] += loss_iou.sum()
+#         losses["loss_class"] += loss_class
+
+
+# class TextCriterion(LossWithWeights):
+#     def __init__(
+#         self,
+#         pad_token,
+#         max_seq_len=100,
+#         weight_dict=None,
+#         compute_aux=False,
+#     ):
+#         super().__init__(weight_dict, compute_aux)
+#         self.pad_token = pad_token
+#         self.max_seq_len = max_seq_len
+#         self.in_lengths = None
+
+#     def get_loss(self, outputs, **kwargs):
+#         nb_tokens = outputs["captioning_tokenized_target"].input_ids.numel()
+#         bs, seq_len = outputs["captioning_tokenized_target"].input_ids.shape
+#         ce = F.cross_entropy(
+#             outputs["captioning_pred_text"].flatten(0, -2),
+#             outputs["captioning_tokenized_target"].input_ids.flatten(),
+#             ignore_index=self.pad_token,
+#             reduction="sum",
+#         )
+
+#         not_pad = (
+#             outputs["captioning_tokenized_target"]
+#             .input_ids.reshape(-1)
+#             .ne(self.pad_token)
+#         )
+
+#         if nb_tokens > 0:
+#             nb_non_pad = not_pad.numel()
+#             ce = ce / nb_non_pad
+
+#         preds = outputs["captioning_pred_text"].flatten(0, -2).argmax(-1)[not_pad]
+#         targets = outputs["captioning_tokenized_target"].input_ids.flatten()[not_pad]
+#         correct = preds == targets
+#         correct = correct.sum() / (correct.numel() + 1e-5)
+
+#         correct_sequence_level = torch.all(
+#             (
+#                 outputs["captioning_pred_text"]
+#                 .flatten(0, -2)
+#                 .argmax(-1)
+#                 .reshape(bs, seq_len)
+#                 == outputs["captioning_tokenized_target"].input_ids
+#             )
+#             | (~not_pad).view(bs, seq_len),
+#             dim=1,
+#         )
+#         seq_level_acc = correct_sequence_level.float().mean()
+
+#         return {"loss_text": ce, "text_acc": correct, "text_seq_acc": seq_level_acc}
+
+
+def segment_miou(source, target):
+    """Compute the mean IoU between two sets of masks"""
+    assert source.shape == target.shape, "The two masks must have the same shape"
+    assert source.ndim == 3, "The masks must be 3D"
+
+    valid_targets = (target.sum(dim=(1, 2)) > 0).sum()
+    if valid_targets == 0:
+        return torch.tensor(1.0, device=source.device)
+    intersection = (source.bool() & target.bool()).sum(dim=(1, 2))
+    union = (source.bool() | target.bool()).sum(dim=(1, 2))
+    iou = intersection / (union + 1e-8)
+    return iou.sum() / valid_targets
+
+
+class SemanticSegCriterion(LossWithWeights):
+    def __init__(
+        self,
+        weight_dict,
+        focal: bool = False,
+        focal_alpha: float = 0.6,
+        focal_gamma: float = 1.6,
+        downsample: bool = True,
+        presence_head: bool = False,
+        # Option to turn off presence loss, if some other component
+        # is already doing it, e.g. decoder - in which case,
+        # we could still set presence_head to True so that
+        # losses are not propogated to masks when there is no GT mask
+        presence_loss: bool = True,
+    ):
+        super().__init__(weight_dict, False)
+        self.focal = focal
+        self.focal_alpha = focal_alpha
+        self.focal_gamma = focal_gamma
+        self.downsample = downsample
+        self.presence_head = presence_head
+        self.presence_loss = presence_loss
+
+    def get_loss(self, out_dict, targets):
+        outputs = out_dict["semantic_seg"]
+        presence_logit = out_dict["presence_logit"]
+        if (
+            "semantic_masks" in targets
+            and targets["semantic_masks"] is not None
+            and targets["semantic_masks"].size(0) > 0
+        ):
+            semantic_targets = targets["semantic_masks"]
+            with torch.no_grad():
+                if self.downsample:
+                    # downsample targets to the size of predictions
+                    size = outputs.shape[-2:]
+                    semantic_targets = (
+                        F.interpolate(
+                            semantic_targets.float().unsqueeze(1),
+                            size=size,
+                            mode="bilinear",
+                            align_corners=False,
+                        )
+                        .squeeze(1)
+                        .bool()
+                    )
+        else:
+            with torch.no_grad():
+                if self.downsample:
+                    # downsample targets to the size of predictions
+                    size = outputs.shape[-2:]
+                    segments = (
+                        F.interpolate(
+                            targets["masks"].float().unsqueeze(1),
+                            size=size,
+                            mode="bilinear",
+                            align_corners=False,
+                        )
+                        .squeeze(1)
+                        .bool()
+                    )
+                else:
+                    segments = targets["masks"].bool()
+
+                # the annotations are for instance segmentation, so we merge them to get semantic segmentation
+                semantic_targets = instance_masks_to_semantic_masks(
+                    segments, targets["num_boxes"]
+                )
+
+        if not self.downsample:
+            # upsample predictions to the target size
+            size = semantic_targets.shape[-2:]
+            outputs = F.interpolate(
+                outputs.float(),
+                size=size,
+                mode="bilinear",
+                align_corners=False,
+            )
+
+        if self.focal:
+            loss = sigmoid_focal_loss(
+                outputs.squeeze(1).flatten(-2),
+                semantic_targets.float().flatten(-2),
+                num_boxes=len(semantic_targets),
+                alpha=self.focal_alpha,
+                gamma=self.focal_gamma,
+                reduce=not self.presence_head,
+            )
+            if self.presence_head:
+                loss = loss.mean(1)
+        else:
+            loss = F.binary_cross_entropy_with_logits(
+                outputs.squeeze(1),
+                semantic_targets.float(),
+                reduction="none" if self.presence_head else "mean",
+            )
+            if self.presence_head:
+                loss = loss.flatten(1).mean(1)
+
+        loss_dice = dice_loss(
+            outputs.squeeze(1).flatten(1),
+            semantic_targets.flatten(1),
+            len(semantic_targets),
+            reduce=not self.presence_head,
+        )
+
+        miou = segment_miou(outputs.sigmoid().squeeze(1) > 0.5, semantic_targets)
+
+        loss_dict = {}
+
+        if self.presence_head:
+            presence_target = semantic_targets.flatten(1).any(-1)
+            if self.presence_loss:
+                loss_presence = F.binary_cross_entropy_with_logits(
+                    presence_logit.flatten(),
+                    presence_target.float(),
+                )
+                presence_acc = (
+                    ((presence_logit.flatten().sigmoid() > 0.5) == presence_target)
+                    .float()
+                    .mean()
+                )
+            else:
+                # Dummy values
+                loss_presence = torch.tensor(0.0, device=loss.device)
+                # Whichever component is computing the presence loss,
+                # should also track presence_acc
+                presence_acc = torch.tensor(0.0, device=loss.device)
+
+            loss_dict["loss_semantic_presence"] = loss_presence
+            loss_dict["presence_acc"] = presence_acc
+
+            # reduce the other losses, skipping the negative ones
+            bs = loss.shape[0]
+            assert presence_target.numel() == bs
+
+            mask = presence_target
+            nb_valid = presence_target.sum().item()
+
+            loss = (loss * mask.float()).sum() / (nb_valid + 1e-6)
+            loss_dice = (loss_dice * mask.float()).sum() / (nb_valid + 1e-6)
+
+        loss_dict.update(
+            {
+                "loss_semantic_seg": loss,
+                "loss_semantic_dice": loss_dice,
+                "miou_semantic_seg": miou,
+            }
+        )
+
+        return loss_dict
+
+
+class Det2TrkAssoc(LossWithWeights):
+    def __init__(
+        self,
+        weight_dict,
+        use_fp_loss=False,
+        fp_loss_on_exhaustive_only=True,
+        treat_fp_as_new_obj=False,
+    ):
+        super().__init__(weight_dict, compute_aux=False)
+        self.use_fp_loss = use_fp_loss
+        self.fp_loss_on_exhaustive_only = fp_loss_on_exhaustive_only
+        self.treat_fp_as_new_obj = treat_fp_as_new_obj
+        if self.use_fp_loss:
+            self.target_keys.append("is_exhaustive")
+
+    def get_loss(self, outputs, targets, indices, num_boxes):
+        det2trk_assoc_logits = outputs["det2trk_assoc_logits"]
+        device = det2trk_assoc_logits.device
+        B, Q_det, Q_trk_plus_2 = det2trk_assoc_logits.shape
+        assert Q_trk_plus_2 >= 2
+        Q_trk = Q_trk_plus_2 - 2
+
+        # We only apply association losses to those detection queries that either match
+        # a GT instance or have score > 0 (i.e. those TP, FN and FP detection queries)
+        matched_object_ids = outputs["matched_object_ids"]
+        assert matched_object_ids.shape == (B, Q_det + Q_trk)
+        matched_obj_ids_det = matched_object_ids[:, :Q_det]
+        matched_obj_ids_trk = matched_object_ids[:, Q_det:]
+        det_is_matched_to_gt = matched_obj_ids_det >= 0
+        trk_is_matched_to_gt = matched_obj_ids_trk >= 0
+
+        # note: -1 label is ignored in the (softmax) cross_entropy loss below
+        det2trk_assoc_labels = -torch.ones(B, Q_det, dtype=torch.long, device=device)
+        # a) If a detection query is matched to a same object ID as a tracking query,
+        # we assign it the index of the tracking query as a label
+        det_is_same_obj_id_as_trk = (
+            det_is_matched_to_gt[:, :, None]
+            & trk_is_matched_to_gt[:, None, :]
+            & (matched_obj_ids_det[:, :, None] == matched_obj_ids_trk[:, None, :])
+        )
+        batch_idx, det_idx, trk_idx = det_is_same_obj_id_as_trk.nonzero(as_tuple=True)
+        det2trk_assoc_labels[batch_idx, det_idx] = trk_idx
+
+        # b) If a detection query is matched to GT but not to any tracking query,
+        # we assign it a "new_object" label
+        det_is_new_obj = det_is_matched_to_gt & ~det_is_same_obj_id_as_trk.any(dim=-1)
+        det2trk_assoc_labels[det_is_new_obj] = Q_trk
+
+        # c) If a detection query is not matched to GT but have score > 0,
+        # we assign it a "false_positive" label
+        if self.use_fp_loss:
+            det_is_above_thresh = outputs["pred_logits"][:, :Q_det].squeeze(2) > 0
+            det_is_fp = ~det_is_matched_to_gt & det_is_above_thresh
+            if self.treat_fp_as_new_obj:
+                det2trk_assoc_labels[det_is_fp] = Q_trk
+            else:
+                if self.fp_loss_on_exhaustive_only:
+                    # only count FP detections on batches that are exhaustively annotated
+                    det_is_fp &= targets["is_exhaustive"].unsqueeze(1).bool()
+                det2trk_assoc_labels[det_is_fp] = Q_trk + 1
+
+        # softmax cross-entropy loss for detection-to-tracking association
+        loss_det2trk_assoc = F.cross_entropy(
+            input=det2trk_assoc_logits.flatten(0, 1),  # (B * Q_det, Q_trk + 2)
+            target=det2trk_assoc_labels.flatten(0, 1),  # (B * Q_det)
+            ignore_index=-1,
+            reduction="none",
+        ).view(B, Q_det)
+        # skip det2trk assocation loss on frames w/o any (non-padding) tracking queries
+        frame_has_valid_trk = trk_is_matched_to_gt.any(dim=-1, keepdims=True)  # (B, 1)
+        loss_det2trk_assoc = loss_det2trk_assoc * frame_has_valid_trk.float()
+
+        loss_det2trk_assoc = loss_det2trk_assoc.sum() / (B * num_boxes)
+        return {"loss_det2trk_assoc": loss_det2trk_assoc}
+
+
+class TrackingByDetectionAssoc(LossWithWeights):
+    def __init__(self, weight_dict):
+        super().__init__(weight_dict, compute_aux=False, supports_o2m_loss=False)
+        assert "loss_det2trk_assoc" in self.weight_dict
+        assert "loss_trk2det_assoc" in self.weight_dict
+
+    def get_loss(self, outputs, targets, indices, num_boxes):
+        # Part A: gather object id matching between detection and tracking
+        det2trk_assoc_logits = outputs["det2trk_assoc_logits"]  # (B, Q_det+1, Q_trk+1)
+        B, Q_det_plus_1, Q_trk_plus_1 = det2trk_assoc_logits.shape
+        assert Q_det_plus_1 >= 1 and Q_trk_plus_1 >= 1
+        Q_det = Q_det_plus_1 - 1
+        Q_trk = Q_trk_plus_1 - 1
+        device = det2trk_assoc_logits.device
+
+        matched_obj_ids_det = outputs["matched_object_ids"]
+        assert matched_obj_ids_det.shape == (B, Q_det)
+        det_is_matched_to_gt = matched_obj_ids_det >= 0
+        matched_obj_ids_trk = outputs["prev_trk_object_ids"]
+        assert matched_obj_ids_trk.shape == (B, Q_trk)
+        trk_is_matched_to_gt = matched_obj_ids_trk >= 0
+        frame_has_valid_trk = trk_is_matched_to_gt.any(dim=-1, keepdims=True)  # (B, 1)
+
+        # check whether a detection object is the same as a tracking object
+        det_is_same_obj_id_as_trk = (
+            det_is_matched_to_gt[:, :, None]
+            & trk_is_matched_to_gt[:, None, :]
+            & (matched_obj_ids_det[:, :, None] == matched_obj_ids_trk[:, None, :])
+        )  # (B, Q_det, Q_trk)
+        # there should be at most one match for each detection and each previous tracked object
+        torch._assert_async(torch.all(det_is_same_obj_id_as_trk.sum(dim=2) <= 1))
+        torch._assert_async(torch.all(det_is_same_obj_id_as_trk.sum(dim=1) <= 1))
+        batch_idx, det_idx, trk_idx = det_is_same_obj_id_as_trk.nonzero(as_tuple=True)
+
+        # Part B: Detection-to-tracking association loss
+        # assign detection-to-tracking labels (note: -1 label is ignored in the loss below)
+        det2trk_assoc_labels = -torch.ones(B, Q_det, dtype=torch.long, device=device)
+        det2trk_assoc_labels[batch_idx, det_idx] = trk_idx
+        # if a detection is matched to GT but not to any tracking, assign it a "new-object" label
+        det_is_new_obj = det_is_matched_to_gt & ~det_is_same_obj_id_as_trk.any(dim=2)
+        det2trk_assoc_labels[det_is_new_obj] = Q_trk  # "Q_trk" label is "new-object"
+
+        # softmax cross-entropy loss for detection-to-tracking association
+        loss_det2trk_assoc = F.cross_entropy(
+            input=det2trk_assoc_logits[:, :-1].flatten(0, 1),  # (B*Q_det, Q_trk+1)
+            target=det2trk_assoc_labels.flatten(0, 1),  # (B*Q_det)
+            ignore_index=-1,
+            reduction="none",
+        ).view(B, Q_det)
+        # skip det2trk assocation loss on frames w/o any (non-padding) tracking queries
+        loss_det2trk_assoc = loss_det2trk_assoc * frame_has_valid_trk.float()
+        loss_det2trk_assoc = loss_det2trk_assoc.sum() / (B * num_boxes)
+        loss_dict = {"loss_det2trk_assoc": loss_det2trk_assoc}
+
+        # Part C: tracking-to-detection association loss
+        trk2det_assoc_logits = det2trk_assoc_logits.transpose(1, 2)
+        assert trk2det_assoc_logits.shape == (B, Q_trk + 1, Q_det + 1)
+        # assign tracking-to-detection labels (note: -1 label is ignored in the loss below)
+        trk2det_assoc_labels = -torch.ones(B, Q_trk, dtype=torch.long, device=device)
+        trk2det_assoc_labels[batch_idx, trk_idx] = det_idx
+        # if a tracking is matched to GT but not to any detection, assign it a "occluded" label
+        trk_is_occluded = trk_is_matched_to_gt & ~det_is_same_obj_id_as_trk.any(dim=1)
+        trk2det_assoc_labels[trk_is_occluded] = Q_det  # "Q_det" label is "occluded"
+
+        # softmax cross-entropy loss for tracking-to-detection association
+        loss_trk2det_assoc = F.cross_entropy(
+            input=trk2det_assoc_logits[:, :-1].flatten(0, 1),  # (B*Q_trk, Q_det+1)
+            target=trk2det_assoc_labels.flatten(0, 1),  # (B*Q_trk)
+            ignore_index=-1,
+            reduction="none",
+        ).view(B, Q_trk)
+        # skip trk2det association loss on frames w/o any (non-padding) tracking queries
+        loss_trk2det_assoc = loss_trk2det_assoc * frame_has_valid_trk.float()
+        loss_trk2det_assoc = loss_trk2det_assoc.sum() / (B * num_boxes)
+        loss_dict["loss_trk2det_assoc"] = loss_trk2det_assoc
+
+        return loss_dict
+
+
+def _keep_only_trk_queries_in_match_inds(inds, Q_det):
+    """Keep only the tracking query indices in the indices tuple"""
+    batch_idx, src_idx, tgt_idx = inds
+    if batch_idx.numel() == 0:
+        return (batch_idx, src_idx, tgt_idx)  # empty indices, nothing to filter
+
+    # keep only the tracking query indices
+    is_trk_query = src_idx >= Q_det
+    batch_idx_trk = batch_idx[is_trk_query]
+    src_idx_trk = src_idx[is_trk_query]
+    tgt_idx_trk = tgt_idx[is_trk_query] if tgt_idx is not None else None
+    return (batch_idx_trk, src_idx_trk, tgt_idx_trk)

之前的代码版本/HuatuoGPT-Vision/MedSAM3/sam3/train/loss/mask_sampling.py

@@ -0,0 +1,113 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+from typing import Callable
+
+import torch
+from torch.nn import functional as F
+
+
+# Adapted from https://github.com/facebookresearch/detectron2/blob/main/projects/PointRend/point_rend/point_features.py
+def point_sample(input, point_coords, **kwargs):
+    """
+    A wrapper around :function:`torch.nn.functional.grid_sample` to support 3D point_coords tensors.
+    Unlike :function:`torch.nn.functional.grid_sample` it assumes `point_coords` to lie inside
+    [0, 1] x [0, 1] square.
+
+    Args:
+        input (Tensor): A tensor of shape (N, C, H, W) that contains features map on a H x W grid.
+        point_coords (Tensor): A tensor of shape (N, P, 2) or (N, Hgrid, Wgrid, 2) that contains
+        [0, 1] x [0, 1] normalized point coordinates.
+
+    Returns:
+        output (Tensor): A tensor of shape (N, C, P) or (N, C, Hgrid, Wgrid) that contains
+            features for points in `point_coords`. The features are obtained via bilinear
+            interplation from `input` the same way as :function:`torch.nn.functional.grid_sample`.
+    """
+    add_dim = False
+    if point_coords.dim() == 3:
+        add_dim = True
+        point_coords = point_coords.unsqueeze(2)
+    normalized_point_coords = 2.0 * point_coords - 1.0  # Normalize to [-1,1]
+    output = F.grid_sample(input, normalized_point_coords, **kwargs)
+    if add_dim:
+        output = output.squeeze(3)
+    return output
+
+
+# Adapted from https://github.com/facebookresearch/detectron2/blob/main/projects/PointRend/point_rend/point_features.py
+def get_uncertain_point_coords_with_randomness(
+    logits: torch.Tensor,
+    uncertainty_func: Callable,
+    num_points: int,
+    oversample_ratio: int,
+    importance_sample_ratio: float,
+) -> torch.Tensor:
+    """
+    Sample points in [0, 1] x [0, 1] coordinate space based on their uncertainty. The unceratinties
+        are calculated for each point using 'uncertainty_func' function that takes point's logit
+        prediction as input.
+    See PointRend paper for details.
+
+    Args:
+        logits (Tensor): A tensor of shape (N, C, Hmask, Wmask) or (N, 1, Hmask, Wmask) for
+            class-specific or class-agnostic prediction.
+        uncertainty_func: A function that takes a Tensor of shape (N, C, P) or (N, 1, P) that
+            contains logit predictions for P points and returns their uncertainties as a Tensor of
+            shape (N, 1, P).
+        num_points (int): The number of points P to sample.
+        oversample_ratio (int): Oversampling parameter.
+        importance_sample_ratio (float): Ratio of points that are sampled via importnace sampling.
+
+    Returns:
+        point_coords (Tensor): A tensor of shape (N, P, 2) that contains the coordinates of P
+            sampled points.
+    """
+    assert oversample_ratio >= 1
+    assert importance_sample_ratio <= 1 and importance_sample_ratio >= 0
+    num_boxes = logits.shape[0]
+    num_sampled = int(num_points * oversample_ratio)
+    point_coords = torch.rand(num_boxes, num_sampled, 2, device=logits.device)
+    point_logits = point_sample(logits, point_coords, align_corners=False)
+    # It is crucial to calculate uncertainty based on the sampled prediction value for the points.
+    # Calculating uncertainties of the predictions first and sampling them for points leads
+    # to incorrect results.
+    # To illustrate this: assume uncertainty_func(logits)=-abs(logits), a sampled point between
+    # two predictions with -1 and 1 logits has 0 logits, and therefore 0 uncertainty value.
+    # However, if we calculate uncertainties for the predictions first,
+    # both will have -1 uncertainty, and the sampled point will get -1 uncertainty.
+    point_uncertainties = uncertainty_func(point_logits)
+    num_uncertain_points = int(importance_sample_ratio * num_points)
+    num_random_points = num_points - num_uncertain_points
+    idx = torch.topk(point_uncertainties[:, 0, :], k=num_uncertain_points, dim=1)[1]
+    # Flatten the indices
+    shift = num_sampled * torch.arange(
+        num_boxes, dtype=torch.long, device=logits.device
+    )
+    idx += shift[:, None]
+    point_coords = point_coords.view(-1, 2)[idx.view(-1), :].view(
+        num_boxes, num_uncertain_points, 2
+    )
+    if num_random_points > 0:
+        point_coords = torch.cat(
+            [
+                point_coords,
+                torch.rand(num_boxes, num_random_points, 2, device=logits.device),
+            ],
+            dim=1,
+        )
+    return point_coords
+
+
+# Adapted from https://github.com/facebookresearch/Mask2Former/blob/main/mask2former/modeling/criterion.py
+def calculate_uncertainty(logits: torch.Tensor) -> torch.Tensor:
+    """
+    Estimates uncerainty as L1 distance between 0.0 and the logit prediction.
+    Args:
+        logits (Tensor): A tensor of shape (R, 1, ...) for class-agnostic
+        predicted masks
+    Returns:
+        scores (Tensor): A tensor of shape (R, 1, ...) that contains uncertainty scores with
+            the most uncertain locations having the highest uncertainty score.
+    """
+    assert logits.shape[1] == 1
+    return -(torch.abs(logits))

之前的代码版本/HuatuoGPT-Vision/MedSAM3/sam3/train/loss/sam3_loss.py

@@ -0,0 +1,203 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+import torch
+
+from sam3.model.model_misc import SAM3Output
+
+from sam3.train.utils.distributed import get_world_size
+
+from .loss_fns import CORE_LOSS_KEY, Det2TrkAssoc, Masks
+
+
+class DummyLoss(torch.nn.Module):
+    """A dummy loss that always returns 0 (as a placeholder for eval)"""
+
+    def __init__(
+        self,
+        core_loss_key: str = CORE_LOSS_KEY,
+        device: str = "cuda",
+        **kwargs,
+    ):
+        super().__init__()
+        self.core_loss_key = core_loss_key
+        self.device = torch.device(device)
+
+    def forward(self, *args, **kwargs):
+        return {self.core_loss_key: torch.tensor(0.0, device=self.device)}
+
+    def accumulate(self, out_dict):
+        """
+        Called by iterative losses.
+        """
+        if self.core_loss_key not in out_dict:
+            out_dict[self.core_loss_key] = torch.tensor(0.0, device=self.device)
+        return out_dict
+
+
+class Sam3LossWrapper(torch.nn.Module):
+    def __init__(
+        self,
+        loss_fns_find,
+        normalization="global",
+        matcher=None,
+        o2m_matcher=None,
+        o2m_weight=1.0,
+        use_o2m_matcher_on_o2m_aux=True,
+        loss_fn_semantic_seg=None,
+        normalize_by_valid_object_num=False,
+        normalize_by_stage_num=False,
+        scale_by_find_batch_size=False,
+    ):
+        super().__init__()
+        self.loss_fns_find = loss_fns_find
+        assert normalization in ["global", "local", "none"]
+        self.normalization = normalization
+        self.normalize_by_valid_object_num = normalize_by_valid_object_num
+        self.normalize_by_stage_num = normalize_by_stage_num
+        self.matcher = matcher
+        self.o2m_matcher = o2m_matcher
+        self.o2m_weight = o2m_weight
+        # whether to use the o2m matcher on the o2m queries in auxiliary outputs
+        self.use_o2m_matcher_on_o2m_aux = use_o2m_matcher_on_o2m_aux
+        self.loss_fn_semantic_seg = loss_fn_semantic_seg
+        self.scale_by_find_batch_size = scale_by_find_batch_size
+
+    def _get_num_boxes(self, targets):
+        # the average number of target boxes for loss normalization
+        if self.normalize_by_valid_object_num:
+            # valid boxes are those with non-zero height and width
+            # (while padded invisible boxes are )
+            boxes_hw = targets["boxes"].view(-1, 4)  # cx, cy, w, h
+            num_boxes = (boxes_hw[:, 2:] > 0).all(dim=-1).sum().float()
+        else:
+            num_boxes = targets["num_boxes"].sum().float()
+        if self.normalization == "global":
+            torch.distributed.all_reduce(num_boxes)
+            num_boxes = torch.clamp(num_boxes / get_world_size(), min=1)
+        elif self.normalization == "local":
+            num_boxes = torch.clamp(num_boxes, min=1)
+        elif self.normalization == "none":
+            num_boxes = 1
+        return num_boxes
+
+    def compute_loss(self, nested_out, targets):
+        num_boxes = self._get_num_boxes(targets)
+        o2m_out_is_valid = nested_out.get("o2m_out_is_valid", None)
+        o2m_target_is_valid_padded = nested_out.get("o2m_target_is_valid_padded", None)
+
+        # Get a list of outputs, including auxiliary and first stage outputs
+        output_list = [(nested_out, "", False)]  # (out, suffix, is_aux)
+        if "aux_outputs" in nested_out:
+            output_list.extend(
+                (aux_out, f"_aux_{i}", True)
+                for i, aux_out in enumerate(nested_out["aux_outputs"])
+            )
+        if "first_stage" in nested_out:
+            output_list.append((nested_out["first_stage"], "_fs", True))
+
+        # Compute all the requested losses
+        losses = {}
+        total_core_loss = 0.0
+        for out, suffix, is_aux in output_list:
+            # o2o matcher indices need to be computed by the model (as the video model requires
+            # a specific way of matching free and locked indices beyond just calling the matcher)
+            indices = out["indices"]
+            has_o2m_out = "pred_logits_o2m" in out
+            if has_o2m_out:
+                o2m_out = {
+                    k[: -len("_o2m")]: v for k, v in out.items() if k.endswith("_o2m")
+                }
+                # o2m targets are the same as the o2o targets (assuming repeat=1)
+                o2m_targets = targets
+                if self.use_o2m_matcher_on_o2m_aux or not is_aux:
+                    o2m_indices = self.o2m_matcher(
+                        o2m_out,
+                        o2m_targets,
+                        out_is_valid=o2m_out_is_valid,
+                        target_is_valid_padded=o2m_target_is_valid_padded,
+                    )
+                else:
+                    o2m_indices = self.matcher(
+                        o2m_out,
+                        o2m_targets,
+                        out_is_valid=o2m_out_is_valid,
+                        target_is_valid_padded=o2m_target_is_valid_padded,
+                    )
+
+            for loss_fn in self.loss_fns_find:
+                l_dict = loss_fn(
+                    outputs=out,
+                    targets=targets,
+                    indices=indices,
+                    num_boxes=num_boxes,
+                    is_aux=is_aux,
+                )
+                total_core_loss += l_dict.pop(CORE_LOSS_KEY)
+                losses.update({f"{k}{suffix}": v for k, v in l_dict.items()})
+
+                compute_o2m_loss = has_o2m_out
+                # a special handling to allow turning off mask loss in o2m
+                # (to be compatible with the original implementation)
+                if isinstance(loss_fn, Masks):
+                    compute_o2m_loss = compute_o2m_loss and "pred_masks" in o2m_out
+                if isinstance(loss_fn, Det2TrkAssoc):
+                    compute_o2m_loss = False  # Det2TrkAssoc does not support o2m
+                if compute_o2m_loss:
+                    l_dict = loss_fn(
+                        outputs=o2m_out,
+                        targets=o2m_targets,
+                        indices=o2m_indices,
+                        num_boxes=num_boxes,
+                        is_aux=is_aux,
+                    )
+                    for k in l_dict:
+                        l_dict[k] *= self.o2m_weight
+                    total_core_loss += l_dict.pop(CORE_LOSS_KEY)
+                    losses.update({f"{k}{suffix}_o2m": v for k, v in l_dict.items()})
+
+        losses[CORE_LOSS_KEY] = total_core_loss
+        return losses
+
+    def forward(self, find_stages: SAM3Output, find_targets):
+        if find_stages.loss_stages is not None:
+            find_targets = [find_targets[i] for i in find_stages.loss_stages]
+        with SAM3Output.iteration_mode(
+            find_stages, iter_mode=SAM3Output.IterMode.ALL_STEPS_PER_STAGE
+        ) as find_stages:
+            assert len(find_stages) == len(find_targets)
+            total_losses = {}
+            for stage_outputs, stage_targets in zip(find_stages, find_targets):
+                stage_targets = [stage_targets] * len(stage_outputs)
+                # If there are multiple steps within a stage, compute the loss for all of them (e.g. interactivity)
+                for outputs, targets in zip(stage_outputs, stage_targets):
+                    cur_losses = self.compute_loss(outputs, targets)
+
+                    if self.loss_fn_semantic_seg is not None:
+                        cur_losses_semantic = self.loss_fn_semantic_seg(
+                            outputs, targets
+                        )
+                        cur_losses[CORE_LOSS_KEY] += cur_losses_semantic.pop(
+                            CORE_LOSS_KEY
+                        )
+                        # make sure the semantic losses don't overlap with the find losses
+                        assert set(cur_losses).isdisjoint(set(cur_losses_semantic))
+                        cur_losses.update(cur_losses_semantic)
+
+                    # Optionally, normalize the loss by the number of find stages (training video frames) so that
+                    # image batches and video batches have similar loss scales. (Otherwise video batches would
+                    # have a much higher loss scale due to summing the losses over all the find stages.)
+                    if self.normalize_by_stage_num:
+                        cur_losses[CORE_LOSS_KEY] /= len(find_stages)
+
+                    if self.scale_by_find_batch_size:
+                        bs = targets["num_boxes"].shape[0]
+                        # sqrt scaling based on the "effective" batch size
+                        cur_losses[CORE_LOSS_KEY] *= bs**0.5
+
+                    for k, v in cur_losses.items():
+                        if k not in total_losses:
+                            total_losses[k] = v
+                        else:
+                            total_losses[k] += v
+
+        return total_losses

之前的代码版本/HuatuoGPT-Vision/MedSAM3/sam3/train/loss/sigmoid_focal_loss.py

@@ -0,0 +1,321 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+"""Triton kernel for faster and memory efficient sigmoid focal loss"""
+
+import torch
+import triton
+import triton.language as tl
+from torch._inductor.runtime.triton_helpers import libdevice
+
+"""
+
+The sigmoid focal loss is defined as:
+
+    prob = inputs.sigmoid()
+    ce_loss = F.binary_cross_entropy_with_logits(inputs, targets, reduction="none")
+    p_t = prob * targets + (1 - prob) * (1 - targets)
+    alpha_t = alpha * targets + (1 - alpha) * (1 - targets)
+    loss = alpha_t * ce_loss * ((1 - p_t) ** gamma)
+
+Where alpha and gamma are scalar parameters, inputs are the logits, targets the float targets.
+
+We implement two versions of the sigmoid focal loss: with and without sum reduction.
+The latter is implemented with built-in reduction to avoid materializing wrt the output of the loss.
+This can help save a bit of peak memory.
+
+The reduction version is implemented using somewhat of a hack. Pytorch's generated kernels usually do the point-wise operation in a first kernel, and implement the reduction another kernel launched on a grid of size 1, where the reduction happens as a for loop in the triton kernel.
+Since we want to fuse those two kernels, that is not a good idea: we'd have to launch the overall kernel on a grid of size 1, which is obviously inefficient.
+On the other hand, typical CUDA algorithms for reduction (eg reduction tree) are hard to implement in triton due to the lack of thread sync primitives.
+We settle for a version that abuses triton's atomic_add: we can have all threads simply add to the same location.
+In practice, this is not good, since it creates a massive bottleneck on the semaphore for that single memory location. So instead, we create M reduction locations. Each thread will simply write to thread_id%M. The python code can finally sum over the M reductions.
+M = 32 works fine in benchmarking tests. The forward is a tiny bit slower compared to the non-reduced kernel, but the backward breaks even due to one less memory allocation.
+"""
+
+
+@triton.jit
+def _inner_focal_loss_fwd(inputs, targets, alpha, gamma):
+    inv_targets = 1 - targets
+    # Sigmoid
+    sig = tl.sigmoid(inputs)
+
+    # Binary cross entropy with logits
+    # In practice, we want the following:
+    # bce_loss = -targets * tl.log(sig) - (1 - targets) * tl.log(1 - sig)
+    # However, the above is not numerically stable.
+    # We're also not directly taking the sum here, so the usual log-sum-exp trick doesn't apply
+    # The bce can be reformulated, after algebraic manipulation, to
+    # bce_loss = log(1 + exp(-x)) + x * (1-y)
+    # This is still not stable, because for large (-x) the exponential will blow up.
+    # We'll use the following alternate formulation:
+    # bce_loss = max(x, 0) - x * y + log(1 + exp(-abs(x)))
+    # Let's show that it's equivalent:
+    # Case x>=0: abs(x) = x , max(x, 0) = x
+    # so we get x - x * y + log(1 + exp(-x)) which is equivalent
+    # Case x<0: abs(x) = -x, max(x, 0) = 0
+    # we have log(1 + exp(-abs(x))) = log(1 + exp(x)) = log(exp(x)(1 + exp(-x))) = x+log(1 + exp(-x))
+    # plugging it in, we get
+    # 0 - x * y + x + log(1 + exp(-x)), which is also equivalent
+    # Note that this is stable because now the exponent are guaranteed to be below 0.
+    max_val = tl.clamp(inputs, min=0, max=1e9)
+    bce_loss = max_val - inputs * targets + tl.log(1 + tl.exp(-tl.abs(inputs)))
+
+    # Modulating factor
+    p_t = sig * targets + (1 - sig) * inv_targets
+    mod_factor = libdevice.pow(1 - p_t, gamma)
+
+    # Alpha factor
+    alpha_t = alpha * targets + (1 - alpha) * inv_targets
+
+    # Final loss calculation
+    return alpha_t * mod_factor * bce_loss
+
+
+# Non-reduced version
+@triton.jit
+def sigmoid_focal_loss_fwd_kernel(
+    inputs_ptr,
+    targets_ptr,
+    loss_ptr,
+    alpha: float,
+    gamma: float,
+    n_elements: int,
+    BLOCK_SIZE: tl.constexpr,
+):
+    pid = tl.program_id(axis=0)
+    block_start = pid * BLOCK_SIZE
+    offset = block_start + tl.arange(0, BLOCK_SIZE)
+    mask = offset < n_elements
+
+    # Load data
+    inputs = tl.load(inputs_ptr + offset, mask=mask).to(tl.float32)
+    targets = tl.load(targets_ptr + offset, mask=mask)
+
+    final_loss = _inner_focal_loss_fwd(inputs, targets, alpha, gamma)
+
+    # Store result
+    tl.store(loss_ptr + offset, final_loss, mask=mask)
+
+
+# version with reduction
+@triton.jit
+def sigmoid_focal_loss_fwd_kernel_reduce(
+    inputs_ptr,
+    targets_ptr,
+    loss_ptr,
+    alpha: float,
+    gamma: float,
+    n_elements: int,
+    BLOCK_SIZE: tl.constexpr,
+    REDUCE_SIZE: tl.constexpr,
+):
+    pid = tl.program_id(axis=0)
+    block_start = pid * BLOCK_SIZE
+    reduce_loc = pid % REDUCE_SIZE
+    offset = block_start + tl.arange(0, BLOCK_SIZE)
+    mask = offset < n_elements
+    # Load data
+    inputs = tl.load(inputs_ptr + offset, mask=mask).to(tl.float32)
+    targets = tl.load(targets_ptr + offset, mask=mask)
+
+    final_loss = _inner_focal_loss_fwd(inputs, targets, alpha, gamma) * mask
+
+    fl = tl.sum(final_loss)
+
+    # Store result
+    tl.atomic_add(loss_ptr + reduce_loc, fl)
+
+
+@triton.jit
+def _inner_focal_loss_bwd(inputs, targets, alpha, gamma):
+    inv_targets = 1 - targets
+
+    # Recompute forward
+    max_val = tl.clamp(inputs, min=0, max=1e9)
+    bce_loss = max_val - inputs * targets + tl.log(1 + tl.exp(-tl.abs(inputs)))
+
+    # Sigmoid
+    sig = tl.sigmoid(inputs)
+    inv_sig = 1 - sig
+
+    # Modulating factor
+    p_t = sig * targets + inv_sig * inv_targets
+    tmp = libdevice.pow(1 - p_t, gamma - 1)
+    mod_factor = tmp * (1 - p_t)
+
+    # Alpha factor
+    alpha_t = alpha * targets + (1 - alpha) * inv_targets
+
+    # Now computing the derivatives
+    d_pt = (2 * targets - 1) * sig * inv_sig
+    d_mod_factor = -gamma * d_pt * tmp
+
+    d_bce_loss = sig - targets
+
+    return alpha_t * (d_bce_loss * mod_factor + d_mod_factor * bce_loss)
+
+
+@triton.jit
+def sigmoid_focal_loss_bwd_kernel(
+    inputs_ptr,
+    targets_ptr,
+    grad_inputs_ptr,
+    grad_out_ptr,
+    alpha: float,
+    gamma: float,
+    n_elements: int,
+    BLOCK_SIZE: tl.constexpr,
+):
+    pid = tl.program_id(axis=0)
+    block_start = pid * BLOCK_SIZE
+    offset = block_start + tl.arange(0, BLOCK_SIZE)
+    mask = offset < n_elements
+    input_ptrs = inputs_ptr + offset
+    target_ptrs = targets_ptr + offset
+    grad_input_ptrs = grad_inputs_ptr + offset
+    grad_out_ptrs = grad_out_ptr + offset
+    # Load data
+    inputs = tl.load(input_ptrs, mask=mask).to(tl.float32)
+    targets = tl.load(target_ptrs, mask=mask)
+    grad_out = tl.load(grad_out_ptrs, mask=mask)
+    d_loss = grad_out * _inner_focal_loss_bwd(inputs, targets, alpha, gamma)
+    tl.store(grad_input_ptrs, d_loss, mask=mask)
+
+
+@triton.jit
+def sigmoid_focal_loss_bwd_kernel_reduce(
+    inputs_ptr,
+    targets_ptr,
+    grad_inputs_ptr,
+    grad_out_ptr,
+    alpha: float,
+    gamma: float,
+    n_elements: int,
+    BLOCK_SIZE: tl.constexpr,
+):
+    # The only difference is that the gradient is now a single scalar
+    pid = tl.program_id(axis=0)
+    block_start = pid * BLOCK_SIZE
+    offset = block_start + tl.arange(0, BLOCK_SIZE)
+    mask = offset < n_elements
+    input_ptrs = inputs_ptr + offset
+    target_ptrs = targets_ptr + offset
+    grad_input_ptrs = grad_inputs_ptr + offset
+    # Load data
+    inputs = tl.load(input_ptrs, mask=mask).to(tl.float32)
+    targets = tl.load(target_ptrs, mask=mask)
+    grad_out = tl.load(grad_out_ptr)
+    d_loss = grad_out * _inner_focal_loss_bwd(inputs, targets, alpha, gamma)
+    tl.store(grad_input_ptrs, d_loss, mask=mask)
+
+
+class SigmoidFocalLoss(torch.autograd.Function):
+    BLOCK_SIZE = 256
+
+    @staticmethod
+    def forward(ctx, inputs, targets, alpha=0.25, gamma=2):
+        n_elements = inputs.numel()
+        assert targets.numel() == n_elements
+        input_shape = inputs.shape
+        inputs = inputs.view(-1).contiguous()
+        targets = targets.view(-1).contiguous()
+        loss = torch.empty(inputs.shape, dtype=torch.float32, device=inputs.device)
+        grid = lambda meta: (triton.cdiv(n_elements, meta["BLOCK_SIZE"]),)
+        sigmoid_focal_loss_fwd_kernel[grid](
+            inputs, targets, loss, alpha, gamma, n_elements, SigmoidFocalLoss.BLOCK_SIZE
+        )
+        ctx.save_for_backward(inputs.view(input_shape), targets.view(input_shape))
+        ctx.alpha = alpha
+        ctx.gamma = gamma
+        return loss.view(input_shape)
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        inputs, targets = ctx.saved_tensors
+        alpha = ctx.alpha
+        gamma = ctx.gamma
+        n_elements = inputs.numel()
+        input_shape = inputs.shape
+        grad_inputs = torch.empty(
+            inputs.shape, dtype=grad_output.dtype, device=grad_output.device
+        )
+        inputs_ptr = inputs.view(-1).contiguous()
+        targets_ptr = targets.view(-1).contiguous()
+        grad_output_ptr = grad_output.view(-1).contiguous()
+        grad_inputs_ptr = grad_inputs
+        assert grad_output.numel() == n_elements
+        grid = lambda meta: (triton.cdiv(n_elements, meta["BLOCK_SIZE"]),)
+        sigmoid_focal_loss_bwd_kernel[grid](
+            inputs_ptr,
+            targets_ptr,
+            grad_inputs_ptr,
+            grad_output_ptr,
+            alpha,
+            gamma,
+            n_elements,
+            SigmoidFocalLoss.BLOCK_SIZE,
+        )
+        return grad_inputs.view(input_shape), None, None, None
+
+
+triton_sigmoid_focal_loss = SigmoidFocalLoss.apply
+
+
+class SigmoidFocalLossReduced(torch.autograd.Function):
+    BLOCK_SIZE = 256
+    REDUCE_SIZE = 32
+
+    @staticmethod
+    def forward(ctx, inputs, targets, alpha=0.25, gamma=2):
+        n_elements = inputs.numel()
+        input_shape = inputs.shape
+        inputs = inputs.view(-1).contiguous()
+        targets = targets.view(-1).contiguous()
+        loss = torch.zeros(
+            SigmoidFocalLossReduced.REDUCE_SIZE,
+            device=inputs.device,
+            dtype=torch.float32,
+        )
+        grid = lambda meta: (triton.cdiv(n_elements, meta["BLOCK_SIZE"]),)
+        sigmoid_focal_loss_fwd_kernel_reduce[grid](
+            inputs,
+            targets,
+            loss,
+            alpha,
+            gamma,
+            n_elements,
+            SigmoidFocalLossReduced.BLOCK_SIZE,
+            SigmoidFocalLossReduced.REDUCE_SIZE,
+        )
+        ctx.save_for_backward(inputs.view(input_shape), targets.view(input_shape))
+        ctx.alpha = alpha
+        ctx.gamma = gamma
+        return loss.sum()
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        inputs, targets = ctx.saved_tensors
+        alpha = ctx.alpha
+        gamma = ctx.gamma
+        n_elements = inputs.numel()
+        input_shape = inputs.shape
+        grad_inputs = torch.empty(
+            inputs.shape, dtype=grad_output.dtype, device=grad_output.device
+        )
+        inputs_ptr = inputs.view(-1).contiguous()
+        targets_ptr = targets.reshape(-1).contiguous()
+        assert grad_output.numel() == 1
+        grid = lambda meta: (triton.cdiv(n_elements, meta["BLOCK_SIZE"]),)
+        sigmoid_focal_loss_bwd_kernel_reduce[grid](
+            inputs_ptr,
+            targets_ptr,
+            grad_inputs,
+            grad_output,
+            alpha,
+            gamma,
+            n_elements,
+            SigmoidFocalLossReduced.BLOCK_SIZE,
+        )
+        return grad_inputs.view(input_shape), None, None, None
+
+
+triton_sigmoid_focal_loss_reduce = SigmoidFocalLossReduced.apply

之前的代码版本/HuatuoGPT-Vision/MedSAM3/sam3/train/masks_ops.py

@@ -0,0 +1,272 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+"""Utilities for masks manipulation"""
+
+import numpy as np
+import pycocotools.mask as maskUtils
+import torch
+from pycocotools import mask as mask_util
+
+
+def instance_masks_to_semantic_masks(
+    instance_masks: torch.Tensor, num_instances: torch.Tensor
+) -> torch.Tensor:
+    """This function converts instance masks to semantic masks.
+    It accepts a collapsed batch of instances masks (ie all instance masks are concatenated in a single tensor) and
+    the number of instances in each image of the batch.
+    It returns a mask with the same spatial dimensions as the input instance masks, where for each batch element the
+    semantic mask is the union of all the instance masks in the batch element.
+
+    If for a given batch element there are no instances (ie num_instances[i]==0), the corresponding semantic mask will be a tensor of zeros.
+
+    Args:
+        instance_masks (torch.Tensor): A tensor of shape (N, H, W) where N is the number of instances in the batch.
+        num_instances (torch.Tensor): A tensor of shape (B,) where B is the batch size. It contains the number of instances
+            in each image of the batch.
+
+    Returns:
+        torch.Tensor: A tensor of shape (B, H, W) where B is the batch size and H, W are the spatial dimensions of the
+            input instance masks.
+    """
+
+    masks_per_query = torch.split(instance_masks, num_instances.tolist())
+
+    return torch.stack([torch.any(masks, dim=0) for masks in masks_per_query], dim=0)
+
+
+def mask_intersection(masks1, masks2, block_size=16):
+    """Compute the intersection of two sets of masks, without blowing the memory"""
+
+    assert masks1.shape[1:] == masks2.shape[1:]
+    assert masks1.dtype == torch.bool and masks2.dtype == torch.bool
+
+    result = torch.zeros(
+        masks1.shape[0], masks2.shape[0], device=masks1.device, dtype=torch.long
+    )
+    for i in range(0, masks1.shape[0], block_size):
+        for j in range(0, masks2.shape[0], block_size):
+            intersection = (
+                (masks1[i : i + block_size, None] * masks2[None, j : j + block_size])
+                .flatten(-2)
+                .sum(-1)
+            )
+            result[i : i + block_size, j : j + block_size] = intersection
+    return result
+
+
+def mask_iom(masks1, masks2):
+    """
+    Similar to IoU, except the denominator is the area of the smallest mask
+    """
+    assert masks1.shape[1:] == masks2.shape[1:]
+    assert masks1.dtype == torch.bool and masks2.dtype == torch.bool
+
+    # intersection = (masks1[:, None] * masks2[None]).flatten(-2).sum(-1)
+    intersection = mask_intersection(masks1, masks2)
+    area1 = masks1.flatten(-2).sum(-1)
+    area2 = masks2.flatten(-2).sum(-1)
+    min_area = torch.min(area1[:, None], area2[None, :])
+    return intersection / (min_area + 1e-8)
+
+
+def compute_boundary(seg):
+    """
+    Adapted from https://github.com/JonathonLuiten/TrackEval/blob/master/trackeval/metrics/j_and_f.py#L148
+    Return a 1pix wide boundary of the given mask
+    """
+    assert seg.ndim >= 2
+    e = torch.zeros_like(seg)
+    s = torch.zeros_like(seg)
+    se = torch.zeros_like(seg)
+
+    e[..., :, :-1] = seg[..., :, 1:]
+    s[..., :-1, :] = seg[..., 1:, :]
+    se[..., :-1, :-1] = seg[..., 1:, 1:]
+
+    b = seg ^ e | seg ^ s | seg ^ se
+    b[..., -1, :] = seg[..., -1, :] ^ e[..., -1, :]
+    b[..., :, -1] = seg[..., :, -1] ^ s[..., :, -1]
+    b[..., -1, -1] = 0
+    return b
+
+
+def dilation(mask, kernel_size):
+    """
+    Implements the dilation operation. If the input is on cpu, we call the cv2 version.
+    Otherwise, we implement it using a convolution
+
+    The kernel is assumed to be a square kernel
+
+    """
+
+    assert mask.ndim == 3
+    kernel_size = int(kernel_size)
+    assert (
+        kernel_size % 2 == 1
+    ), f"Dilation expects a odd kernel size, got {kernel_size}"
+
+    if mask.is_cuda:
+        m = mask.unsqueeze(1).to(torch.float16)
+        k = torch.ones(1, 1, kernel_size, 1, dtype=m.dtype, device=m.device)
+
+        result = torch.nn.functional.conv2d(m, k, padding="same")
+        result = torch.nn.functional.conv2d(result, k.transpose(-1, -2), padding="same")
+        return result.view_as(mask) > 0
+
+    all_masks = mask.view(-1, mask.size(-2), mask.size(-1)).numpy().astype(np.uint8)
+    kernel = np.ones((kernel_size, kernel_size), dtype=np.uint8)
+
+    import cv2
+
+    processed = [torch.from_numpy(cv2.dilate(m, kernel)) for m in all_masks]
+    return torch.stack(processed).view_as(mask).to(mask)
+
+
+def compute_F_measure(
+    gt_boundary_rle, gt_dilated_boundary_rle, dt_boundary_rle, dt_dilated_boundary_rle
+):
+    """Adapted from https://github.com/JonathonLuiten/TrackEval/blob/master/trackeval/metrics/j_and_f.py#L207
+
+    Assumes the boundary and dilated boundaries have already been computed and converted to RLE
+    """
+    gt_match = maskUtils.merge([gt_boundary_rle, dt_dilated_boundary_rle], True)
+    dt_match = maskUtils.merge([dt_boundary_rle, gt_dilated_boundary_rle], True)
+
+    n_dt = maskUtils.area(dt_boundary_rle)
+    n_gt = maskUtils.area(gt_boundary_rle)
+    # % Compute precision and recall
+    if n_dt == 0 and n_gt > 0:
+        precision = 1
+        recall = 0
+    elif n_dt > 0 and n_gt == 0:
+        precision = 0
+        recall = 1
+    elif n_dt == 0 and n_gt == 0:
+        precision = 1
+        recall = 1
+    else:
+        precision = maskUtils.area(dt_match) / float(n_dt)
+        recall = maskUtils.area(gt_match) / float(n_gt)
+
+    # Compute F measure
+    if precision + recall == 0:
+        f_val = 0
+    else:
+        f_val = 2 * precision * recall / (precision + recall)
+
+    return f_val
+
+
+@torch.no_grad()
+def rle_encode(orig_mask, return_areas=False):
+    """Encodes a collection of masks in RLE format
+
+    This function emulates the behavior of the COCO API's encode function, but
+    is executed partially on the GPU for faster execution.
+
+    Args:
+        mask (torch.Tensor): A mask of shape (N, H, W) with dtype=torch.bool
+        return_areas (bool): If True, add the areas of the masks as a part of
+            the RLE output dict under the "area" key. Default is False.
+
+    Returns:
+        str: The RLE encoded masks
+    """
+    assert orig_mask.ndim == 3, "Mask must be of shape (N, H, W)"
+    assert orig_mask.dtype == torch.bool, "Mask must have dtype=torch.bool"
+
+    if orig_mask.numel() == 0:
+        return []
+
+    # First, transpose the spatial dimensions.
+    # This is necessary because the COCO API uses Fortran order
+    mask = orig_mask.transpose(1, 2)
+
+    # Flatten the mask
+    flat_mask = mask.reshape(mask.shape[0], -1)
+    if return_areas:
+        mask_areas = flat_mask.sum(-1).tolist()
+    # Find the indices where the mask changes
+    differences = torch.ones(
+        mask.shape[0], flat_mask.shape[1] + 1, device=mask.device, dtype=torch.bool
+    )
+    differences[:, 1:-1] = flat_mask[:, :-1] != flat_mask[:, 1:]
+    differences[:, 0] = flat_mask[:, 0]
+    _, change_indices = torch.where(differences)
+
+    try:
+        boundaries = torch.cumsum(differences.sum(-1), 0).cpu()
+    except RuntimeError as _:
+        boundaries = torch.cumsum(differences.cpu().sum(-1), 0)
+
+    change_indices_clone = change_indices.clone()
+    # First pass computes the RLEs on GPU, in a flatten format
+    for i in range(mask.shape[0]):
+        # Get the change indices for this batch item
+        beg = 0 if i == 0 else boundaries[i - 1].item()
+        end = boundaries[i].item()
+        change_indices[beg + 1 : end] -= change_indices_clone[beg : end - 1]
+
+    # Now we can split the RLES of each batch item, and convert them to strings
+    # No more gpu at this point
+    change_indices = change_indices.tolist()
+
+    batch_rles = []
+    # Process each mask in the batch separately
+    for i in range(mask.shape[0]):
+        beg = 0 if i == 0 else boundaries[i - 1].item()
+        end = boundaries[i].item()
+        run_lengths = change_indices[beg:end]
+
+        uncompressed_rle = {"counts": run_lengths, "size": list(orig_mask.shape[1:])}
+        h, w = uncompressed_rle["size"]
+        rle = mask_util.frPyObjects(uncompressed_rle, h, w)
+        rle["counts"] = rle["counts"].decode("utf-8")
+        if return_areas:
+            rle["area"] = mask_areas[i]
+        batch_rles.append(rle)
+
+    return batch_rles
+
+
+def robust_rle_encode(masks):
+    """Encodes a collection of masks in RLE format. Uses the gpu version fist, falls back to the cpu version if it fails"""
+
+    assert masks.ndim == 3, "Mask must be of shape (N, H, W)"
+    assert masks.dtype == torch.bool, "Mask must have dtype=torch.bool"
+
+    try:
+        return rle_encode(masks)
+    except RuntimeError as _:
+        masks = masks.cpu().numpy()
+        rles = [
+            mask_util.encode(
+                np.array(mask[:, :, np.newaxis], dtype=np.uint8, order="F")
+            )[0]
+            for mask in masks
+        ]
+        for rle in rles:
+            rle["counts"] = rle["counts"].decode("utf-8")
+        return rles
+
+
+def ann_to_rle(segm, im_info):
+    """Convert annotation which can be polygons, uncompressed RLE to RLE.
+    Args:
+        ann (dict) : annotation object
+    Returns:
+        ann (rle)
+    """
+    h, w = im_info["height"], im_info["width"]
+    if isinstance(segm, list):
+        # polygon -- a single object might consist of multiple parts
+        # we merge all parts into one mask rle code
+        rles = mask_util.frPyObjects(segm, h, w)
+        rle = mask_util.merge(rles)
+    elif isinstance(segm["counts"], list):
+        # uncompressed RLE
+        rle = mask_util.frPyObjects(segm, h, w)
+    else:
+        # rle
+        rle = segm
+    return rle

之前的代码版本/HuatuoGPT-Vision/MedSAM3/sam3/train/matcher.py

@@ -0,0 +1,806 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+"""
+Modules to compute the matching cost and solve the corresponding LSAP.
+"""
+
+import numpy as np
+import torch
+
+from sam3.model.box_ops import box_cxcywh_to_xyxy, box_iou, generalized_box_iou
+from scipy.optimize import linear_sum_assignment
+from torch import nn
+
+
+def _do_matching(cost, repeats=1, return_tgt_indices=False, do_filtering=False):
+    if repeats > 1:
+        cost = np.tile(cost, (1, repeats))
+
+    i, j = linear_sum_assignment(cost)
+    if do_filtering:
+        # filter out invalid entries (i.e. those with cost > 1e8)
+        valid_thresh = 1e8
+        valid_ijs = [(ii, jj) for ii, jj in zip(i, j) if cost[ii, jj] < valid_thresh]
+        i, j = zip(*valid_ijs) if len(valid_ijs) > 0 else ([], [])
+        i, j = np.array(i, dtype=np.int64), np.array(j, dtype=np.int64)
+    if return_tgt_indices:
+        return i, j
+    order = np.argsort(j)
+    return i[order]
+
+
+class HungarianMatcher(nn.Module):
+    """This class computes an assignment between the targets and the predictions of the network
+
+    For efficiency reasons, the targets don't include the no_object. Because of this, in general,
+    there are more predictions than targets. In this case, we do a 1-to-1 matching of the best predictions,
+    while the others are un-matched (and thus treated as non-objects).
+    """
+
+    def __init__(
+        self,
+        cost_class: float = 1,
+        cost_bbox: float = 1,
+        cost_giou: float = 1,
+        focal_loss: bool = False,
+        focal_alpha: float = 0.25,
+        focal_gamma: float = 2,
+    ):
+        """Creates the matcher
+
+        Params:
+            cost_class: This is the relative weight of the classification error in the matching cost
+            cost_bbox: This is the relative weight of the L1 error of the bounding box coordinates in the matching cost
+            cost_giou: This is the relative weight of the giou loss of the bounding box in the matching cost
+        """
+        super().__init__()
+        self.cost_class = cost_class
+        self.cost_bbox = cost_bbox
+        self.cost_giou = cost_giou
+        self.norm = nn.Sigmoid() if focal_loss else nn.Softmax(-1)
+        assert (
+            cost_class != 0 or cost_bbox != 0 or cost_giou != 0
+        ), "all costs cant be 0"
+        self.focal_loss = focal_loss
+        self.focal_alpha = focal_alpha
+        self.focal_gamma = focal_gamma
+
+    @torch.no_grad()
+    def forward(self, outputs, batched_targets):
+        """Performs the matching
+
+        Params:
+            outputs: This is a dict that contains at least these entries:
+                 "pred_logits": Tensor of dim [batch_size, num_queries, num_classes] with the classification logits
+                 "pred_boxes": Tensor of dim [batch_size, num_queries, 4] with the predicted box coordinates
+
+            targets: This is a list of targets (len(targets) = batch_size), where each target is a dict containing:
+                 "labels": Tensor of dim [num_target_boxes] (where num_target_boxes is the number of ground-truth
+                           objects in the target) containing the class labels
+                 "boxes": Tensor of dim [num_target_boxes, 4] containing the target box coordinates
+
+        Returns:
+            A list of size batch_size, containing tuples of (index_i, index_j) where:
+                - index_i is the indices of the selected predictions (in order)
+                - index_j is the indices of the corresponding selected targets (in order)
+            For each batch element, it holds:
+                len(index_i) = len(index_j) = min(num_queries, num_target_boxes)
+        """
+        bs, num_queries = outputs["pred_logits"].shape[:2]
+
+        # We flatten to compute the cost matrices in a batch
+        out_prob = self.norm(
+            outputs["pred_logits"].flatten(0, 1)
+        )  # [batch_size * num_queries, num_classes]
+        out_bbox = outputs["pred_boxes"].flatten(0, 1)  # [batch_size * num_queries, 4]
+
+        # Also concat the target labels and boxes
+        tgt_bbox = batched_targets["boxes"]
+
+        if "positive_map" in batched_targets:
+            # In this case we have a multi-hot target
+            positive_map = batched_targets["positive_map"]
+            assert len(tgt_bbox) == len(positive_map)
+
+            if self.focal_loss:
+                positive_map = positive_map > 1e-4
+                alpha = self.focal_alpha
+                gamma = self.focal_gamma
+                neg_cost_class = (
+                    (1 - alpha) * (out_prob**gamma) * (-(1 - out_prob + 1e-8).log())
+                )
+                pos_cost_class = (
+                    alpha * ((1 - out_prob) ** gamma) * (-(out_prob + 1e-8).log())
+                )
+                cost_class = (
+                    (pos_cost_class - neg_cost_class).unsqueeze(1)
+                    * positive_map.unsqueeze(0)
+                ).sum(-1)
+            else:
+                # Compute the soft-cross entropy between the predicted token alignment and the GT one for each box
+                cost_class = -(out_prob.unsqueeze(1) * positive_map.unsqueeze(0)).sum(
+                    -1
+                )
+        else:
+            # In this case we are doing a "standard" cross entropy
+            tgt_ids = batched_targets["labels"]
+            assert len(tgt_bbox) == len(tgt_ids)
+
+            if self.focal_loss:
+                alpha = self.focal_alpha
+                gamma = self.focal_gamma
+                neg_cost_class = (
+                    (1 - alpha) * (out_prob**gamma) * (-(1 - out_prob + 1e-8).log())
+                )
+                pos_cost_class = (
+                    alpha * ((1 - out_prob) ** gamma) * (-(out_prob + 1e-8).log())
+                )
+                cost_class = pos_cost_class[:, tgt_ids] - neg_cost_class[:, tgt_ids]
+            else:
+                # Compute the classification cost. Contrary to the loss, we don't use the NLL,
+                # but approximate it in 1 - proba[target class].
+                # The 1 is a constant that doesn't change the matching, it can be omitted.
+                cost_class = -out_prob[:, tgt_ids]
+
+        # Compute the L1 cost between boxes
+        cost_bbox = torch.cdist(out_bbox, tgt_bbox, p=1)
+        assert cost_class.shape == cost_bbox.shape
+
+        # Compute the giou cost betwen boxes
+        cost_giou = -generalized_box_iou(
+            box_cxcywh_to_xyxy(out_bbox), box_cxcywh_to_xyxy(tgt_bbox)
+        )
+
+        # Final cost matrix
+        C = (
+            self.cost_bbox * cost_bbox
+            + self.cost_class * cost_class
+            + self.cost_giou * cost_giou
+        )
+        C = C.view(bs, num_queries, -1).cpu().numpy()
+
+        sizes = torch.cumsum(batched_targets["num_boxes"], -1)[:-1]
+        costs = [c[i] for i, c in enumerate(np.split(C, sizes.cpu().numpy(), axis=-1))]
+        indices = [_do_matching(c) for c in costs]
+        batch_idx = torch.as_tensor(
+            sum([[i] * len(src) for i, src in enumerate(indices)], []), dtype=torch.long
+        )
+        src_idx = torch.from_numpy(np.concatenate(indices)).long()
+        return batch_idx, src_idx
+
+
+class BinaryHungarianMatcher(nn.Module):
+    """This class computes an assignment between the targets and the predictions of the network
+
+    For efficiency reasons, the targets don't include the no_object. Because of this, in general,
+    there are more predictions than targets. In this case, we do a 1-to-1 matching of the best predictions,
+    while the others are un-matched (and thus treated as non-objects).
+    """
+
+    def __init__(
+        self,
+        cost_class: float = 1,
+        cost_bbox: float = 1,
+        cost_giou: float = 1,
+    ):
+        """Creates the matcher
+
+        Params:
+            cost_class: This is the relative weight of the classification error in the matching cost
+            cost_bbox: This is the relative weight of the L1 error of the bounding box coordinates in the matching cost
+            cost_giou: This is the relative weight of the giou loss of the bounding box in the matching cost
+        """
+        super().__init__()
+        self.cost_class = cost_class
+        self.cost_bbox = cost_bbox
+        self.cost_giou = cost_giou
+        self.norm = nn.Sigmoid()
+        assert (
+            cost_class != 0 or cost_bbox != 0 or cost_giou != 0
+        ), "all costs cant be 0"
+
+    @torch.no_grad()
+    def forward(self, outputs, batched_targets, repeats=0, repeat_batch=1):
+        """Performs the matching
+
+        Params:
+            outputs: This is a dict that contains at least these entries:
+                 "pred_logits": Tensor of dim [batch_size, num_queries, num_classes] with the classification logits
+                 "pred_boxes": Tensor of dim [batch_size, num_queries, 4] with the predicted box coordinates
+
+            targets: This is a list of targets (len(targets) = batch_size), where each target is a dict containing:
+                 "labels": Tensor of dim [num_target_boxes] (where num_target_boxes is the number of ground-truth
+                           objects in the target) containing the class labels
+                 "boxes": Tensor of dim [num_target_boxes, 4] containing the target box coordinates
+
+        Returns:
+            A list of size batch_size, containing tuples of (index_i, index_j) where:
+                - index_i is the indices of the selected predictions (in order)
+                - index_j is the indices of the corresponding selected targets (in order)
+            For each batch element, it holds:
+                len(index_i) = len(index_j) = min(num_queries, num_target_boxes)
+        """
+        if repeat_batch != 1:
+            raise NotImplementedError("please use BinaryHungarianMatcherV2 instead")
+
+        bs, num_queries = outputs["pred_logits"].shape[:2]
+
+        # We flatten to compute the cost matrices in a batch
+        out_prob = self.norm(outputs["pred_logits"].flatten(0, 1)).squeeze(
+            -1
+        )  # [batch_size * num_queries]
+        out_bbox = outputs["pred_boxes"].flatten(0, 1)  # [batch_size * num_queries, 4]
+
+        # Also concat the target labels and boxes
+        tgt_bbox = batched_targets["boxes"]
+
+        # Compute the L1 cost between boxes
+        cost_bbox = torch.cdist(out_bbox, tgt_bbox, p=1)
+
+        cost_class = -out_prob.unsqueeze(-1).expand_as(cost_bbox)
+
+        assert cost_class.shape == cost_bbox.shape
+
+        # Compute the giou cost betwen boxes
+        cost_giou = -generalized_box_iou(
+            box_cxcywh_to_xyxy(out_bbox), box_cxcywh_to_xyxy(tgt_bbox)
+        )
+
+        # Final cost matrix
+        C = (
+            self.cost_bbox * cost_bbox
+            + self.cost_class * cost_class
+            + self.cost_giou * cost_giou
+        )
+        C = C.view(bs, num_queries, -1).cpu().numpy()
+
+        sizes = torch.cumsum(batched_targets["num_boxes"], -1)[:-1]
+        costs = [c[i] for i, c in enumerate(np.split(C, sizes.cpu().numpy(), axis=-1))]
+        return_tgt_indices = False
+        for c in costs:
+            n_targ = c.shape[1]
+            if repeats > 1:
+                n_targ *= repeats
+            if c.shape[0] < n_targ:
+                return_tgt_indices = True
+                break
+        if return_tgt_indices:
+            indices, tgt_indices = zip(
+                *(
+                    _do_matching(
+                        c, repeats=repeats, return_tgt_indices=return_tgt_indices
+                    )
+                    for c in costs
+                )
+            )
+            tgt_indices = list(tgt_indices)
+            for i in range(1, len(tgt_indices)):
+                tgt_indices[i] += sizes[i - 1].item()
+            tgt_idx = torch.from_numpy(np.concatenate(tgt_indices)).long()
+        else:
+            indices = [_do_matching(c, repeats=repeats) for c in costs]
+            tgt_idx = None
+
+        batch_idx = torch.as_tensor(
+            sum([[i] * len(src) for i, src in enumerate(indices)], []), dtype=torch.long
+        )
+        src_idx = torch.from_numpy(np.concatenate(indices)).long()
+        return batch_idx, src_idx, tgt_idx
+
+
+class BinaryFocalHungarianMatcher(nn.Module):
+    """This class computes an assignment between the targets and the predictions of the network
+
+    For efficiency reasons, the targets don't include the no_object. Because of this, in general,
+    there are more predictions than targets. In this case, we do a 1-to-1 matching of the best predictions,
+    while the others are un-matched (and thus treated as non-objects).
+    """
+
+    def __init__(
+        self,
+        cost_class: float = 1,
+        cost_bbox: float = 1,
+        cost_giou: float = 1,
+        alpha: float = 0.25,
+        gamma: float = 2.0,
+        stable: bool = False,
+    ):
+        """Creates the matcher
+
+        Params:
+            cost_class: This is the relative weight of the classification error in the matching cost
+            cost_bbox: This is the relative weight of the L1 error of the bounding box coordinates in the matching cost
+            cost_giou: This is the relative weight of the giou loss of the bounding box in the matching cost
+        """
+        super().__init__()
+        self.cost_class = cost_class
+        self.cost_bbox = cost_bbox
+        self.cost_giou = cost_giou
+        self.norm = nn.Sigmoid()
+        self.alpha = alpha
+        self.gamma = gamma
+        self.stable = stable
+        assert (
+            cost_class != 0 or cost_bbox != 0 or cost_giou != 0
+        ), "all costs cant be 0"
+
+    @torch.no_grad()
+    def forward(self, outputs, batched_targets, repeats=1, repeat_batch=1):
+        """Performs the matching
+
+        Params:
+            outputs: This is a dict that contains at least these entries:
+                 "pred_logits": Tensor of dim [batch_size, num_queries, num_classes] with the classification logits
+                 "pred_boxes": Tensor of dim [batch_size, num_queries, 4] with the predicted box coordinates
+
+            targets: This is a list of targets (len(targets) = batch_size), where each target is a dict containing:
+                 "labels": Tensor of dim [num_target_boxes] (where num_target_boxes is the number of ground-truth
+                           objects in the target) containing the class labels
+                 "boxes": Tensor of dim [num_target_boxes, 4] containing the target box coordinates
+
+        Returns:
+            A list of size batch_size, containing tuples of (index_i, index_j) where:
+                - index_i is the indices of the selected predictions (in order)
+                - index_j is the indices of the corresponding selected targets (in order)
+            For each batch element, it holds:
+                len(index_i) = len(index_j) = min(num_queries, num_target_boxes)
+        """
+        if repeat_batch != 1:
+            raise NotImplementedError("please use BinaryHungarianMatcherV2 instead")
+
+        bs, num_queries = outputs["pred_logits"].shape[:2]
+
+        # We flatten to compute the cost matrices in a batch
+        out_score = outputs["pred_logits"].flatten(0, 1).squeeze(-1)
+        out_prob = self.norm(out_score)  # [batch_size * num_queries]
+        out_bbox = outputs["pred_boxes"].flatten(0, 1)  # [batch_size * num_queries, 4]
+
+        # Also concat the target labels and boxes
+        tgt_bbox = batched_targets["boxes"]
+
+        # Compute the L1 cost between boxes
+        cost_bbox = torch.cdist(out_bbox, tgt_bbox, p=1)
+
+        # Compute the giou cost betwen boxes
+        cost_giou = -generalized_box_iou(
+            box_cxcywh_to_xyxy(out_bbox), box_cxcywh_to_xyxy(tgt_bbox)
+        )
+
+        # cost_class = -out_prob.unsqueeze(-1).expand_as(cost_bbox)
+        if self.stable:
+            rescaled_giou = (-cost_giou + 1) / 2
+            out_prob = out_prob.unsqueeze(-1).expand_as(cost_bbox) * rescaled_giou
+            cost_class = -self.alpha * (1 - out_prob) ** self.gamma * torch.log(
+                out_prob
+            ) + (1 - self.alpha) * out_prob**self.gamma * torch.log(1 - out_prob)
+        else:
+            # directly computing log sigmoid (more numerically stable)
+            log_out_prob = torch.nn.functional.logsigmoid(out_score)
+            log_one_minus_out_prob = torch.nn.functional.logsigmoid(-out_score)
+            cost_class = (
+                -self.alpha * (1 - out_prob) ** self.gamma * log_out_prob
+                + (1 - self.alpha) * out_prob**self.gamma * log_one_minus_out_prob
+            )
+        if not self.stable:
+            cost_class = cost_class.unsqueeze(-1).expand_as(cost_bbox)
+
+        assert cost_class.shape == cost_bbox.shape
+
+        # Final cost matrix
+        C = (
+            self.cost_bbox * cost_bbox
+            + self.cost_class * cost_class
+            + self.cost_giou * cost_giou
+        )
+        C = C.view(bs, num_queries, -1).cpu().numpy()
+
+        sizes = torch.cumsum(batched_targets["num_boxes"], -1)[:-1]
+        costs = [c[i] for i, c in enumerate(np.split(C, sizes.cpu().numpy(), axis=-1))]
+        return_tgt_indices = False
+        for c in costs:
+            n_targ = c.shape[1]
+            if repeats > 1:
+                n_targ *= repeats
+            if c.shape[0] < n_targ:
+                return_tgt_indices = True
+                break
+        if return_tgt_indices:
+            indices, tgt_indices = zip(
+                *(
+                    _do_matching(
+                        c, repeats=repeats, return_tgt_indices=return_tgt_indices
+                    )
+                    for c in costs
+                )
+            )
+            tgt_indices = list(tgt_indices)
+            for i in range(1, len(tgt_indices)):
+                tgt_indices[i] += sizes[i - 1].item()
+            tgt_idx = torch.from_numpy(np.concatenate(tgt_indices)).long()
+        else:
+            indices = [_do_matching(c, repeats=repeats) for c in costs]
+            tgt_idx = None
+
+        batch_idx = torch.as_tensor(
+            sum([[i] * len(src) for i, src in enumerate(indices)], []), dtype=torch.long
+        )
+        src_idx = torch.from_numpy(np.concatenate(indices)).long()
+        return batch_idx, src_idx, tgt_idx
+
+
+class BinaryHungarianMatcherV2(nn.Module):
+    """
+    This class computes an assignment between the targets and the predictions
+    of the network
+
+    For efficiency reasons, the targets don't include the no_object. Because of
+    this, in general, there are more predictions than targets. In this case, we
+    do a 1-to-1 matching of the best predictions, while the others are
+    un-matched (and thus treated as non-objects).
+
+    This is a more efficient implementation of BinaryHungarianMatcher.
+    """
+
+    def __init__(
+        self,
+        cost_class: float = 1,
+        cost_bbox: float = 1,
+        cost_giou: float = 1,
+        focal: bool = False,
+        alpha: float = 0.25,
+        gamma: float = 2.0,
+        stable: bool = False,
+        remove_samples_with_0_gt: bool = True,
+    ):
+        """
+        Creates the matcher
+
+        Params:
+        - cost_class: Relative weight of the classification error in the
+          matching cost
+        - cost_bbox: Relative weight of the L1 error of the bounding box
+          coordinates in the matching cost
+        - cost_giou: This is the relative weight of the giou loss of the
+          bounding box in the matching cost
+        """
+        super().__init__()
+        self.cost_class = cost_class
+        self.cost_bbox = cost_bbox
+        self.cost_giou = cost_giou
+        self.norm = nn.Sigmoid()
+        assert (
+            cost_class != 0 or cost_bbox != 0 or cost_giou != 0
+        ), "all costs cant be 0"
+        self.focal = focal
+        if focal:
+            self.alpha = alpha
+            self.gamma = gamma
+            self.stable = stable
+        self.remove_samples_with_0_gt = remove_samples_with_0_gt
+
+    @torch.no_grad()
+    def forward(
+        self,
+        outputs,
+        batched_targets,
+        repeats=1,
+        repeat_batch=1,
+        out_is_valid=None,
+        target_is_valid_padded=None,
+    ):
+        """
+        Performs the matching. The inputs and outputs are the same as
+        BinaryHungarianMatcher.forward, except for the optional cached_padded
+        flag and the optional "_boxes_padded" entry of batched_targets.
+
+        Inputs:
+        - outputs: A dict with the following keys:
+            - "pred_logits": Tensor of shape (batch_size, num_queries, 1) with
+               classification logits
+            - "pred_boxes": Tensor of shape (batch_size, num_queries, 4) with
+               predicted box coordinates in cxcywh format.
+        - batched_targets: A dict of targets. There may be a variable number of
+          targets per batch entry; suppose that there are T_b targets for batch
+          entry 0 <= b < batch_size. It should have the following keys:
+          - "boxes": Tensor of shape (sum_b T_b, 4) giving ground-truth boxes
+             in cxcywh format for all batch entries packed into a single tensor
+          - "num_boxes": int64 Tensor of shape (batch_size,) giving the number
+             of ground-truth boxes per batch entry: num_boxes[b] = T_b
+          - "_boxes_padded": Tensor of shape (batch_size, max_b T_b, 4) giving
+            a padded version of ground-truth boxes. If this is not present then
+            it will be computed from batched_targets["boxes"] instead, but
+            caching it here can improve performance for repeated calls with the
+            same targets.
+        - out_is_valid: If not None, it should be a boolean tensor of shape
+          (batch_size, num_queries) indicating which predictions are valid.
+          Invalid predictions are ignored during matching and won't appear in
+          the output indices.
+        - target_is_valid_padded: If not None, it should be a boolean tensor of
+          shape (batch_size, max_num_gt_boxes) in padded format indicating
+          which GT boxes are valid. Invalid GT boxes are ignored during matching
+          and won't appear in the output indices.
+
+        Returns:
+            A list of size batch_size, containing tuples of (idx_i, idx_j):
+                - idx_i is the indices of the selected predictions (in order)
+                - idx_j is the indices of the corresponding selected targets
+                  (in order)
+            For each batch element, it holds:
+                len(index_i) = len(index_j)
+                             = min(num_queries, num_target_boxes)
+        """
+        _, num_queries = outputs["pred_logits"].shape[:2]
+
+        out_score = outputs["pred_logits"].squeeze(-1)  # (B, Q)
+        out_bbox = outputs["pred_boxes"]  # (B, Q, 4))
+
+        device = out_score.device
+
+        num_boxes = batched_targets["num_boxes"].cpu()
+        # Get a padded version of target boxes (as precomputed in the collator).
+        # It should work for both repeat==1 (o2o) and repeat>1 (o2m) matching.
+        tgt_bbox = batched_targets["boxes_padded"]
+        if self.remove_samples_with_0_gt:
+            # keep only samples w/ at least 1 GT box in targets (num_boxes and tgt_bbox)
+            batch_keep = num_boxes > 0
+            num_boxes = num_boxes[batch_keep]
+            tgt_bbox = tgt_bbox[batch_keep]
+            if target_is_valid_padded is not None:
+                target_is_valid_padded = target_is_valid_padded[batch_keep]
+        # Repeat the targets (for the case of batched aux outputs in the matcher)
+        if repeat_batch > 1:
+            # In this case, out_prob and out_bbox will be a concatenation of
+            # both final and auxiliary outputs, so we also repeat the targets
+            num_boxes = num_boxes.repeat(repeat_batch)
+            tgt_bbox = tgt_bbox.repeat(repeat_batch, 1, 1)
+            if target_is_valid_padded is not None:
+                target_is_valid_padded = target_is_valid_padded.repeat(repeat_batch, 1)
+
+        # keep only samples w/ at least 1 GT box in outputs
+        if self.remove_samples_with_0_gt:
+            if repeat_batch > 1:
+                batch_keep = batch_keep.repeat(repeat_batch)
+            out_score = out_score[batch_keep]
+            out_bbox = out_bbox[batch_keep]
+            if out_is_valid is not None:
+                out_is_valid = out_is_valid[batch_keep]
+        assert out_bbox.shape[0] == tgt_bbox.shape[0]
+        assert out_bbox.shape[0] == num_boxes.shape[0]
+
+        # Compute the L1 cost between boxes
+        cost_bbox = torch.cdist(out_bbox, tgt_bbox, p=1)
+
+        # Compute the giou cost betwen boxes
+        cost_giou = -generalized_box_iou(
+            box_cxcywh_to_xyxy(out_bbox), box_cxcywh_to_xyxy(tgt_bbox)
+        )
+
+        out_prob = self.norm(out_score)
+        if not self.focal:
+            cost_class = -out_prob.unsqueeze(-1).expand_as(cost_bbox)
+        else:
+            if self.stable:
+                rescaled_giou = (-cost_giou + 1) / 2
+                out_prob = out_prob.unsqueeze(-1).expand_as(cost_bbox) * rescaled_giou
+                cost_class = -self.alpha * (1 - out_prob) ** self.gamma * torch.log(
+                    out_prob
+                ) + (1 - self.alpha) * out_prob**self.gamma * torch.log(1 - out_prob)
+            else:
+                # directly computing log sigmoid (more numerically stable)
+                log_out_prob = torch.nn.functional.logsigmoid(out_score)
+                log_one_minus_out_prob = torch.nn.functional.logsigmoid(-out_score)
+                cost_class = (
+                    -self.alpha * (1 - out_prob) ** self.gamma * log_out_prob
+                    + (1 - self.alpha) * out_prob**self.gamma * log_one_minus_out_prob
+                )
+            if not self.stable:
+                cost_class = cost_class.unsqueeze(-1).expand_as(cost_bbox)
+
+        assert cost_class.shape == cost_bbox.shape
+
+        # Final cost matrix
+        C = (
+            self.cost_bbox * cost_bbox
+            + self.cost_class * cost_class
+            + self.cost_giou * cost_giou
+        )
+        # assign a very high cost (1e9) to invalid outputs and targets, so that we can
+        # filter them out (in `_do_matching`) from bipartite matching results
+        do_filtering = out_is_valid is not None or target_is_valid_padded is not None
+        if out_is_valid is not None:
+            C = torch.where(out_is_valid[:, :, None], C, 1e9)
+        if target_is_valid_padded is not None:
+            C = torch.where(target_is_valid_padded[:, None, :], C, 1e9)
+        C = C.cpu().numpy()
+        costs = [C[i, :, :s] for i, s in enumerate(num_boxes.tolist())]
+        return_tgt_indices = (
+            do_filtering or torch.any(num_queries < num_boxes * max(repeats, 1)).item()
+        )
+        if len(costs) == 0:
+            # We have size 0 in the batch dimension, so we return empty matching indices
+            # (note that this can happen due to `remove_samples_with_0_gt=True` even if
+            # the original input batch size is not 0, when all queries have empty GTs).
+            indices = []
+            tgt_idx = torch.zeros(0).long().to(device) if return_tgt_indices else None
+        elif return_tgt_indices:
+            indices, tgt_indices = zip(
+                *(
+                    _do_matching(
+                        c,
+                        repeats=repeats,
+                        return_tgt_indices=return_tgt_indices,
+                        do_filtering=do_filtering,
+                    )
+                    for c in costs
+                )
+            )
+            tgt_indices = list(tgt_indices)
+            sizes = torch.cumsum(num_boxes, -1)[:-1]
+            for i in range(1, len(tgt_indices)):
+                tgt_indices[i] += sizes[i - 1].item()
+            tgt_idx = torch.from_numpy(np.concatenate(tgt_indices)).long().to(device)
+        else:
+            indices = [
+                _do_matching(c, repeats=repeats, do_filtering=do_filtering)
+                for c in costs
+            ]
+            tgt_idx = None
+
+        if self.remove_samples_with_0_gt:
+            kept_inds = batch_keep.nonzero().squeeze(1)
+            batch_idx = torch.as_tensor(
+                sum([[kept_inds[i]] * len(src) for i, src in enumerate(indices)], []),
+                dtype=torch.long,
+                device=device,
+            )
+        else:
+            batch_idx = torch.as_tensor(
+                sum([[i] * len(src) for i, src in enumerate(indices)], []),
+                dtype=torch.long,
+                device=device,
+            )
+
+        # indices could be an empty list (since we remove samples w/ 0 GT boxes)
+        if len(indices) > 0:
+            src_idx = torch.from_numpy(np.concatenate(indices)).long().to(device)
+        else:
+            src_idx = torch.empty(0, dtype=torch.long, device=device)
+        return batch_idx, src_idx, tgt_idx
+
+
+class BinaryOneToManyMatcher(nn.Module):
+    """
+    This class computes a greedy assignment between the targets and the predictions of the network.
+    In this formulation, several predictions can be assigned to each target, but each prediction can be assigned to
+    at most one target.
+
+    See DAC-Detr for details
+    """
+
+    def __init__(
+        self,
+        alpha: float = 0.3,
+        threshold: float = 0.4,
+        topk: int = 6,
+    ):
+        """
+        Creates the matcher
+
+        Params:
+                alpha: relative balancing between classification and localization
+                threshold: threshold used to select positive predictions
+                topk: number of top scoring predictions to consider
+        """
+        super().__init__()
+        self.norm = nn.Sigmoid()
+        self.alpha = alpha
+        self.threshold = threshold
+        self.topk = topk
+
+    @torch.no_grad()
+    def forward(
+        self,
+        outputs,
+        batched_targets,
+        repeats=1,
+        repeat_batch=1,
+        out_is_valid=None,
+        target_is_valid_padded=None,
+    ):
+        """
+        Performs the matching. The inputs and outputs are the same as
+        BinaryHungarianMatcher.forward
+
+        Inputs:
+        - outputs: A dict with the following keys:
+            - "pred_logits": Tensor of shape (batch_size, num_queries, 1) with
+               classification logits
+            - "pred_boxes": Tensor of shape (batch_size, num_queries, 4) with
+               predicted box coordinates in cxcywh format.
+        - batched_targets: A dict of targets. There may be a variable number of
+          targets per batch entry; suppose that there are T_b targets for batch
+          entry 0 <= b < batch_size. It should have the following keys:
+          - "num_boxes": int64 Tensor of shape (batch_size,) giving the number
+             of ground-truth boxes per batch entry: num_boxes[b] = T_b
+          - "_boxes_padded": Tensor of shape (batch_size, max_b T_b, 4) giving
+            a padded version of ground-truth boxes. If this is not present then
+            it will be computed from batched_targets["boxes"] instead, but
+            caching it here can improve performance for repeated calls with the
+            same targets.
+        - out_is_valid: If not None, it should be a boolean tensor of shape
+          (batch_size, num_queries) indicating which predictions are valid.
+          Invalid predictions are ignored during matching and won't appear in
+          the output indices.
+        - target_is_valid_padded: If not None, it should be a boolean tensor of
+          shape (batch_size, max_num_gt_boxes) in padded format indicating
+          which GT boxes are valid. Invalid GT boxes are ignored during matching
+          and won't appear in the output indices.
+        Returns:
+            A list of size batch_size, containing tuples of (idx_i, idx_j):
+                - idx_i is the indices of the selected predictions (in order)
+                - idx_j is the indices of the corresponding selected targets
+                  (in order)
+            For each batch element, it holds:
+                len(index_i) = len(index_j)
+                             = min(num_queries, num_target_boxes)
+        """
+        assert repeats <= 1 and repeat_batch <= 1
+        bs, num_queries = outputs["pred_logits"].shape[:2]
+
+        out_prob = self.norm(outputs["pred_logits"]).squeeze(-1)  # (B, Q)
+        out_bbox = outputs["pred_boxes"]  # (B, Q, 4))
+
+        num_boxes = batched_targets["num_boxes"]
+
+        # Get a padded version of target boxes (as precomputed in the collator).
+        tgt_bbox = batched_targets["boxes_padded"]
+        assert len(tgt_bbox) == bs
+        num_targets = tgt_bbox.shape[1]
+        if num_targets == 0:
+            return (
+                torch.empty(0, dtype=torch.long, device=out_prob.device),
+                torch.empty(0, dtype=torch.long, device=out_prob.device),
+                torch.empty(0, dtype=torch.long, device=out_prob.device),
+            )
+
+        iou, _ = box_iou(box_cxcywh_to_xyxy(out_bbox), box_cxcywh_to_xyxy(tgt_bbox))
+
+        assert iou.shape == (bs, num_queries, num_targets)
+
+        # Final cost matrix (higher is better in `C`; this is unlike the case
+        # of BinaryHungarianMatcherV2 above where lower is better in its `C`)
+        C = self.alpha * out_prob.unsqueeze(-1) + (1 - self.alpha) * iou
+        if out_is_valid is not None:
+            C = torch.where(out_is_valid[:, :, None], C, -1e9)
+        if target_is_valid_padded is not None:
+            C = torch.where(target_is_valid_padded[:, None, :], C, -1e9)
+
+        # Selecting topk predictions
+        matches = C > torch.quantile(
+            C, 1 - self.topk / num_queries, dim=1, keepdim=True
+        )
+
+        # Selecting predictions above threshold
+        matches = matches & (C > self.threshold)
+        if out_is_valid is not None:
+            matches = matches & out_is_valid[:, :, None]
+        if target_is_valid_padded is not None:
+            matches = matches & target_is_valid_padded[:, None, :]
+
+        # Removing padding
+        matches = matches & (
+            torch.arange(0, num_targets, device=num_boxes.device)[None]
+            < num_boxes[:, None]
+        ).unsqueeze(1)
+
+        batch_idx, src_idx, tgt_idx = torch.nonzero(matches, as_tuple=True)
+
+        cum_num_boxes = torch.cat(
+            [
+                torch.zeros(1, dtype=num_boxes.dtype, device=num_boxes.device),
+                num_boxes.cumsum(-1)[:-1],
+            ]
+        )
+        tgt_idx += cum_num_boxes[batch_idx]
+
+        return batch_idx, src_idx, tgt_idx

之前的代码版本/HuatuoGPT-Vision/MedSAM3/sam3/train/nms_helper.py

@@ -0,0 +1,306 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+import warnings
+from typing import Dict, List
+
+import numpy as np
+
+# Check if Numba is available
+HAS_NUMBA = False
+try:
+    import numba as nb
+
+    HAS_NUMBA = True
+except ImportError:
+    warnings.warn(
+        "Numba not found. Using slower pure Python implementations.", UserWarning
+    )
+
+
+# -------------------- Helper Functions --------------------
+def is_zero_box(bbox: list) -> bool:
+    """Check if bounding box is invalid"""
+    if bbox is None:
+        return True
+    return all(x <= 0 for x in bbox[:4]) or len(bbox) < 4
+
+
+def convert_bbox_format(bbox: list) -> List[float]:
+    """Convert bbox from (x,y,w,h) to (x1,y1,x2,y2)"""
+    x, y, w, h = bbox
+    return [x, y, x + w, y + h]
+
+
+# -------------------- Track-level NMS --------------------
+def process_track_level_nms(video_groups: Dict, nms_threshold: float) -> Dict:
+    """Apply track-level NMS to all videos"""
+    for video_id, tracks in video_groups.items():
+        track_detections = []
+
+        # Process tracks
+        for track_idx, track in enumerate(tracks):
+            if not track["bboxes"]:
+                continue
+
+            converted_bboxes = []
+            valid_frames = []
+            for bbox in track["bboxes"]:
+                if bbox and not is_zero_box(bbox):
+                    converted_bboxes.append(convert_bbox_format(bbox))
+                    valid_frames.append(True)
+                else:
+                    converted_bboxes.append([np.nan] * 4)
+                    valid_frames.append(False)
+
+            if any(valid_frames):
+                track_detections.append(
+                    {
+                        "track_idx": track_idx,
+                        "bboxes": np.array(converted_bboxes, dtype=np.float32),
+                        "score": track["score"],
+                    }
+                )
+
+        # Apply NMS
+        if track_detections:
+            scores = np.array([d["score"] for d in track_detections], dtype=np.float32)
+            keep = apply_track_nms(track_detections, scores, nms_threshold)
+
+            # Suppress non-kept tracks
+            for idx, track in enumerate(track_detections):
+                if idx not in keep:
+                    tracks[track["track_idx"]]["bboxes"] = [None] * len(track["bboxes"])
+
+    return video_groups
+
+
+# -------------------- Frame-level NMS --------------------
+def process_frame_level_nms(video_groups: Dict, nms_threshold: float) -> Dict:
+    """Apply frame-level NMS to all videos"""
+    for video_id, tracks in video_groups.items():
+        if not tracks:
+            continue
+
+        num_frames = len(tracks[0]["bboxes"])
+
+        for frame_idx in range(num_frames):
+            frame_detections = []
+
+            # Collect valid detections
+            for track_idx, track in enumerate(tracks):
+                bbox = track["bboxes"][frame_idx]
+                if bbox and not is_zero_box(bbox):
+                    frame_detections.append(
+                        {
+                            "track_idx": track_idx,
+                            "bbox": np.array(
+                                convert_bbox_format(bbox), dtype=np.float32
+                            ),
+                            "score": track["score"],
+                        }
+                    )
+
+            # Apply NMS
+            if frame_detections:
+                bboxes = np.stack([d["bbox"] for d in frame_detections])
+                scores = np.array(
+                    [d["score"] for d in frame_detections], dtype=np.float32
+                )
+                keep = apply_frame_nms(bboxes, scores, nms_threshold)
+
+                # Suppress non-kept detections
+                for i, d in enumerate(frame_detections):
+                    if i not in keep:
+                        tracks[d["track_idx"]]["bboxes"][frame_idx] = None
+
+    return video_groups
+
+
+# Track-level NMS helpers ------------------------------------------------------
+def compute_track_iou_matrix(
+    bboxes_stacked: np.ndarray, valid_masks: np.ndarray, areas: np.ndarray
+) -> np.ndarray:
+    """IoU matrix computation for track-level NMS with fallback to pure Python"""
+    num_tracks = bboxes_stacked.shape[0]
+    iou_matrix = np.zeros((num_tracks, num_tracks), dtype=np.float32)
+    if HAS_NUMBA:
+        iou_matrix = _compute_track_iou_matrix_numba(bboxes_stacked, valid_masks, areas)
+    else:
+        # Pure Python implementation
+        for i in range(num_tracks):
+            for j in range(i + 1, num_tracks):
+                valid_ij = valid_masks[i] & valid_masks[j]
+                if not valid_ij.any():
+                    continue
+                bboxes_i = bboxes_stacked[i, valid_ij]
+                bboxes_j = bboxes_stacked[j, valid_ij]
+                area_i = areas[i, valid_ij]
+                area_j = areas[j, valid_ij]
+                inter_total = 0.0
+                union_total = 0.0
+                for k in range(bboxes_i.shape[0]):
+                    x1 = max(bboxes_i[k, 0], bboxes_j[k, 0])
+                    y1 = max(bboxes_i[k, 1], bboxes_j[k, 1])
+                    x2 = min(bboxes_i[k, 2], bboxes_j[k, 2])
+                    y2 = min(bboxes_i[k, 3], bboxes_j[k, 3])
+                    inter = max(0, x2 - x1) * max(0, y2 - y1)
+                    union = area_i[k] + area_j[k] - inter
+                    inter_total += inter
+                    union_total += union
+                if union_total > 0:
+                    iou_matrix[i, j] = inter_total / union_total
+                    iou_matrix[j, i] = iou_matrix[i, j]
+    return iou_matrix
+
+
+if HAS_NUMBA:
+
+    @nb.jit(nopython=True, parallel=True)
+    def _compute_track_iou_matrix_numba(bboxes_stacked, valid_masks, areas):
+        """Numba-optimized IoU matrix computation for track-level NMS"""
+        num_tracks = bboxes_stacked.shape[0]
+        iou_matrix = np.zeros((num_tracks, num_tracks), dtype=np.float32)
+        for i in nb.prange(num_tracks):
+            for j in range(i + 1, num_tracks):
+                valid_ij = valid_masks[i] & valid_masks[j]
+                if not valid_ij.any():
+                    continue
+                bboxes_i = bboxes_stacked[i, valid_ij]
+                bboxes_j = bboxes_stacked[j, valid_ij]
+                area_i = areas[i, valid_ij]
+                area_j = areas[j, valid_ij]
+                inter_total = 0.0
+                union_total = 0.0
+                for k in range(bboxes_i.shape[0]):
+                    x1 = max(bboxes_i[k, 0], bboxes_j[k, 0])
+                    y1 = max(bboxes_i[k, 1], bboxes_j[k, 1])
+                    x2 = min(bboxes_i[k, 2], bboxes_j[k, 2])
+                    y2 = min(bboxes_i[k, 3], bboxes_j[k, 3])
+                    inter = max(0, x2 - x1) * max(0, y2 - y1)
+                    union = area_i[k] + area_j[k] - inter
+                    inter_total += inter
+                    union_total += union
+                if union_total > 0:
+                    iou_matrix[i, j] = inter_total / union_total
+                    iou_matrix[j, i] = iou_matrix[i, j]
+        return iou_matrix
+
+
+def apply_track_nms(
+    track_detections: List[dict], scores: np.ndarray, nms_threshold: float
+) -> List[int]:
+    """Vectorized track-level NMS implementation"""
+    if not track_detections:
+        return []
+    bboxes_stacked = np.stack([d["bboxes"] for d in track_detections], axis=0)
+    valid_masks = ~np.isnan(bboxes_stacked).any(axis=2)
+    areas = (bboxes_stacked[:, :, 2] - bboxes_stacked[:, :, 0]) * (
+        bboxes_stacked[:, :, 3] - bboxes_stacked[:, :, 1]
+    )
+    areas[~valid_masks] = 0
+    iou_matrix = compute_track_iou_matrix(bboxes_stacked, valid_masks, areas)
+    keep = []
+    order = np.argsort(-scores)
+    suppress = np.zeros(len(track_detections), dtype=bool)
+    for i in range(len(order)):
+        if not suppress[order[i]]:
+            keep.append(order[i])
+            suppress[order[i:]] = suppress[order[i:]] | (
+                iou_matrix[order[i], order[i:]] >= nms_threshold
+            )
+    return keep
+
+
+# Frame-level NMS helpers ------------------------------------------------------
+def compute_frame_ious(bbox: np.ndarray, bboxes: np.ndarray) -> np.ndarray:
+    """IoU computation for frame-level NMS with fallback to pure Python"""
+    if HAS_NUMBA:
+        return _compute_frame_ious_numba(bbox, bboxes)
+    else:
+        # Pure Python implementation
+        ious = np.zeros(len(bboxes), dtype=np.float32)
+        for i in range(len(bboxes)):
+            x1 = max(bbox[0], bboxes[i, 0])
+            y1 = max(bbox[1], bboxes[i, 1])
+            x2 = min(bbox[2], bboxes[i, 2])
+            y2 = min(bbox[3], bboxes[i, 3])
+
+            inter = max(0, x2 - x1) * max(0, y2 - y1)
+            area1 = (bbox[2] - bbox[0]) * (bbox[3] - bbox[1])
+            area2 = (bboxes[i, 2] - bboxes[i, 0]) * (bboxes[i, 3] - bboxes[i, 1])
+            union = area1 + area2 - inter
+
+            ious[i] = inter / union if union > 0 else 0.0
+        return ious
+
+
+if HAS_NUMBA:
+
+    @nb.jit(nopython=True, parallel=True)
+    def _compute_frame_ious_numba(bbox, bboxes):
+        """Numba-optimized IoU computation"""
+        ious = np.zeros(len(bboxes), dtype=np.float32)
+        for i in nb.prange(len(bboxes)):
+            x1 = max(bbox[0], bboxes[i, 0])
+            y1 = max(bbox[1], bboxes[i, 1])
+            x2 = min(bbox[2], bboxes[i, 2])
+            y2 = min(bbox[3], bboxes[i, 3])
+
+            inter = max(0, x2 - x1) * max(0, y2 - y1)
+            area1 = (bbox[2] - bbox[0]) * (bbox[3] - bbox[1])
+            area2 = (bboxes[i, 2] - bboxes[i, 0]) * (bboxes[i, 3] - bboxes[i, 1])
+            union = area1 + area2 - inter
+
+            ious[i] = inter / union if union > 0 else 0.0
+        return ious
+
+
+def apply_frame_nms(
+    bboxes: np.ndarray, scores: np.ndarray, nms_threshold: float
+) -> List[int]:
+    """Frame-level NMS implementation with fallback to pure Python"""
+    if HAS_NUMBA:
+        return _apply_frame_nms_numba(bboxes, scores, nms_threshold)
+    else:
+        # Pure Python implementation
+        order = np.argsort(-scores)
+        keep = []
+        suppress = np.zeros(len(bboxes), dtype=bool)
+
+        for i in range(len(order)):
+            if not suppress[order[i]]:
+                keep.append(order[i])
+                current_bbox = bboxes[order[i]]
+
+                remaining_bboxes = bboxes[order[i + 1 :]]
+                if len(remaining_bboxes) > 0:  # Check if there are any remaining boxes
+                    ious = compute_frame_ious(current_bbox, remaining_bboxes)
+                    suppress[order[i + 1 :]] = suppress[order[i + 1 :]] | (
+                        ious >= nms_threshold
+                    )
+
+        return keep
+
+
+if HAS_NUMBA:
+
+    @nb.jit(nopython=True)
+    def _apply_frame_nms_numba(bboxes, scores, nms_threshold):
+        """Numba-optimized NMS implementation"""
+        order = np.argsort(-scores)
+        keep = []
+        suppress = np.zeros(len(bboxes), dtype=nb.boolean)
+
+        for i in range(len(order)):
+            if not suppress[order[i]]:
+                keep.append(order[i])
+                current_bbox = bboxes[order[i]]
+
+                if i + 1 < len(order):  # Check bounds
+                    ious = _compute_frame_ious_numba(
+                        current_bbox, bboxes[order[i + 1 :]]
+                    )
+                    suppress[order[i + 1 :]] = suppress[order[i + 1 :]] | (
+                        ious >= nms_threshold
+                    )
+
+        return keep

之前的代码版本/HuatuoGPT-Vision/MedSAM3/sam3/train/train.py

@@ -0,0 +1,339 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+import logging
+import os
+import random
+import sys
+import traceback
+from argparse import ArgumentParser
+from copy import deepcopy
+
+import submitit
+import torch
+
+from hydra import compose, initialize_config_module
+from hydra.utils import instantiate
+
+from iopath.common.file_io import g_pathmgr
+from omegaconf import OmegaConf
+
+from sam3.train.utils.train_utils import makedir, register_omegaconf_resolvers
+from tqdm import tqdm
+
+
+os.environ["HYDRA_FULL_ERROR"] = "1"
+
+
+class SlurmEvent:
+    QUEUED = "QUEUED"
+    START = "START"
+    FINISH = "FINISH"
+    JOB_ERROR = "JOB_ERROR"
+    SLURM_SIGNAL = "SLURM_SIGNAL"
+
+
+def handle_custom_resolving(cfg):
+    # We'll resolve the config here, so we can catch mistakes early.
+    # However, we need to pass the un-resolved config to the launcher
+    # (because DVC resolving needs to be done on the node it will run on)
+    # First, do a copy without triggering resolving
+    cfg_resolved = OmegaConf.to_container(cfg, resolve=False)
+    cfg_resolved = OmegaConf.create(cfg_resolved)
+    return cfg_resolved
+
+
+def single_proc_run(local_rank, main_port, cfg, world_size):
+    """Single GPU process"""
+    os.environ["MASTER_ADDR"] = "localhost"
+    os.environ["MASTER_PORT"] = str(main_port)
+    os.environ["RANK"] = str(local_rank)
+    os.environ["LOCAL_RANK"] = str(local_rank)
+    os.environ["WORLD_SIZE"] = str(world_size)
+    try:
+        register_omegaconf_resolvers()
+    except Exception as e:
+        logging.info(e)
+
+    trainer = instantiate(cfg.trainer, _recursive_=False)
+    trainer.run()
+
+
+def single_node_runner(cfg, main_port: int):
+    assert cfg.launcher.num_nodes == 1
+    # assert cfg.launcher.gpus_per_node == 1
+    num_proc = cfg.launcher.gpus_per_node
+    torch.multiprocessing.set_start_method(
+        "spawn"
+    )  # CUDA runtime does not support `fork`
+    if num_proc == 1:
+        # directly call single_proc so we can easily set breakpoints
+        # mp.spawn does not let us set breakpoints
+        single_proc_run(local_rank=0, main_port=main_port, cfg=cfg, world_size=num_proc)
+    else:
+        mp_runner = torch.multiprocessing.start_processes
+        args = (main_port, cfg, num_proc)
+        # Note: using "fork" below, "spawn" causes time and error regressions. Using
+        # spawn changes the default multiprocessing context to spawn, which doesn't
+        # interact well with the dataloaders (likely due to the use of OpenCV).
+        mp_runner(single_proc_run, args=args, nprocs=num_proc, start_method="spawn")
+
+
+def format_exception(e: Exception, limit=20):
+    traceback_str = "".join(traceback.format_tb(e.__traceback__, limit=limit))
+    return f"{type(e).__name__}: {e}\nTraceback:\n{traceback_str}"
+
+
+class SubmititRunner(submitit.helpers.Checkpointable):
+    """A callable which is passed to submitit to launch the jobs."""
+
+    def __init__(self, port, cfg):
+        self.cfg = cfg
+        self.port = port
+        self.has_setup = False
+
+    def run_trainer(self):
+        job_env = submitit.JobEnvironment()
+        # Need to add this again so the hydra.job.set_env PYTHONPATH
+        # is also set when launching jobs.
+        add_pythonpath_to_sys_path()
+        os.environ["MASTER_ADDR"] = job_env.hostnames[0]
+        os.environ["MASTER_PORT"] = str(self.port)
+        os.environ["RANK"] = str(job_env.global_rank)
+        os.environ["LOCAL_RANK"] = str(job_env.local_rank)
+        os.environ["WORLD_SIZE"] = str(job_env.num_tasks)
+
+        register_omegaconf_resolvers()
+        cfg_resolved = OmegaConf.to_container(self.cfg, resolve=False)
+        cfg_resolved = OmegaConf.create(cfg_resolved)
+
+        trainer = instantiate(cfg_resolved.trainer, _recursive_=False)
+        trainer.run()
+
+    def __call__(self):
+        job_env = submitit.JobEnvironment()
+        self.setup_job_info(job_env.job_id, job_env.global_rank)
+        try:
+            self.run_trainer()
+        except Exception as e:
+            # Log the exception. Then raise it again (as what SubmititRunner currently does).
+            message = format_exception(e)
+            logging.error(message)
+            raise e
+
+    def setup_job_info(self, job_id, rank):
+        """Set up slurm job info"""
+        self.job_info = {
+            "job_id": job_id,
+            "rank": rank,
+            "cluster": self.cfg.get("cluster", None),
+            "experiment_log_dir": self.cfg.launcher.experiment_log_dir,
+        }
+
+        self.has_setup = True
+
+
+def add_pythonpath_to_sys_path():
+    if "PYTHONPATH" not in os.environ or not os.environ["PYTHONPATH"]:
+        return
+    sys.path = os.environ["PYTHONPATH"].split(":") + sys.path
+
+
+def main(args) -> None:
+    cfg = compose(config_name=args.config)
+    if cfg.launcher.experiment_log_dir is None:
+        cfg.launcher.experiment_log_dir = os.path.join(
+            os.getcwd(), "sam3_logs", args.config
+        )
+    print("###################### Train App Config ####################")
+    print(OmegaConf.to_yaml(cfg))
+    print("############################################################")
+
+    add_pythonpath_to_sys_path()
+    makedir(cfg.launcher.experiment_log_dir)
+    with g_pathmgr.open(
+        os.path.join(cfg.launcher.experiment_log_dir, "config.yaml"), "w"
+    ) as f:
+        f.write(OmegaConf.to_yaml(cfg))
+
+    cfg_resolved = OmegaConf.to_container(cfg, resolve=False)
+    cfg_resolved = OmegaConf.create(cfg_resolved)
+
+    with g_pathmgr.open(
+        os.path.join(cfg.launcher.experiment_log_dir, "config_resolved.yaml"), "w"
+    ) as f:
+        f.write(OmegaConf.to_yaml(cfg_resolved, resolve=True))
+
+    submitit_conf = cfg.get("submitit", None)
+    assert submitit_conf is not None, "Missing submitit config"
+
+    experiment_log_dir = cfg.launcher.experiment_log_dir
+    print(f"Experiment Log Dir:\n{experiment_log_dir}")
+    submitit_dir = os.path.join(experiment_log_dir, "submitit_logs")
+
+    # Prioritize cmd line args
+    cfg.launcher.gpus_per_node = (
+        args.num_gpus if args.num_gpus is not None else cfg.launcher.gpus_per_node
+    )
+    cfg.launcher.num_nodes = (
+        args.num_nodes if args.num_nodes is not None else cfg.launcher.num_nodes
+    )
+    submitit_conf.use_cluster = (
+        args.use_cluster if args.use_cluster is not None else submitit_conf.use_cluster
+    )
+    if submitit_conf.use_cluster:
+        executor = submitit.AutoExecutor(folder=submitit_dir)
+        submitit_conf.partition = (
+            args.partition
+            if args.partition is not None
+            else submitit_conf.get("partition", None)
+        )
+        submitit_conf.account = (
+            args.account
+            if args.account is not None
+            else submitit_conf.get("account", None)
+        )
+        submitit_conf.qos = (
+            args.qos if args.qos is not None else submitit_conf.get("qos", None)
+        )
+        job_kwargs = {
+            "timeout_min": 60 * submitit_conf.timeout_hour,
+            "name": (
+                submitit_conf.name if hasattr(submitit_conf, "name") else args.config
+            ),
+            "slurm_partition": submitit_conf.partition,
+            "gpus_per_node": cfg.launcher.gpus_per_node,
+            "tasks_per_node": cfg.launcher.gpus_per_node,  # one task per GPU
+            "cpus_per_task": submitit_conf.cpus_per_task,
+            "nodes": cfg.launcher.num_nodes,
+            "slurm_additional_parameters": {
+                "exclude": " ".join(submitit_conf.get("exclude_nodes", [])),
+            },
+        }
+        if "include_nodes" in submitit_conf:
+            assert (
+                len(submitit_conf["include_nodes"]) >= cfg.launcher.num_nodes
+            ), "Not enough nodes"
+            job_kwargs["slurm_additional_parameters"]["nodelist"] = " ".join(
+                submitit_conf["include_nodes"]
+            )
+        if submitit_conf.account is not None:
+            job_kwargs["slurm_additional_parameters"]["account"] = submitit_conf.account
+        if submitit_conf.qos is not None:
+            job_kwargs["slurm_additional_parameters"]["qos"] = submitit_conf.qos
+
+        if submitit_conf.get("mem_gb", None) is not None:
+            job_kwargs["mem_gb"] = submitit_conf.mem_gb
+        elif submitit_conf.get("mem", None) is not None:
+            job_kwargs["slurm_mem"] = submitit_conf.mem
+
+        if submitit_conf.get("constraints", None) is not None:
+            job_kwargs["slurm_constraint"] = submitit_conf.constraints
+
+        if submitit_conf.get("comment", None) is not None:
+            job_kwargs["slurm_comment"] = submitit_conf.comment
+
+        # Supports only cpu-bind option within srun_args. New options can be added here
+        if submitit_conf.get("srun_args", None) is not None:
+            job_kwargs["slurm_srun_args"] = []
+            if submitit_conf.srun_args.get("cpu_bind", None) is not None:
+                job_kwargs["slurm_srun_args"].extend(
+                    ["--cpu-bind", submitit_conf.srun_args.cpu_bind]
+                )
+
+        print("###################### SLURM Config ####################")
+        print(job_kwargs)
+        print("##########################################")
+        executor.update_parameters(**job_kwargs)
+
+        if (
+            "job_array" in submitit_conf
+            and submitit_conf.job_array.get("num_tasks", -1) > 0
+        ):
+            num_tasks = submitit_conf.job_array.num_tasks
+            job_array_config_dir = os.path.join(
+                cfg.launcher.experiment_log_dir, "job_array_configs"
+            )
+            makedir(job_array_config_dir)
+
+            job_indices = range(num_tasks)
+            ports = random.sample(
+                range(submitit_conf.port_range[0], submitit_conf.port_range[1] + 1),
+                k=len(job_indices),
+            )
+
+            jobs_runners_configs = []
+            with executor.batch():
+                task_index = 0
+                for indices, main_port in tqdm(zip(job_indices, ports)):
+                    curr_cfg = deepcopy(cfg)
+                    curr_cfg.submitit.job_array["task_index"] = task_index
+                    curr_cfg_resolved = handle_custom_resolving(cfg)
+                    runner = SubmititRunner(main_port, curr_cfg)
+                    job = executor.submit(runner)
+                    jobs_runners_configs.append(
+                        (job, runner, curr_cfg, curr_cfg_resolved)
+                    )
+                    task_index += 1
+
+            for job, runner, job_cfg, job_cfg_resolved in jobs_runners_configs:
+                print("Submitit Job ID:", job.job_id)
+
+                # Save job specific config
+                job_array_config_file = os.path.join(
+                    job_array_config_dir, "{}.config.yaml".format(job.job_id)
+                )
+                with g_pathmgr.open(job_array_config_file, "w") as f:
+                    f.write(OmegaConf.to_yaml(job_cfg))
+
+                job_array_config_resolved_file = os.path.join(
+                    job_array_config_dir, "{}.config_resolved.yaml".format(job.job_id)
+                )
+                with g_pathmgr.open(job_array_config_resolved_file, "w") as f:
+                    f.write(OmegaConf.to_yaml(job_cfg_resolved, resolve=True))
+
+                runner.setup_job_info(job.job_id, rank=0)
+                # runner.log_event(event_type=SlurmEvent.QUEUED)
+        else:
+            main_port = random.randint(
+                submitit_conf.port_range[0], submitit_conf.port_range[1]
+            )
+            runner = SubmititRunner(main_port, cfg)
+            job = executor.submit(runner)
+            print(f"Submitit Job ID: {job.job_id}")
+            runner.setup_job_info(job.job_id, rank=0)
+
+    else:
+        cfg.launcher.num_nodes = 1
+        main_port = random.randint(
+            submitit_conf.port_range[0], submitit_conf.port_range[1]
+        )
+        single_node_runner(cfg, main_port)
+
+
+if __name__ == "__main__":
+    initialize_config_module("sam3.train", version_base="1.2")
+    parser = ArgumentParser()
+    parser.add_argument(
+        "-c",
+        "--config",
+        required=True,
+        type=str,
+        help="path to config file (e.g. configs/roboflow_v100_full_ft_100_images.yaml)",
+    )
+    parser.add_argument(
+        "--use-cluster",
+        type=int,
+        default=None,
+        help="whether to launch on a cluster, 0: run locally, 1: run on a cluster",
+    )
+    parser.add_argument("--partition", type=str, default=None, help="SLURM partition")
+    parser.add_argument("--account", type=str, default=None, help="SLURM account")
+    parser.add_argument("--qos", type=str, default=None, help="SLURM qos")
+    parser.add_argument(
+        "--num-gpus", type=int, default=None, help="number of GPUS per node"
+    )
+    parser.add_argument("--num-nodes", type=int, default=None, help="Number of nodes")
+    args = parser.parse_args()
+    args.use_cluster = bool(args.use_cluster) if args.use_cluster is not None else None
+    register_omegaconf_resolvers()
+    main(args)

之前的代码版本/HuatuoGPT-Vision/MedSAM3/sam3/train/trainer.py

@@ -0,0 +1,1193 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+import contextlib
+import fnmatch
+import gc
+import json
+import logging
+import math
+import os
+import time
+from collections import OrderedDict
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Mapping, Optional
+
+import numpy as np
+
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+from hydra.utils import instantiate
+from iopath.common.file_io import g_pathmgr
+
+from sam3.model.data_misc import BatchedDatapoint
+from sam3.model.model_misc import SAM3Output
+from sam3.model.utils.misc import copy_data_to_device
+
+from sam3.train.optim.optimizer import construct_optimizer
+
+from sam3.train.utils.checkpoint_utils import (
+    assert_skipped_parameters_are_frozen,
+    exclude_params_matching_unix_pattern,
+    load_state_dict_into_model,
+    with_check_parameter_frozen,
+)
+
+from sam3.train.utils.distributed import all_reduce_max, barrier, get_rank
+
+from sam3.train.utils.logger import Logger, setup_logging
+from sam3.train.utils.train_utils import (
+    AverageMeter,
+    collect_dict_keys,
+    DurationMeter,
+    get_amp_type,
+    get_machine_local_and_dist_rank,
+    get_resume_checkpoint,
+    human_readable_time,
+    is_dist_avail_and_initialized,
+    log_env_variables,
+    makedir,
+    MemMeter,
+    Phase,
+    ProgressMeter,
+    set_seeds,
+    setup_distributed_backend,
+)
+
+
+CORE_LOSS_KEY = "core_loss"
+
+
+def unwrap_ddp_if_wrapped(model):
+    if isinstance(model, torch.nn.parallel.DistributedDataParallel):
+        return model.module
+    return model
+
+
+@dataclass
+class OptimAMPConf:
+    enabled: bool = False
+    amp_dtype: str = "float16"
+
+
+@dataclass
+class OptimConf:
+    optimizer: torch.optim.Optimizer = None
+    options: Optional[Dict[str, Any]] = None
+    param_group_modifiers: Optional[List] = None
+    amp: Optional[Dict[str, Any]] = None
+    gradient_clip: Any = None
+    gradient_logger: Any = None
+
+    def __post_init__(self):
+        # amp
+        if not isinstance(self.amp, OptimAMPConf):
+            if self.amp is None:
+                self.amp = {}
+            assert isinstance(self.amp, Mapping)
+            self.amp = OptimAMPConf(**self.amp)
+
+
+@dataclass
+class DistributedConf:
+    backend: Optional[str] = None  # inferred from accelerator type
+    comms_dtype: Optional[str] = None
+    find_unused_parameters: bool = False
+    timeout_mins: int = 30
+    gradient_as_bucket_view: bool = False  # PyTorch DDP default is False
+    static_graph: bool = False  # PyTorch DDP default is False
+
+
+@dataclass
+class CudaConf:
+    cudnn_deterministic: bool = False
+    cudnn_benchmark: bool = True
+    allow_tf32: bool = False
+    # if not None, `matmul_allow_tf32` key will override `allow_tf32` for matmul
+    matmul_allow_tf32: Optional[bool] = None
+    # if not None, `cudnn_allow_tf32` key will override `allow_tf32` for cudnn
+    cudnn_allow_tf32: Optional[bool] = None
+
+
+@dataclass
+class CheckpointConf:
+    save_dir: str
+    save_freq: int
+    save_list: List[int] = field(default_factory=list)
+    model_weight_initializer: Any = None
+    save_best_meters: List[str] = None
+    skip_saving_parameters: List[str] = field(default_factory=list)
+    initialize_after_preemption: Optional[bool] = None
+    # if not None, training will be resumed from this checkpoint
+    resume_from: Optional[str] = None
+
+    def infer_missing(self):
+        if self.initialize_after_preemption is None:
+            with_skip_saving = len(self.skip_saving_parameters) > 0
+            self.initialize_after_preemption = with_skip_saving
+        return self
+
+
+@dataclass
+class LoggingConf:
+    log_dir: str
+    log_freq: int  # In iterations
+    tensorboard_writer: Any
+    log_level_primary: str = "INFO"
+    log_level_secondary: str = "ERROR"
+    log_scalar_frequency: int = 100
+    log_visual_frequency: int = 100
+    scalar_keys_to_log: Optional[Dict[str, Any]] = None
+    log_batch_stats: bool = False
+    wandb_writer: Optional[Any] = None
+
+
+class Trainer:
+    """
+    Trainer supporting the DDP training strategies.
+    """
+
+    EPSILON = 1e-8
+
+    def __init__(
+        self,
+        *,  # the order of these args can change at any time, so they are keyword-only
+        data: Dict[str, Any],
+        model: Dict[str, Any],
+        logging: Dict[str, Any],
+        checkpoint: Dict[str, Any],
+        max_epochs: int,
+        mode: str = "train",
+        accelerator: str = "cuda",
+        seed_value: int = 123,
+        val_epoch_freq: int = 1,
+        distributed: Dict[str, bool] = None,
+        cuda: Dict[str, bool] = None,
+        env_variables: Optional[Dict[str, Any]] = None,
+        optim: Optional[Dict[str, Any]] = None,
+        optim_overrides: Optional[List[Dict[str, Any]]] = None,
+        meters: Optional[Dict[str, Any]] = None,
+        loss: Optional[Dict[str, Any]] = None,
+        skip_first_val: bool = False,
+        skip_saving_ckpts: bool = False,
+        empty_gpu_mem_cache_after_eval: bool = True,
+        gradient_accumulation_steps: int = 1,
+    ):
+        self._setup_env_variables(env_variables)
+        self._setup_timers()
+
+        self.data_conf = data
+        self.model_conf = model
+        self.logging_conf = LoggingConf(**logging)
+        self.checkpoint_conf = CheckpointConf(**checkpoint).infer_missing()
+        self.max_epochs = max_epochs
+        self.mode = mode
+        self.val_epoch_freq = val_epoch_freq
+        self.optim_conf = OptimConf(**optim) if optim is not None else OptimConf()
+        self.meters_conf = meters
+        self.loss_conf = loss
+        self.gradient_accumulation_steps = gradient_accumulation_steps
+        distributed = DistributedConf(**distributed or {})
+        cuda = CudaConf(**cuda or {})
+        self.where = 0.0
+
+        self.skip_first_val = skip_first_val
+        self.skip_saving_ckpts = skip_saving_ckpts
+        self.empty_gpu_mem_cache_after_eval = empty_gpu_mem_cache_after_eval
+
+        self._infer_distributed_backend_if_none(distributed, accelerator)
+
+        self._setup_device(accelerator)
+
+        self._setup_torch_dist_and_backend(cuda, distributed)
+
+        makedir(self.logging_conf.log_dir)
+        setup_logging(
+            __name__,
+            output_dir=self.logging_conf.log_dir,
+            rank=self.rank,
+            log_level_primary=self.logging_conf.log_level_primary,
+            log_level_secondary=self.logging_conf.log_level_secondary,
+        )
+
+        set_seeds(seed_value, self.max_epochs, self.distributed_rank)
+        log_env_variables()
+
+        assert (
+            is_dist_avail_and_initialized()
+        ), "Torch distributed needs to be initialized before calling the trainer."
+
+        self._setup_components()  # Except Optimizer everything is setup here.
+        self._move_to_device()
+        self._construct_optimizers()
+        self._setup_dataloaders()
+
+        self.time_elapsed_meter = DurationMeter("Time Elapsed", self.device, ":.2f")
+
+        if self.checkpoint_conf.resume_from is not None:
+            assert os.path.exists(
+                self.checkpoint_conf.resume_from
+            ), f"The 'resume_from' checkpoint {self.checkpoint_conf.resume_from} does not exist!"
+            dst = os.path.join(self.checkpoint_conf.save_dir, "checkpoint.pt")
+            if self.distributed_rank == 0 and not os.path.exists(dst):
+                # Copy the "resume_from" checkpoint to the checkpoint folder
+                # if there is not a checkpoint to resume from already there
+                makedir(self.checkpoint_conf.save_dir)
+                g_pathmgr.copy(self.checkpoint_conf.resume_from, dst)
+            barrier()
+
+        self.load_checkpoint()
+        self._setup_ddp_distributed_training(distributed, accelerator)
+        barrier()
+
+    def _setup_timers(self):
+        """
+        Initializes counters for elapsed time and eta.
+        """
+        self.start_time = time.time()
+        self.ckpt_time_elapsed = 0
+        self.est_epoch_time = dict.fromkeys([Phase.TRAIN, Phase.VAL], 0)
+
+    def _get_meters(self, phase_filters=None):
+        if self.meters is None:
+            return {}
+        meters = {}
+        for phase, phase_meters in self.meters.items():
+            if phase_filters is not None and phase not in phase_filters:
+                continue
+            for key, key_meters in phase_meters.items():
+                if key_meters is None:
+                    continue
+                for name, meter in key_meters.items():
+                    meters[f"{phase}_{key}/{name}"] = meter
+        return meters
+
+    def _infer_distributed_backend_if_none(self, distributed_conf, accelerator):
+        if distributed_conf.backend is None:
+            distributed_conf.backend = "nccl" if accelerator == "cuda" else "gloo"
+
+    def _setup_env_variables(self, env_variables_conf) -> None:
+        if env_variables_conf is not None:
+            for variable_name, value in env_variables_conf.items():
+                os.environ[variable_name] = value
+
+    def _setup_torch_dist_and_backend(self, cuda_conf, distributed_conf) -> None:
+        if torch.cuda.is_available():
+            torch.backends.cudnn.deterministic = cuda_conf.cudnn_deterministic
+            torch.backends.cudnn.benchmark = cuda_conf.cudnn_benchmark
+            torch.backends.cuda.matmul.allow_tf32 = (
+                cuda_conf.matmul_allow_tf32
+                if cuda_conf.matmul_allow_tf32 is not None
+                else cuda_conf.allow_tf32
+            )
+            torch.backends.cudnn.allow_tf32 = (
+                cuda_conf.cudnn_allow_tf32
+                if cuda_conf.cudnn_allow_tf32 is not None
+                else cuda_conf.allow_tf32
+            )
+
+        self.rank = setup_distributed_backend(
+            distributed_conf.backend, distributed_conf.timeout_mins
+        )
+
+    def _setup_device(self, accelerator):
+        self.local_rank, self.distributed_rank = get_machine_local_and_dist_rank()
+        if accelerator == "cuda":
+            self.device = torch.device("cuda", self.local_rank)
+            torch.cuda.set_device(self.local_rank)
+        elif accelerator == "cpu":
+            self.device = torch.device("cpu")
+        else:
+            raise ValueError(f"Unsupported accelerator: {accelerator}")
+
+    def _setup_ddp_distributed_training(self, distributed_conf, accelerator):
+        assert isinstance(self.model, torch.nn.Module)
+
+        self.model = nn.parallel.DistributedDataParallel(
+            self.model,
+            device_ids=[self.local_rank] if accelerator == "cuda" else [],
+            find_unused_parameters=distributed_conf.find_unused_parameters,
+            gradient_as_bucket_view=distributed_conf.gradient_as_bucket_view,
+            static_graph=distributed_conf.static_graph,
+        )
+        if distributed_conf.comms_dtype is not None:  # noqa
+            from torch.distributed.algorithms import ddp_comm_hooks
+
+            amp_type = get_amp_type(distributed_conf.comms_dtype)
+            if amp_type == torch.bfloat16:
+                hook = ddp_comm_hooks.default_hooks.bf16_compress_hook
+                logging.info("Enabling bfloat16 grad communication")
+            else:
+                hook = ddp_comm_hooks.default_hooks.fp16_compress_hook
+                logging.info("Enabling fp16 grad communication")
+            process_group = None
+            self.model.register_comm_hook(process_group, hook)
+
+    def _move_to_device(self):
+        logging.info(
+            f"Moving components to device {self.device} and local rank {self.local_rank}."
+        )
+
+        self.model.to(self.device)
+
+        logging.info(
+            f"Done moving components to device {self.device} and local rank {self.local_rank}."
+        )
+
+    def save_checkpoint(self, epoch, checkpoint_names=None):
+        if self.skip_saving_ckpts:
+            logging.info(
+                "skip_saving_ckpts is set to True. So, no checkpoints have been saved."
+            )
+            return
+        checkpoint_folder = self.checkpoint_conf.save_dir
+        makedir(checkpoint_folder)
+        if checkpoint_names is None:
+            checkpoint_names = ["checkpoint"]
+            if (
+                self.checkpoint_conf.save_freq > 0
+                and (int(epoch) % self.checkpoint_conf.save_freq == 0)
+            ) or int(epoch) in self.checkpoint_conf.save_list:
+                checkpoint_names.append(f"checkpoint_{int(epoch)}")
+
+        checkpoint_paths = []
+        for ckpt_name in checkpoint_names:
+            checkpoint_paths.append(os.path.join(checkpoint_folder, f"{ckpt_name}.pt"))
+
+        state_dict = unwrap_ddp_if_wrapped(self.model).state_dict()
+        state_dict = exclude_params_matching_unix_pattern(
+            patterns=self.checkpoint_conf.skip_saving_parameters, state_dict=state_dict
+        )
+
+        checkpoint = {
+            "model": state_dict,
+            "optimizer": self.optim.optimizer.state_dict(),
+            "epoch": epoch,
+            "loss": self.loss.state_dict(),
+            "steps": self.steps,
+            "time_elapsed": self.time_elapsed_meter.val,
+            "best_meter_values": self.best_meter_values,
+        }
+        if self.optim_conf.amp.enabled:
+            checkpoint["scaler"] = self.scaler.state_dict()
+
+        # DDP checkpoints are only saved on rank 0 (all workers are identical)
+        if self.distributed_rank != 0:
+            return
+
+        for checkpoint_path in checkpoint_paths:
+            self._save_checkpoint(checkpoint, checkpoint_path)
+
+    def _save_checkpoint(self, checkpoint, checkpoint_path):
+        """
+        Save a checkpoint while guarding against the job being killed in the middle
+        of checkpoint saving (which corrupts the checkpoint file and ruins the
+        entire training since usually only the last checkpoint is kept per run).
+
+        We first save the new checkpoint to a temp file (with a '.tmp' suffix), and
+        and move it to overwrite the old checkpoint_path.
+        """
+        checkpoint_path_tmp = f"{checkpoint_path}.tmp"
+        with g_pathmgr.open(checkpoint_path_tmp, "wb") as f:
+            torch.save(checkpoint, f)
+        # after torch.save is completed, replace the old checkpoint with the new one
+        if g_pathmgr.exists(checkpoint_path):
+            # remove the old checkpoint_path file first (otherwise g_pathmgr.mv fails)
+            g_pathmgr.rm(checkpoint_path)
+        success = g_pathmgr.mv(checkpoint_path_tmp, checkpoint_path)
+        assert success
+
+    def load_checkpoint(self):
+        ckpt_path = get_resume_checkpoint(self.checkpoint_conf.save_dir)
+        if ckpt_path is None:
+            self._init_model_state()
+        else:
+            if self.checkpoint_conf.initialize_after_preemption:
+                self._call_model_initializer()
+            self._load_resuming_checkpoint(ckpt_path)
+
+    def _init_model_state(self):
+        # Checking that parameters that won't be saved are indeed frozen
+        # We do this check here before even saving the model to catch errors
+        # are early as possible and not at the end of the first epoch
+        assert_skipped_parameters_are_frozen(
+            patterns=self.checkpoint_conf.skip_saving_parameters,
+            model=self.model,
+        )
+
+        # Checking that parameters that won't be saved are initialized from
+        # within the model definition, unless `initialize_after_preemption`
+        # is explicitly set to `True`. If not, this is a bug, and after
+        # preemption, the `skip_saving_parameters` will have random values
+        allow_init_skip_parameters = self.checkpoint_conf.initialize_after_preemption
+        with with_check_parameter_frozen(
+            patterns=self.checkpoint_conf.skip_saving_parameters,
+            model=self.model,
+            disabled=allow_init_skip_parameters,
+        ):
+            self._call_model_initializer()
+
+    def _call_model_initializer(self):
+        model_weight_initializer = instantiate(
+            self.checkpoint_conf.model_weight_initializer
+        )
+        if model_weight_initializer is not None:
+            logging.info(
+                f"Loading pretrained checkpoint from {self.checkpoint_conf.model_weight_initializer}"
+            )
+            self.model = model_weight_initializer(model=self.model)
+
+    def _load_resuming_checkpoint(self, ckpt_path: str):
+        logging.info(f"Resuming training from {ckpt_path}")
+
+        with g_pathmgr.open(ckpt_path, "rb") as f:
+            checkpoint = torch.load(f, map_location="cpu")
+        load_state_dict_into_model(
+            model=self.model,
+            state_dict=checkpoint["model"],
+            ignore_missing_keys=self.checkpoint_conf.skip_saving_parameters,
+        )
+
+        self.optim.optimizer.load_state_dict(checkpoint["optimizer"])
+        self.loss.load_state_dict(checkpoint["loss"], strict=True)
+        self.epoch = checkpoint["epoch"]
+        self.steps = checkpoint["steps"]
+        self.ckpt_time_elapsed = checkpoint.get("time_elapsed")
+
+        if self.optim_conf.amp.enabled and "scaler" in checkpoint:
+            self.scaler.load_state_dict(checkpoint["scaler"])
+
+        self.best_meter_values = checkpoint.get("best_meter_values", {})
+
+        if "train_dataset" in checkpoint and self.train_dataset is not None:
+            self.train_dataset.load_checkpoint_state(checkpoint["train_dataset"])
+
+    def is_intermediate_val_epoch(self, epoch):
+        skip_epoch = self.skip_first_val and epoch == 0
+        return (
+            epoch % self.val_epoch_freq == 0
+            and epoch < self.max_epochs - 1
+            and not skip_epoch
+        )
+
+    def _find_loss(self, key: str):
+        if key in self.loss:
+            return self.loss[key]
+
+        assert key != "all", "Loss must be specified for key='all'"
+        assert (
+            "default" in self.loss
+        ), f"Key {key} not found in losss, and no default provided"
+        return self.loss["default"]
+
+    def _find_meter(self, phase: str, key: str):
+        if key in self.meters[phase]:
+            return self.meters[phase][key]
+
+        for cand_key, meter in self.meters[phase].items():
+            if fnmatch.fnmatch(key, cand_key):
+                return meter
+        return None
+
+    def _step(
+        self,
+        batch: BatchedDatapoint,
+        model: nn.Module,
+        phase: str,
+    ):
+        key, batch = batch.popitem()
+        batch = copy_data_to_device(batch, self.device, non_blocking=True)
+
+        find_stages = model(batch)
+        find_targets = [
+            unwrap_ddp_if_wrapped(model).back_convert(x) for x in batch.find_targets
+        ]
+        batch_size = len(batch.img_batch)
+        loss = self._find_loss(key)(find_stages, find_targets)
+
+        loss_str = f"Losses/{phase}_{key}_loss"
+
+        loss_log_str = os.path.join("Step_Losses", loss_str)
+
+        # loss contains multiple sub-components we wish to log
+        step_losses = {}
+        if isinstance(loss, dict):
+            step_losses.update(
+                {f"Losses/{phase}_{key}_{k}": v for k, v in loss.items()}
+            )
+            loss = self._log_loss_detailed_and_return_core_loss(
+                loss, loss_log_str, self.steps[phase]
+            )
+
+        if self.steps[phase] % self.logging_conf.log_scalar_frequency == 0:
+            self.logger.log(
+                loss_log_str,
+                loss,
+                self.steps[phase],
+            )
+
+        self.steps[phase] += 1
+
+        ret_tuple = {loss_str: loss}, batch_size, step_losses
+
+        if phase not in self.meters:
+            return ret_tuple
+
+        meters_dict = self._find_meter(phase, key)
+        if meters_dict is None:
+            return ret_tuple
+        if meters_dict is not None:
+            for _, meter in meters_dict.items():
+                meter.update(
+                    find_stages=find_stages,
+                    find_metadatas=batch.find_metadatas,
+                    model=model,
+                    batch=batch,
+                    key=key,
+                )
+            # Cleanup memory
+            if isinstance(find_stages, SAM3Output):
+                for fs in find_stages:
+                    for k in list(fs.keys()):
+                        del fs[k]
+
+        return ret_tuple
+
+    def run(self):
+        assert self.mode in ["train", "train_only", "val"]
+        if self.mode == "train":
+            if self.epoch > 0:
+                logging.info(f"Resuming training from epoch: {self.epoch}")
+                # resuming from a checkpoint
+                if self.is_intermediate_val_epoch(self.epoch - 1):
+                    logging.info("Running previous val epoch")
+                    self.epoch -= 1
+                    self.run_val()
+                    self.epoch += 1
+            self.run_train()
+            self.run_val()
+        elif self.mode == "val":
+            self.run_val()
+        elif self.mode == "train_only":
+            self.run_train()
+
+    def _setup_dataloaders(self):
+        self.train_dataset = None
+        self.val_dataset = None
+
+        if self.mode in ["train", "val"]:
+            self.val_dataset = instantiate(self.data_conf.get(Phase.VAL, None))
+
+        if self.mode in ["train", "train_only"]:
+            self.train_dataset = instantiate(self.data_conf.train)
+
+    def run_train(self):
+        while self.epoch < self.max_epochs:
+            dataloader = self.train_dataset.get_loader(epoch=int(self.epoch))
+            barrier()
+            outs = self.train_epoch(dataloader)
+            self.logger.log_dict(outs, self.epoch)  # Logged only on rank 0
+
+            # log train to text file.
+            if self.distributed_rank == 0:
+                with g_pathmgr.open(
+                    os.path.join(self.logging_conf.log_dir, "train_stats.json"),
+                    "a",
+                ) as f:
+                    f.write(json.dumps(outs) + "\n")
+
+            # Save checkpoint before validating
+            self.save_checkpoint(self.epoch + 1)
+
+            del dataloader
+            gc.collect()
+
+            # Run val, not running on last epoch since will run after the
+            # loop anyway
+            if self.is_intermediate_val_epoch(self.epoch):
+                self.run_val()
+                if torch.cuda.is_available() and self.empty_gpu_mem_cache_after_eval:
+                    # release memory buffers held by the model during eval (which typically
+                    # involves a lot more frames in video grounding that during training)
+                    torch.cuda.empty_cache()
+
+            if self.distributed_rank == 0:
+                self.best_meter_values.update(self._get_trainer_state("train"))
+                with g_pathmgr.open(
+                    os.path.join(self.logging_conf.log_dir, "best_stats.json"),
+                    "a",
+                ) as f:
+                    f.write(json.dumps(self.best_meter_values) + "\n")
+
+            self.epoch += 1
+        # epoch was incremented in the loop but the val step runs out of the loop
+        self.epoch -= 1
+
+    def run_val(self):
+        if not self.val_dataset:
+            return
+
+        dataloader = self.val_dataset.get_loader(epoch=int(self.epoch))
+        outs = self.val_epoch(dataloader, phase=Phase.VAL)
+        del dataloader
+        gc.collect()
+        self.logger.log_dict(outs, self.epoch)  # Logged only on rank 0
+
+        if self.distributed_rank == 0:
+            with g_pathmgr.open(
+                os.path.join(self.logging_conf.log_dir, "val_stats.json"),
+                "a",
+            ) as f:
+                f.write(json.dumps(outs) + "\n")
+
+    def val_epoch(self, val_loader, phase):
+        batch_time = AverageMeter("Batch Time", self.device, ":.2f")
+        data_time = AverageMeter("Data Time", self.device, ":.2f")
+        mem = MemMeter("Mem (GB)", self.device, ":.2f")
+
+        iters_per_epoch = len(val_loader)
+
+        curr_phases = [phase]
+        curr_models = [self.model]
+
+        loss_names = []
+        for p in curr_phases:
+            for key in self.loss.keys():
+                loss_names.append(f"Losses/{p}_{key}_loss")
+
+        loss_mts = OrderedDict(
+            [(name, AverageMeter(name, self.device, ":.2e")) for name in loss_names]
+        )
+        extra_loss_mts = {}
+
+        for model in curr_models:
+            model.eval()
+            if hasattr(unwrap_ddp_if_wrapped(model), "on_validation_epoch_start"):
+                unwrap_ddp_if_wrapped(model).on_validation_epoch_start()
+
+        progress = ProgressMeter(
+            iters_per_epoch,
+            [batch_time, data_time, mem, self.time_elapsed_meter, *loss_mts.values()],
+            self._get_meters(curr_phases),
+            prefix="Val Epoch: [{}]".format(self.epoch),
+        )
+
+        end = time.time()
+
+        for data_iter, batch in enumerate(val_loader):
+            # measure data loading time
+            data_time.update(time.time() - end)
+
+            # batch = batch.to(self.device, non_blocking=True)
+
+            # compute output
+            with torch.no_grad():
+                with torch.amp.autocast(
+                    device_type="cuda",
+                    enabled=(self.optim_conf.amp.enabled if self.optim_conf else False),
+                    dtype=(
+                        get_amp_type(self.optim_conf.amp.amp_dtype)
+                        if self.optim_conf
+                        else None
+                    ),
+                ):
+                    for phase, model in zip(curr_phases, curr_models):
+                        loss_dict, batch_size, extra_losses = self._step(
+                            batch,
+                            model,
+                            phase,
+                        )
+
+                        assert len(loss_dict) == 1
+                        loss_key, loss = loss_dict.popitem()
+
+                        if loss_key in loss_mts:
+                            loss_mts[loss_key].update(loss.item(), batch_size)
+
+                        for k, v in extra_losses.items():
+                            if k not in extra_loss_mts:
+                                extra_loss_mts[k] = AverageMeter(k, self.device, ":.2e")
+                            extra_loss_mts[k].update(v.item(), batch_size)
+
+            # measure elapsed time
+            batch_time.update(time.time() - end)
+            end = time.time()
+
+            self.time_elapsed_meter.update(
+                time.time() - self.start_time + self.ckpt_time_elapsed
+            )
+
+            if torch.cuda.is_available():
+                mem.update(reset_peak_usage=True)
+
+            if data_iter % self.logging_conf.log_freq == 0:
+                progress.display(data_iter)
+
+            if data_iter % self.logging_conf.log_scalar_frequency == 0:
+                # Log progress meters.
+                for progress_meter in progress.meters:
+                    self.logger.log(
+                        os.path.join("Step_Stats", phase, progress_meter.name),
+                        progress_meter.val,
+                        self.steps[Phase.VAL],
+                    )
+
+            if data_iter % 10 == 0:
+                dist.barrier()
+
+        self.est_epoch_time[phase] = batch_time.avg * iters_per_epoch
+        self._log_timers(phase)
+        for model in curr_models:
+            if hasattr(unwrap_ddp_if_wrapped(model), "on_validation_epoch_end"):
+                unwrap_ddp_if_wrapped(model).on_validation_epoch_end()
+
+        out_dict = self._log_meters_and_save_best_ckpts(curr_phases)
+
+        for k, v in loss_mts.items():
+            out_dict[k] = v.avg
+        for k, v in extra_loss_mts.items():
+            out_dict[k] = v.avg
+
+        for phase in curr_phases:
+            out_dict.update(self._get_trainer_state(phase))
+        self._reset_meters(curr_phases)
+        logging.info(f"Meters: {out_dict}")
+        return out_dict
+
+    def _get_trainer_state(self, phase):
+        return {
+            "Trainer/where": self.where,
+            "Trainer/epoch": self.epoch,
+            f"Trainer/steps_{phase}": self.steps[phase],
+        }
+
+    def train_epoch(self, train_loader):
+        # Init stat meters
+        batch_time_meter = AverageMeter("Batch Time", self.device, ":.2f")
+        data_time_meter = AverageMeter("Data Time", self.device, ":.2f")
+        mem_meter = MemMeter("Mem (GB)", self.device, ":.2f")
+        data_times = []
+        phase = Phase.TRAIN
+
+        iters_per_epoch = len(train_loader)
+
+        loss_names = []
+        for batch_key in self.loss.keys():
+            loss_names.append(f"Losses/{phase}_{batch_key}_loss")
+
+        loss_mts = OrderedDict(
+            [(name, AverageMeter(name, self.device, ":.2e")) for name in loss_names]
+        )
+        extra_loss_mts = {}
+
+        progress = ProgressMeter(
+            iters_per_epoch,
+            [
+                batch_time_meter,
+                data_time_meter,
+                mem_meter,
+                self.time_elapsed_meter,
+                *loss_mts.values(),
+            ],
+            self._get_meters([phase]),
+            prefix="Train Epoch: [{}]".format(self.epoch),
+        )
+
+        # Model training loop
+        self.model.train()
+        end = time.time()
+
+        for data_iter, batch in enumerate(train_loader):
+            # measure data loading time
+            data_time_meter.update(time.time() - end)
+            data_times.append(data_time_meter.val)
+            # batch = batch.to(
+            #     self.device, non_blocking=True
+            # )  # move tensors in a tensorclass
+
+            try:
+                self._run_step(batch, phase, loss_mts, extra_loss_mts)
+
+                # compute gradient and do optim step
+                exact_epoch = self.epoch + float(data_iter) / iters_per_epoch
+                self.where = float(exact_epoch) / self.max_epochs
+                assert self.where <= 1 + self.EPSILON
+                if self.where < 1.0:
+                    self.optim.step_schedulers(
+                        self.where, step=int(exact_epoch * iters_per_epoch)
+                    )
+                else:
+                    logging.warning(
+                        f"Skipping scheduler update since the training is at the end, i.e, {self.where} of [0,1]."
+                    )
+
+                # Log schedulers
+                if data_iter % self.logging_conf.log_scalar_frequency == 0:
+                    for j, param_group in enumerate(self.optim.optimizer.param_groups):
+                        for option in self.optim.schedulers[j]:
+                            optim_prefix = (
+                                "" + f"{j}_"
+                                if len(self.optim.optimizer.param_groups) > 1
+                                else ""
+                            )
+                            self.logger.log(
+                                os.path.join("Optim", f"{optim_prefix}", option),
+                                param_group[option],
+                                self.steps[phase],
+                            )
+
+                # Clipping gradients and detecting diverging gradients
+                if self.gradient_clipper is not None:
+                    self.scaler.unscale_(self.optim.optimizer)
+                    self.gradient_clipper(model=self.model)
+
+                if self.gradient_logger is not None:
+                    self.gradient_logger(
+                        self.model, rank=self.distributed_rank, where=self.where
+                    )
+
+                # Optimizer step: the scaler will make sure gradients are not
+                # applied if the gradients are infinite
+                self.scaler.step(self.optim.optimizer)
+                self.scaler.update()
+
+                # measure elapsed time
+                batch_time_meter.update(time.time() - end)
+                end = time.time()
+
+                self.time_elapsed_meter.update(
+                    time.time() - self.start_time + self.ckpt_time_elapsed
+                )
+
+                mem_meter.update(reset_peak_usage=True)
+                if data_iter % self.logging_conf.log_freq == 0:
+                    progress.display(data_iter)
+
+                if data_iter % self.logging_conf.log_scalar_frequency == 0:
+                    # Log progress meters.
+                    for progress_meter in progress.meters:
+                        self.logger.log(
+                            os.path.join("Step_Stats", phase, progress_meter.name),
+                            progress_meter.val,
+                            self.steps[phase],
+                        )
+
+            # Catching NaN/Inf errors in the loss
+            except FloatingPointError as e:
+                raise e
+
+        self.est_epoch_time[Phase.TRAIN] = batch_time_meter.avg * iters_per_epoch
+        self._log_timers(Phase.TRAIN)
+        self._log_sync_data_times(Phase.TRAIN, data_times)
+
+        out_dict = self._log_meters_and_save_best_ckpts([Phase.TRAIN])
+
+        for k, v in loss_mts.items():
+            out_dict[k] = v.avg
+        for k, v in extra_loss_mts.items():
+            out_dict[k] = v.avg
+        out_dict.update(self._get_trainer_state(phase))
+        logging.info(f"Losses and meters: {out_dict}")
+        self._reset_meters([phase])
+        return out_dict
+
+    def _log_sync_data_times(self, phase, data_times):
+        data_times = all_reduce_max(torch.tensor(data_times)).tolist()
+        steps = range(self.steps[phase] - len(data_times), self.steps[phase])
+        for step, data_time in zip(steps, data_times):
+            if step % self.logging_conf.log_scalar_frequency == 0:
+                self.logger.log(
+                    os.path.join("Step_Stats", phase, "Data Time Synced"),
+                    data_time,
+                    step,
+                )
+
+    def _run_step(
+        self,
+        batch: BatchedDatapoint,
+        phase: str,
+        loss_mts: Dict[str, AverageMeter],
+        extra_loss_mts: Dict[str, AverageMeter],
+        raise_on_error: bool = True,
+    ):
+        """
+        Run the forward / backward
+        """
+
+        # it's important to set grads to None, especially with Adam since 0
+        # grads will also update a model even if the step doesn't produce
+        # gradients
+        self.optim.zero_grad(set_to_none=True)
+
+        if self.gradient_accumulation_steps > 1:
+            assert isinstance(
+                batch, list
+            ), f"Expected a list of batches, got {type(batch)}"
+            assert (
+                len(batch) == self.gradient_accumulation_steps
+            ), f"Expected {self.gradient_accumulation_steps} batches, got {len(batch)}"
+            accum_steps = len(batch)
+        else:
+            accum_steps = 1
+            batch = [batch]
+
+        for i, chunked_batch in enumerate(batch):
+            ddp_context = (
+                self.model.no_sync()
+                if i < accum_steps - 1
+                else contextlib.nullcontext()
+            )
+            with ddp_context:
+                with torch.amp.autocast(
+                    device_type="cuda",
+                    enabled=self.optim_conf.amp.enabled,
+                    dtype=get_amp_type(self.optim_conf.amp.amp_dtype),
+                ):
+                    loss_dict, batch_size, extra_losses = self._step(
+                        chunked_batch,
+                        self.model,
+                        phase,
+                    )
+
+                assert len(loss_dict) == 1
+                loss_key, loss = loss_dict.popitem()
+
+                if not math.isfinite(loss.item()):
+                    error_msg = f"Loss is {loss.item()}, attempting to stop training"
+                    logging.error(error_msg)
+                    if raise_on_error:
+                        raise FloatingPointError(error_msg)
+                    else:
+                        return
+
+                self.scaler.scale(loss).backward()
+                loss_mts[loss_key].update(loss.item(), batch_size)
+                for extra_loss_key, extra_loss in extra_losses.items():
+                    if extra_loss_key not in extra_loss_mts:
+                        extra_loss_mts[extra_loss_key] = AverageMeter(
+                            extra_loss_key, self.device, ":.2e"
+                        )
+                    extra_loss_mts[extra_loss_key].update(extra_loss.item(), batch_size)
+
+    def _log_meters_and_save_best_ckpts(self, phases: List[str]):
+        logging.info("Synchronizing meters")
+        out_dict = {}
+        checkpoint_save_keys = []
+        for key, meter in self._get_meters(phases).items():
+            meter_output = meter.compute_synced()
+            is_better_check = getattr(meter, "is_better", None)
+
+            for meter_subkey, meter_value in meter_output.items():
+                out_dict[os.path.join("Meters_train", key, meter_subkey)] = meter_value
+
+                if is_better_check is None:
+                    continue
+
+                tracked_meter_key = os.path.join(key, meter_subkey)
+                if tracked_meter_key not in self.best_meter_values or is_better_check(
+                    meter_value,
+                    self.best_meter_values[tracked_meter_key],
+                ):
+                    self.best_meter_values[tracked_meter_key] = meter_value
+
+                    if (
+                        self.checkpoint_conf.save_best_meters is not None
+                        and key in self.checkpoint_conf.save_best_meters
+                    ):
+                        checkpoint_save_keys.append(tracked_meter_key.replace("/", "_"))
+
+        if len(checkpoint_save_keys) > 0:
+            self.save_checkpoint(self.epoch + 1, checkpoint_save_keys)
+
+        return out_dict
+
+    def _log_timers(self, phase):
+        time_remaining = 0
+        epochs_remaining = self.max_epochs - self.epoch - 1
+        val_epochs_remaining = sum(
+            n % self.val_epoch_freq == 0 for n in range(self.epoch, self.max_epochs)
+        )
+
+        # Adding the guaranteed val run at the end if val_epoch_freq doesn't coincide with
+        # the end epoch.
+        if (self.max_epochs - 1) % self.val_epoch_freq != 0:
+            val_epochs_remaining += 1
+
+        # Remove the current val run from estimate
+        if phase == Phase.VAL:
+            val_epochs_remaining -= 1
+
+        time_remaining += (
+            epochs_remaining * self.est_epoch_time[Phase.TRAIN]
+            + val_epochs_remaining * self.est_epoch_time[Phase.VAL]
+        )
+
+        self.logger.log(
+            os.path.join("Step_Stats", phase, self.time_elapsed_meter.name),
+            self.time_elapsed_meter.val,
+            self.steps[phase],
+        )
+
+        logging.info(f"Estimated time remaining: {human_readable_time(time_remaining)}")
+
+    def _reset_meters(self, phases: str) -> None:
+        for meter in self._get_meters(phases).values():
+            meter.reset()
+
+    def _check_val_key_match(self, val_keys, phase):
+        if val_keys is not None:
+            # Check if there are any duplicates
+            assert len(val_keys) == len(
+                set(val_keys)
+            ), f"Duplicate keys in val datasets, keys: {val_keys}"
+
+            # Check that the keys match the meter keys
+            if self.meters_conf is not None and phase in self.meters_conf:
+                assert set(val_keys) == set(self.meters_conf[phase].keys()), (
+                    f"Keys in val datasets do not match the keys in meters."
+                    f"\nMissing in meters: {set(val_keys) - set(self.meters_conf[phase].keys())}"
+                    f"\nMissing in val datasets: {set(self.meters_conf[phase].keys()) - set(val_keys)}"
+                )
+
+            if self.loss_conf is not None:
+                loss_keys = set(self.loss_conf.keys()) - set(["all"])
+                if "default" not in loss_keys:
+                    for k in val_keys:
+                        assert (
+                            k in loss_keys
+                        ), f"Error: key {k} is not defined in the losses, and no default is set"
+
+    def _setup_components(self):
+        # Get the keys for all the val datasets, if any
+        val_phase = Phase.VAL
+        val_keys = None
+        if self.data_conf.get(val_phase, None) is not None:
+            val_keys = collect_dict_keys(self.data_conf[val_phase])
+        # Additional checks on the sanity of the config for val datasets
+        self._check_val_key_match(val_keys, phase=val_phase)
+
+        logging.info("Setting up components: Model, loss, optim, meters etc.")
+        self.epoch = 0
+        self.steps = {Phase.TRAIN: 0, Phase.VAL: 0}
+
+        self.logger = Logger(self.logging_conf)
+
+        self.model = instantiate(self.model_conf, _convert_="all")
+        print_model_summary(self.model)
+
+        self.loss = None
+        if self.loss_conf:
+            self.loss = {
+                key: el  # wrap_base_loss(el)
+                for (key, el) in instantiate(self.loss_conf, _convert_="all").items()
+            }
+            self.loss = nn.ModuleDict(self.loss)
+
+        self.meters = {}
+        self.best_meter_values = {}
+        if self.meters_conf:
+            self.meters = instantiate(self.meters_conf, _convert_="all")
+
+        self.scaler = torch.amp.GradScaler(
+            self.device,
+            enabled=self.optim_conf.amp.enabled if self.optim_conf else False,
+        )
+
+        self.gradient_clipper = (
+            instantiate(self.optim_conf.gradient_clip) if self.optim_conf else None
+        )
+        self.gradient_logger = (
+            instantiate(self.optim_conf.gradient_logger) if self.optim_conf else None
+        )
+
+        logging.info("Finished setting up components: Model, loss, optim, meters etc.")
+
+    def _construct_optimizers(self):
+        self.optim = construct_optimizer(
+            self.model,
+            self.optim_conf.optimizer,
+            self.optim_conf.options,
+            self.optim_conf.param_group_modifiers,
+        )
+
+    def _log_loss_detailed_and_return_core_loss(self, loss, loss_str, step):
+        core_loss = loss.pop(CORE_LOSS_KEY)
+        if step % self.logging_conf.log_scalar_frequency == 0:
+            for k in loss:
+                log_str = os.path.join(loss_str, k)
+                self.logger.log(log_str, loss[k], step)
+        return core_loss
+
+
+def print_model_summary(model: torch.nn.Module, log_dir: str = ""):
+    """
+    Prints the model and the number of parameters in the model.
+    # Multiple packages provide this info in a nice table format
+    # However, they need us to provide an `input` (as they also write down the output sizes)
+    # Our models are complex, and a single input is restrictive.
+    # https://github.com/sksq96/pytorch-summary
+    # https://github.com/nmhkahn/torchsummaryX
+    """
+    if get_rank() != 0:
+        return
+    param_kwargs = {}
+    trainable_parameters = sum(
+        p.numel() for p in model.parameters(**param_kwargs) if p.requires_grad
+    )
+    total_parameters = sum(p.numel() for p in model.parameters(**param_kwargs))
+    non_trainable_parameters = total_parameters - trainable_parameters
+    logging.info("==" * 10)
+    logging.info(f"Summary for model {type(model)}")
+    logging.info(f"Model is {model}")
+    logging.info(f"\tTotal parameters {get_human_readable_count(total_parameters)}")
+    logging.info(
+        f"\tTrainable parameters {get_human_readable_count(trainable_parameters)}"
+    )
+    logging.info(
+        f"\tNon-Trainable parameters {get_human_readable_count(non_trainable_parameters)}"
+    )
+    logging.info("==" * 10)
+
+    if log_dir:
+        output_fpath = os.path.join(log_dir, "model.txt")
+        with g_pathmgr.open(output_fpath, "w") as f:
+            print(model, file=f)
+
+
+PARAMETER_NUM_UNITS = [" ", "K", "M", "B", "T"]
+
+
+def get_human_readable_count(number: int) -> str:
+    """
+    Abbreviates an integer number with K, M, B, T for thousands, millions,
+    billions and trillions, respectively.
+    Examples:
+        >>> get_human_readable_count(123)
+        '123  '
+        >>> get_human_readable_count(1234)  # (one thousand)
+        '1.2 K'
+        >>> get_human_readable_count(2e6)   # (two million)
+        '2.0 M'
+        >>> get_human_readable_count(3e9)   # (three billion)
+        '3.0 B'
+        >>> get_human_readable_count(4e14)  # (four hundred trillion)
+        '400 T'
+        >>> get_human_readable_count(5e15)  # (more than trillion)
+        '5,000 T'
+    Args:
+        number: a positive integer number
+    Return:
+        A string formatted according to the pattern described above.
+    """
+    assert number >= 0
+    labels = PARAMETER_NUM_UNITS
+    num_digits = int(np.floor(np.log10(number)) + 1 if number > 0 else 1)
+    num_groups = int(np.ceil(num_digits / 3))
+    num_groups = min(num_groups, len(labels))  # don't abbreviate beyond trillions
+    shift = -3 * (num_groups - 1)
+    number = number * (10**shift)
+    index = num_groups - 1
+    if index < 1 or number >= 100:
+        return f"{int(number):,d} {labels[index]}"
+    else:
+        return f"{number:,.1f} {labels[index]}"

之前的代码版本/HuatuoGPT-Vision/MedSAM3/sam3/train/utils/__init__.py

@@ -0,0 +1 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved

之前的代码版本/HuatuoGPT-Vision/MedSAM3/sam3/train/utils/checkpoint_utils.py

@@ -0,0 +1,358 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+
+import contextlib
+import fnmatch
+import logging
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    Union,
+)
+
+import numpy as np
+import torch
+import torch.nn as nn
+from iopath.common.file_io import g_pathmgr
+from torch.jit._script import RecursiveScriptModule
+
+
+def unix_pattern_to_parameter_names(
+    constraints: List[str], all_parameter_names: Sequence[str]
+) -> Union[None, Set[str]]:
+    """
+    Go through the list of parameter names and select those that match
+    any of the provided constraints
+    """
+    parameter_names = []
+    for param_name in constraints:
+        matching_parameters = set(fnmatch.filter(all_parameter_names, param_name))
+        assert (
+            len(matching_parameters) > 0
+        ), f"param_names {param_name} don't match any param in the given names."
+        parameter_names.append(matching_parameters)
+    return set.union(*parameter_names)
+
+
+def filter_params_matching_unix_pattern(
+    patterns: List[str], state_dict: Dict[str, torch.Tensor]
+) -> Dict[str, torch.Tensor]:
+    """
+    Remove from the state dictionary the parameters matching the provided unix patterns
+
+    Args:
+        patterns: the list of unix patterns to exclude
+        state_dict: the dictionary to filter
+
+    Returns:
+        A new state dictionary
+    """
+    if len(patterns) == 0:
+        return {}
+
+    all_keys = list(state_dict.keys())
+    included_keys = unix_pattern_to_parameter_names(patterns, all_keys)
+    return {k: state_dict[k] for k in included_keys}
+
+
+def exclude_params_matching_unix_pattern(
+    patterns: List[str], state_dict: Dict[str, torch.Tensor]
+) -> Dict[str, torch.Tensor]:
+    """
+    Remove from the state dictionary the parameters matching the provided unix patterns
+
+    Args:
+        patterns: the list of unix patterns to exclude
+        state_dict: the dictionary to filter
+
+    Returns:
+        A new state dictionary
+    """
+    if len(patterns) == 0:
+        return state_dict
+
+    all_keys = list(state_dict.keys())
+    excluded_keys = unix_pattern_to_parameter_names(patterns, all_keys)
+    return {k: v for k, v in state_dict.items() if k not in excluded_keys}
+
+
+def _get_state_dict_summary(state_dict: Dict[str, torch.Tensor]):
+    keys = []
+    trace = []
+    for k, v in state_dict.items():
+        keys.append(k)
+        trace.append(v.sum().item())
+    trace = np.array(trace)[np.argsort(keys)]
+    return trace
+
+
+def assert_skipped_parameters_are_frozen(model: nn.Module, patterns: List[str]):
+    """
+    Verifies that all the parameters matching the provided patterns
+    are frozen - this acts as a safeguard when ignoring parameter
+    when saving checkpoints - if the parameters are in fact trainable
+    """
+    if not patterns:
+        return
+
+    frozen_state_dict = filter_params_matching_unix_pattern(
+        patterns=patterns, state_dict=model.state_dict()
+    )
+    non_frozen_keys = {
+        n
+        for n, p in model.named_parameters()
+        if n in frozen_state_dict and p.requires_grad
+    }
+    if non_frozen_keys:
+        raise ValueError(
+            f"Parameters excluded with `skip_saving_parameters` should be frozen: {non_frozen_keys}"
+        )
+
+
+@contextlib.contextmanager
+def with_check_parameter_frozen(
+    model: nn.Module, patterns: List[str], disabled: bool = True
+):
+    """
+    Context manager that inspects a model surrounding a piece of code
+    and verifies if the model has been updated by this piece of code
+
+    The function will raise an exception if the model has been updated
+    on at least one of the parameter that matches one of the pattern
+
+    Args:
+        model: the model that might have been updated
+        patterns: for the parameters we want to observe
+        allowed:
+    """
+    if not patterns or disabled:
+        yield
+        return
+
+    frozen_state_dict = filter_params_matching_unix_pattern(
+        patterns=patterns, state_dict=model.state_dict()
+    )
+    summary_before = _get_state_dict_summary(frozen_state_dict)
+
+    yield
+
+    frozen_state_dict = filter_params_matching_unix_pattern(
+        patterns=patterns, state_dict=model.state_dict()
+    )
+    summary_after = _get_state_dict_summary(frozen_state_dict)
+
+    if not np.allclose(summary_before, summary_after, atol=1e-6):
+        raise ValueError(
+            f"""
+            The `model_weight_initializer` has initialized parameters frozen with `skip_saving_parameters`.
+            You can resolve this error by either initializing those parameters from within the model definition
+            or using the flag `trainer.checkpoint.initialize_after_preemption` to True.
+        """
+        )
+
+
+class CkptExcludeKernel:
+    """
+    Removes the keys from the given model state_dict that match the key_pattern.
+
+    Args:
+        key_pattern: Patterns used to select the keys in the state_dict
+            that are eligible for this kernel.
+    """
+
+    def __init__(self, key_pattern: List[str]):
+        self.key_pattern = key_pattern
+
+    def __call__(self, state_dict: Dict):
+        """
+        Args:
+            state_dict: A dictionary representing the given checkpoint's state dict.
+        """
+        if len(self.key_pattern) == 0:
+            return state_dict
+        exclude_keys = unix_pattern_to_parameter_names(
+            self.key_pattern, state_dict.keys()
+        )
+        return {k: v for k, v in state_dict.items() if k not in exclude_keys}
+
+
+def load_checkpoint(
+    path_list: List[str],
+    pick_recursive_keys: Optional[List[str]] = None,
+    map_location: str = "cpu",
+) -> Any:
+    """
+    Loads a checkpoint from the specified path.
+
+    Args:
+        path_list: A list of paths which contain the checkpoint. Each element
+            is tried (in order) until a file that exists is found. That file is then
+            used to read the checkpoint.
+        pick_recursive_keys: Picks sub dicts from the loaded checkpoint if not None.
+            For pick_recursive_keys = ["a", "b"], will return checkpoint_dict["a"]["b"]
+        map_location (str): a function, torch.device, string or a dict specifying how to
+            remap storage locations
+
+    Returns: Model with the matchin pre-trained weights loaded.
+    """
+    path_exists = False
+    for path in path_list:
+        if g_pathmgr.exists(path):
+            path_exists = True
+            break
+
+    if not path_exists:
+        raise ValueError(f"No path exists in {path_list}")
+
+    with g_pathmgr.open(path, "rb") as f:
+        checkpoint = torch.load(f, map_location=map_location)
+
+    logging.info(f"Loaded checkpoint from {path}")
+    if pick_recursive_keys is not None:
+        for key in pick_recursive_keys:
+            checkpoint = checkpoint[key]
+    return checkpoint
+
+
+def get_state_dict(checkpoint, ckpt_state_dict_keys):
+    if isinstance(checkpoint, RecursiveScriptModule):
+        # This is a torchscript JIT model
+        return checkpoint.state_dict()
+    pre_train_dict = checkpoint
+    for i, key in enumerate(ckpt_state_dict_keys):
+        if (isinstance(pre_train_dict, Mapping) and key not in pre_train_dict) or (
+            isinstance(pre_train_dict, Sequence) and key >= len(pre_train_dict)
+        ):
+            key_str = (
+                '["' + '"]["'.join(list(map(ckpt_state_dict_keys[:i], str))) + '"]'
+            )
+            raise KeyError(
+                f"'{key}' not found in checkpoint{key_str} "
+                f"with keys: {pre_train_dict.keys()}"
+            )
+        pre_train_dict = pre_train_dict[key]
+    return pre_train_dict
+
+
+def load_checkpoint_and_apply_kernels(
+    checkpoint_path: str,
+    checkpoint_kernels: List[Callable] = None,
+    ckpt_state_dict_keys: Tuple[str] = ("state_dict",),
+    map_location: str = "cpu",
+) -> nn.Module:
+    """
+    Performs checkpoint loading with a variety of pre-processing kernel applied in
+    sequence.
+
+    Args:
+        checkpoint_path (str): Path to the checkpoint.
+        checkpoint_kernels List(Callable): A list of checkpoint processing kernels
+            to apply in the specified order. Supported kernels include `CkptIncludeKernel`,
+            `CkptExcludeKernel`, etc. These kernels are applied in the
+            given order.
+        ckpt_state_dict_keys (str): Keys containing the model state dict.
+        map_location (str): a function, torch.device, string or a dict specifying how to
+            remap storage locations
+
+    Returns: Model with the matchin pre-trained weights loaded.
+    """
+    assert g_pathmgr.exists(checkpoint_path), "Checkpoint '{}' not found".format(
+        checkpoint_path
+    )
+
+    # Load the checkpoint on CPU to avoid GPU mem spike.
+    with g_pathmgr.open(checkpoint_path, "rb") as f:
+        checkpoint = torch.load(f, map_location=map_location)
+
+    pre_train_dict = get_state_dict(checkpoint, ckpt_state_dict_keys)
+
+    # Not logging into info etc since it's a huge log
+    logging.debug(
+        "Loaded Checkpoint State Dict pre-kernel application: %s"
+        % str(", ".join(list(pre_train_dict.keys())))
+    )
+    # Apply kernels
+    if checkpoint_kernels is not None:
+        for f in checkpoint_kernels:
+            pre_train_dict = f(state_dict=pre_train_dict)
+
+    logging.debug(
+        "Loaded Checkpoint State Dict Post-kernel application %s"
+        % str(", ".join(list(pre_train_dict.keys())))
+    )
+
+    return pre_train_dict
+
+
+def check_load_state_dict_errors(
+    missing_keys,
+    unexpected_keys,
+    strict: bool,
+    ignore_missing_keys: List[str] = None,
+    ignore_unexpected_keys: List[str] = None,
+):
+    if ignore_missing_keys is not None and len(ignore_missing_keys) > 0:
+        ignored_keys = unix_pattern_to_parameter_names(
+            ignore_missing_keys, missing_keys
+        )
+        missing_keys = [key for key in missing_keys if key not in ignored_keys]
+
+    if ignore_unexpected_keys is not None and len(ignore_unexpected_keys) > 0:
+        ignored_unexpected_keys = unix_pattern_to_parameter_names(
+            ignore_unexpected_keys, unexpected_keys
+        )
+        unexpected_keys = [
+            key for key in unexpected_keys if key not in ignored_unexpected_keys
+        ]
+
+    err = "State key mismatch."
+    if unexpected_keys:
+        err += f" Unexpected keys: {unexpected_keys}."
+    if missing_keys:
+        err += f" Missing keys: {missing_keys}."
+
+    if unexpected_keys or missing_keys:
+        logging.warning(err)
+        if unexpected_keys or strict:
+            raise KeyError(err)
+
+
+def load_state_dict_into_model(
+    state_dict: Dict,
+    model: nn.Module,
+    strict: bool = True,
+    ignore_missing_keys: List[str] = None,
+    ignore_unexpected_keys: List[str] = None,
+    checkpoint_kernels: List[Callable] = None,
+):
+    """
+    Loads a state dict into the given model.
+
+    Args:
+        state_dict: A dictionary containing the model's
+            state dict, or a subset if strict is False
+        model: Model to load the checkpoint weights into
+        strict: raise if the state_dict has missing state keys
+        ignore_missing_keys: unix pattern of keys to ignore
+    """
+    # Apply kernels
+    if checkpoint_kernels is not None:
+        for f in checkpoint_kernels:
+            state_dict = f(state_dict=state_dict)
+    missing_keys, unexpected_keys = model.load_state_dict(state_dict, strict=False)
+
+    check_load_state_dict_errors(
+        missing_keys,
+        unexpected_keys,
+        strict=strict,
+        ignore_missing_keys=ignore_missing_keys,
+        ignore_unexpected_keys=ignore_unexpected_keys,
+    )
+    return model

之前的代码版本/HuatuoGPT-Vision/MedSAM3/sam3/train/utils/distributed.py

@@ -0,0 +1,585 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import datetime
+import functools
+import io
+import logging
+import os
+import random
+import tempfile
+import time
+from typing import Any, Callable, List, Tuple
+
+import torch
+import torch.autograd as autograd
+import torch.distributed as dist
+
+
+# Default to GPU 0
+_cuda_device_index: int = 0
+
+# Setting _cuda_device_index to -1 internally implies that we should use CPU
+_CPU_DEVICE_INDEX = -1
+_PRIMARY_RANK = 0
+
+
+@functools.lru_cache()
+def _get_global_gloo_group():
+    """
+    Return a process group based on gloo backend, containing all the ranks
+    The result is cached.
+    """
+
+    if dist.get_backend() == "nccl":
+        # Increase timeout from 1800 sec to 43200 sec (12 hr) to avoid some processes
+        # being much slower than others causing a timeout (which can happen in relation
+        # or LVIS class mAP evaluation).
+        timeout = 43200
+        return dist.new_group(
+            backend="gloo",
+            timeout=datetime.timedelta(seconds=timeout),
+        )
+
+    return dist.group.WORLD
+
+
+def is_main_process():
+    """Return true if the current process is the main one"""
+    return get_rank() == 0
+
+
+def all_gather_via_filesys(data, filesys_save_dir=None, gather_to_rank_0_only=False):
+    """
+    Run all_gather on arbitrary picklable data (not necessarily tensors), similar to
+    `all_gather` above, but using filesystem instead of collective ops.
+
+    If gather_to_rank_0_only is True, only rank 0 will load the gathered object list
+    (and other ranks will have an empty list).
+    """
+    world_size = get_world_size()
+    if world_size == 1:
+        return [data]
+
+    print("gathering via files")
+    cpu_group = _get_global_gloo_group()
+
+    # if unspecified, we will save to the current python file dir
+    if filesys_save_dir is not None:
+        save_dir = filesys_save_dir
+    elif "EXP_DIR" in os.environ:
+        save_dir = os.environ["EXP_DIR"]
+    else:
+        # try the same directory where the code is stored
+        save_dir = filesys_save_dir or os.path.dirname(__file__)
+    save_dir = os.path.join(save_dir, "all_gather_via_filesys")
+    if is_main_process():
+        os.makedirs(save_dir, exist_ok=True)
+
+    # use a timestamp and salt to distinguish different all_gather
+    timestamp = int(time.time()) if is_main_process() else 0
+    salt = random.randint(0, 2**31 - 1) if is_main_process() else 0
+    # broadcast the timestamp and salt across ranks
+    # (all-reduce will do the broadcasting since only rank 0 is non-zero)
+    timestamp_and_salt = torch.tensor([timestamp, salt], dtype=torch.long)
+    dist.all_reduce(timestamp_and_salt, group=cpu_group)
+    timestamp, salt = timestamp_and_salt.tolist()
+
+    # save the data to a file on the disk
+    rank_save = get_rank()
+    save_data_filename = f"data_to_gather_{timestamp}_{salt}_{rank_save}.pkl"
+    save_data_path = os.path.join(save_dir, save_data_filename)
+    assert not os.path.exists(save_data_path), f"{save_data_path} already exists"
+    torch.save(data, save_data_path)
+    dist.barrier(group=cpu_group)
+
+    # read the data from the files
+    data_list = []
+    if rank_save == 0 or not gather_to_rank_0_only:
+        for rank_load in range(world_size):
+            load_data_filename = f"data_to_gather_{timestamp}_{salt}_{rank_load}.pkl"
+            load_data_path = os.path.join(save_dir, load_data_filename)
+            assert os.path.exists(load_data_path), f"cannot read {save_data_path}"
+            data_list.append(torch.load(load_data_path, weights_only=False))
+    dist.barrier(group=cpu_group)
+
+    # delete the saved file
+    os.remove(save_data_path)
+    return data_list
+
+
+def all_gather(data, force_cpu=False, force_filesys=False, filesys_save_dir=None):
+    """
+    Run all_gather on arbitrary picklable data (not necessarily tensors)
+    Args:
+        data: any picklable object
+    Returns:
+        list[data]: list of data gathered from each rank
+    """
+
+    world_size = get_world_size()
+    if world_size == 1:
+        return [data]
+
+    if os.getenv("MDETR_FILESYS_REDUCE_RANK_0_ONLY") == "1":
+        return all_gather_via_filesys(
+            data, filesys_save_dir, gather_to_rank_0_only=True
+        )
+
+    if os.getenv("MDETR_FILESYS_REDUCE") == "1" or force_filesys:
+        return all_gather_via_filesys(data, filesys_save_dir)
+
+    cpu_group = None
+    if os.getenv("MDETR_CPU_REDUCE") == "1" or force_cpu:
+        cpu_group = _get_global_gloo_group()
+
+    buffer = io.BytesIO()
+    torch.save(data, buffer)
+    data_view = buffer.getbuffer()
+    device = "cuda" if cpu_group is None else "cpu"
+    tensor = torch.ByteTensor(data_view).to(device)
+
+    # obtain Tensor size of each rank
+    local_size = torch.tensor([tensor.numel()], device=device, dtype=torch.long)
+    size_list = [
+        torch.tensor([0], device=device, dtype=torch.long) for _ in range(world_size)
+    ]
+    if cpu_group is None:
+        dist.all_gather(size_list, local_size)
+    else:
+        print("gathering on cpu")
+        dist.all_gather(size_list, local_size, group=cpu_group)
+    size_list = [int(size.item()) for size in size_list]
+    max_size = max(size_list)
+    assert isinstance(local_size.item(), int)
+    local_size = int(local_size.item())
+
+    # receiving Tensor from all ranks
+    # we pad the tensor because torch all_gather does not support
+    # gathering tensors of different shapes
+    tensor_list = []
+    for _ in size_list:
+        tensor_list.append(torch.empty((max_size,), dtype=torch.uint8, device=device))
+    if local_size != max_size:
+        padding = torch.empty(
+            size=(max_size - local_size,), dtype=torch.uint8, device=device
+        )
+        tensor = torch.cat((tensor, padding), dim=0)
+    if cpu_group is None:
+        dist.all_gather(tensor_list, tensor)
+    else:
+        dist.all_gather(tensor_list, tensor, group=cpu_group)
+
+    data_list = []
+    for size, tensor in zip(size_list, tensor_list):
+        tensor = torch.split(tensor, [size, max_size - size], dim=0)[0]
+        buffer = io.BytesIO(tensor.cpu().numpy())
+        obj = torch.load(buffer, weights_only=False)
+        data_list.append(obj)
+
+    return data_list
+
+
+def convert_to_distributed_tensor(tensor: torch.Tensor) -> Tuple[torch.Tensor, str]:
+    """
+    For some backends, such as NCCL, communication only works if the
+    tensor is on the GPU. This helper function converts to the correct
+    device and returns the tensor + original device.
+    """
+    orig_device = "cpu" if not tensor.is_cuda else "gpu"
+    if (
+        torch.distributed.is_available()
+        and torch.distributed.get_backend() == torch.distributed.Backend.NCCL
+        and not tensor.is_cuda
+    ):
+        tensor = tensor.cuda()
+    return (tensor, orig_device)
+
+
+def convert_to_normal_tensor(tensor: torch.Tensor, orig_device: str) -> torch.Tensor:
+    """
+    For some backends, such as NCCL, communication only works if the
+    tensor is on the GPU. This converts the tensor back to original device.
+    """
+    if tensor.is_cuda and orig_device == "cpu":
+        tensor = tensor.cpu()
+    return tensor
+
+
+def is_distributed_training_run() -> bool:
+    return (
+        torch.distributed.is_available()
+        and torch.distributed.is_initialized()
+        and (torch.distributed.get_world_size() > 1)
+    )
+
+
+def is_primary() -> bool:
+    """
+    Returns True if this is rank 0 of a distributed training job OR if it is
+    a single trainer job. Otherwise False.
+    """
+    return get_rank() == _PRIMARY_RANK
+
+
+def all_reduce_mean(tensor: torch.Tensor) -> torch.Tensor:
+    """
+    Wrapper over torch.distributed.all_reduce for performing mean reduction
+    of tensor over all processes.
+    """
+    return all_reduce_op(
+        tensor,
+        torch.distributed.ReduceOp.SUM,
+        lambda t: t / torch.distributed.get_world_size(),
+    )
+
+
+def all_reduce_sum(tensor: torch.Tensor) -> torch.Tensor:
+    """
+    Wrapper over torch.distributed.all_reduce for performing sum
+    reduction of tensor over all processes in both distributed /
+    non-distributed scenarios.
+    """
+    return all_reduce_op(tensor, torch.distributed.ReduceOp.SUM)
+
+
+def all_reduce_min(tensor: torch.Tensor) -> torch.Tensor:
+    """
+    Wrapper over torch.distributed.all_reduce for performing min
+    reduction of tensor over all processes in both distributed /
+    non-distributed scenarios.
+    """
+    return all_reduce_op(tensor, torch.distributed.ReduceOp.MIN)
+
+
+def all_reduce_max(tensor: torch.Tensor) -> torch.Tensor:
+    """
+    Wrapper over torch.distributed.all_reduce for performing min
+    reduction of tensor over all processes in both distributed /
+    non-distributed scenarios.
+    """
+    return all_reduce_op(tensor, torch.distributed.ReduceOp.MAX)
+
+
+def all_reduce_op(
+    tensor: torch.Tensor,
+    op: torch.distributed.ReduceOp,
+    after_op_func: Callable[[torch.Tensor], torch.Tensor] = None,
+) -> torch.Tensor:
+    """
+    Wrapper over torch.distributed.all_reduce for performing
+    reduction of tensor over all processes in both distributed /
+    non-distributed scenarios.
+    """
+    if is_distributed_training_run():
+        tensor, orig_device = convert_to_distributed_tensor(tensor)
+        torch.distributed.all_reduce(tensor, op)
+        if after_op_func is not None:
+            tensor = after_op_func(tensor)
+        tensor = convert_to_normal_tensor(tensor, orig_device)
+    return tensor
+
+
+def gather_tensors_from_all(tensor: torch.Tensor) -> List[torch.Tensor]:
+    """
+    Wrapper over torch.distributed.all_gather for performing
+    'gather' of 'tensor' over all processes in both distributed /
+    non-distributed scenarios.
+    """
+    if tensor.ndim == 0:
+        # 0 dim tensors cannot be gathered. so unsqueeze
+        tensor = tensor.unsqueeze(0)
+
+    if is_distributed_training_run():
+        tensor, orig_device = convert_to_distributed_tensor(tensor)
+        gathered_tensors = [
+            torch.zeros_like(tensor) for _ in range(torch.distributed.get_world_size())
+        ]
+        torch.distributed.all_gather(gathered_tensors, tensor)
+        gathered_tensors = [
+            convert_to_normal_tensor(_tensor, orig_device)
+            for _tensor in gathered_tensors
+        ]
+    else:
+        gathered_tensors = [tensor]
+
+    return gathered_tensors
+
+
+def gather_from_all(tensor: torch.Tensor) -> torch.Tensor:
+    gathered_tensors = gather_tensors_from_all(tensor)
+    gathered_tensor = torch.cat(gathered_tensors, 0)
+    return gathered_tensor
+
+
+def broadcast(tensor: torch.Tensor, src: int = 0) -> torch.Tensor:
+    """
+    Wrapper over torch.distributed.broadcast for broadcasting a tensor from the source
+    to all processes in both distributed / non-distributed scenarios.
+    """
+    if is_distributed_training_run():
+        tensor, orig_device = convert_to_distributed_tensor(tensor)
+        torch.distributed.broadcast(tensor, src)
+        tensor = convert_to_normal_tensor(tensor, orig_device)
+    return tensor
+
+
+def barrier() -> None:
+    """
+    Wrapper over torch.distributed.barrier, returns without waiting
+    if the distributed process group is not initialized instead of throwing error.
+    """
+    if not torch.distributed.is_available() or not torch.distributed.is_initialized():
+        return
+    torch.distributed.barrier()
+
+
+def get_world_size() -> int:
+    """
+    Simple wrapper for correctly getting worldsize in both distributed
+    / non-distributed settings
+    """
+    return (
+        torch.distributed.get_world_size()
+        if torch.distributed.is_available() and torch.distributed.is_initialized()
+        else 1
+    )
+
+
+def get_rank() -> int:
+    """
+    Simple wrapper for correctly getting rank in both distributed
+    / non-distributed settings
+    """
+    return (
+        torch.distributed.get_rank()
+        if torch.distributed.is_available() and torch.distributed.is_initialized()
+        else 0
+    )
+
+
+def get_primary_rank() -> int:
+    return _PRIMARY_RANK
+
+
+def set_cuda_device_index(idx: int) -> None:
+    global _cuda_device_index
+    _cuda_device_index = idx
+    torch.cuda.set_device(_cuda_device_index)
+
+
+def set_cpu_device() -> None:
+    global _cuda_device_index
+    _cuda_device_index = _CPU_DEVICE_INDEX
+
+
+def get_cuda_device_index() -> int:
+    return _cuda_device_index
+
+
+def init_distributed_data_parallel_model(
+    model: torch.nn.Module,
+    broadcast_buffers: bool = False,
+    find_unused_parameters: bool = True,
+    bucket_cap_mb: int = 25,
+) -> torch.nn.parallel.DistributedDataParallel:
+    global _cuda_device_index
+
+    if _cuda_device_index == _CPU_DEVICE_INDEX:
+        # CPU-only model, don't specify device
+        return torch.nn.parallel.DistributedDataParallel(
+            model,
+            broadcast_buffers=broadcast_buffers,
+            find_unused_parameters=find_unused_parameters,
+            bucket_cap_mb=bucket_cap_mb,
+        )
+    else:
+        # GPU model
+        return torch.nn.parallel.DistributedDataParallel(
+            model,
+            device_ids=[_cuda_device_index],
+            output_device=_cuda_device_index,
+            broadcast_buffers=broadcast_buffers,
+            find_unused_parameters=find_unused_parameters,
+            bucket_cap_mb=bucket_cap_mb,
+        )
+
+
+def broadcast_object(obj: Any, src: int = _PRIMARY_RANK, use_disk: bool = True) -> Any:
+    """Broadcast an object from a source to all workers.
+
+    Args:
+        obj: Object to broadcast, must be serializable
+        src: Source rank for broadcast (default is primary)
+        use_disk: If enabled, removes redundant CPU memory copies by writing to
+            disk
+    """
+    # Either broadcast from primary to the fleet (default),
+    # or use the src setting as the original rank
+    if get_rank() == src:
+        # Emit data
+        buffer = io.BytesIO()
+        torch.save(obj, buffer)
+        data_view = buffer.getbuffer()
+        length_tensor = torch.LongTensor([len(data_view)])
+        length_tensor = broadcast(length_tensor, src=src)
+        data_tensor = torch.ByteTensor(data_view)
+        data_tensor = broadcast(data_tensor, src=src)
+    else:
+        # Fetch from the source
+        length_tensor = torch.LongTensor([0])
+        length_tensor = broadcast(length_tensor, src=src)
+        data_tensor = torch.empty([length_tensor.item()], dtype=torch.uint8)
+        data_tensor = broadcast(data_tensor, src=src)
+        if use_disk:
+            with tempfile.TemporaryFile("r+b") as f:
+                f.write(data_tensor.numpy())
+                # remove reference to the data tensor and hope that Python garbage
+                # collects it
+                del data_tensor
+                f.seek(0)
+                obj = torch.load(f, weights_only=False)
+        else:
+            buffer = io.BytesIO(data_tensor.numpy())
+            obj = torch.load(buffer, weights_only=False)
+    return obj
+
+
+def all_gather_tensor(tensor: torch.Tensor, world_size=None):
+    if world_size is None:
+        world_size = get_world_size()
+    # make contiguous because NCCL won't gather the tensor otherwise
+    assert tensor.is_contiguous(), f"{tensor.shape} is not contiguous!"
+    tensor, orig_device = convert_to_distributed_tensor(tensor)
+    tensor_all = [torch.ones_like(tensor) for _ in range(world_size)]
+    dist.all_gather(tensor_all, tensor, async_op=False)  # performance opt
+    tensor_all = [
+        convert_to_normal_tensor(tensor, orig_device) for tensor in tensor_all
+    ]
+    return tensor_all
+
+
+def all_gather_batch(tensors: List[torch.Tensor]):
+    """
+    Performs all_gather operation on the provided tensors.
+    """
+    # Queue the gathered tensors
+    world_size = get_world_size()
+    # There is no need for reduction in the single-proc case
+    if world_size == 1:
+        return tensors
+    tensor_list = []
+    output_tensor = []
+    for tensor in tensors:
+        tensor_all = all_gather_tensor(tensor, world_size)
+        tensor_list.append(tensor_all)
+
+    for tensor_all in tensor_list:
+        output_tensor.append(torch.cat(tensor_all, dim=0))
+    return output_tensor
+
+
+class GatherLayer(autograd.Function):
+    """
+    Gather tensors from all workers with support for backward propagation:
+    This implementation does not cut the gradients as torch.distributed.all_gather does.
+    """
+
+    @staticmethod
+    def forward(ctx, x):
+        output = [torch.zeros_like(x) for _ in range(dist.get_world_size())]
+        dist.all_gather(output, x)
+        return tuple(output)
+
+    @staticmethod
+    def backward(ctx, *grads):
+        all_gradients = torch.stack(grads)
+        dist.all_reduce(all_gradients)
+        return all_gradients[dist.get_rank()]
+
+
+def all_gather_batch_with_grad(tensors):
+    """
+    Performs all_gather operation on the provided tensors.
+    Graph remains connected for backward grad computation.
+    """
+    # Queue the gathered tensors
+    world_size = get_world_size()
+    # There is no need for reduction in the single-proc case
+    if world_size == 1:
+        return tensors
+    tensor_list = []
+    output_tensor = []
+
+    for tensor in tensors:
+        tensor_all = GatherLayer.apply(tensor)
+        tensor_list.append(tensor_all)
+
+    for tensor_all in tensor_list:
+        output_tensor.append(torch.cat(tensor_all, dim=0))
+    return output_tensor
+
+
+def unwrap_ddp_if_wrapped(model):
+    if isinstance(model, torch.nn.parallel.DistributedDataParallel):
+        return model.module
+    return model
+
+
+def create_new_process_group(group_size):
+    """
+    Creates process groups of a gives `group_size` and returns
+    process group that current GPU participates in.
+
+    `group_size` must divide the total number of GPUs (world_size).
+
+    Modified from
+    https://github.com/NVIDIA/apex/blob/4e1ae43f7f7ac69113ef426dd15f37123f0a2ed3/apex/parallel/__init__.py#L60
+
+    Args:
+        group_size (int): number of GPU's to collaborate for sync bn
+    """
+
+    assert group_size > 0
+
+    world_size = torch.distributed.get_world_size()
+    if world_size <= 8:
+        if group_size > world_size:
+            logging.warning(
+                f"Requested group size [{group_size}] > world size [{world_size}]. "
+                "Assuming local debug run and capping it to world size."
+            )
+            group_size = world_size
+    assert world_size >= group_size
+    assert world_size % group_size == 0
+
+    group = None
+    for group_num in range(world_size // group_size):
+        group_ids = range(group_num * group_size, (group_num + 1) * group_size)
+        cur_group = torch.distributed.new_group(ranks=group_ids)
+        if torch.distributed.get_rank() // group_size == group_num:
+            group = cur_group
+            # can not drop out and return here, every process must go through creation of all subgroups
+
+    assert group is not None
+    return group
+
+
+def is_dist_avail_and_initialized():
+    if not dist.is_available():
+        return False
+    if not dist.is_initialized():
+        return False
+    return True
+
+
+def gather_to_rank_0_via_filesys(data, filesys_save_dir=None):
+    """
+    Gather any picklable data to rank 0 via filesystem, using all_gather_via_filesys.
+    """
+    return all_gather_via_filesys(data, filesys_save_dir, gather_to_rank_0_only=True)

之前的代码版本/HuatuoGPT-Vision/MedSAM3/sam3/train/utils/logger.py

@@ -0,0 +1,241 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+import atexit
+import functools
+import logging
+import sys
+import uuid
+from typing import Any, Dict, Optional, Union
+
+from hydra.utils import instantiate
+
+from iopath.common.file_io import g_pathmgr
+from numpy import ndarray
+
+from sam3.train.utils.train_utils import get_machine_local_and_dist_rank, makedir
+from torch import Tensor
+from torch.utils.tensorboard import SummaryWriter
+
+Scalar = Union[Tensor, ndarray, int, float]
+
+
+def make_tensorboard_logger(log_dir: str, **writer_kwargs: Any):
+    makedir(log_dir)
+    summary_writer_method = SummaryWriter
+    return TensorBoardLogger(
+        path=log_dir, summary_writer_method=summary_writer_method, **writer_kwargs
+    )
+
+
+class TensorBoardWriterWrapper:
+    """
+    A wrapper around a SummaryWriter object.
+    """
+
+    def __init__(
+        self,
+        path: str,
+        *args: Any,
+        filename_suffix: str = None,
+        summary_writer_method: Any = SummaryWriter,
+        **kwargs: Any,
+    ) -> None:
+        """Create a new TensorBoard logger.
+        On construction, the logger creates a new events file that logs
+        will be written to.  If the environment variable `RANK` is defined,
+        logger will only log if RANK = 0.
+
+        NOTE: If using the logger with distributed training:
+        - This logger can call collective operations
+        - Logs will be written on rank 0 only
+        - Logger must be constructed synchronously *after* initializing distributed process group.
+
+        Args:
+            path (str): path to write logs to
+            *args, **kwargs: Extra arguments to pass to SummaryWriter
+        """
+        self._writer: Optional[SummaryWriter] = None
+        _, self._rank = get_machine_local_and_dist_rank()
+        self._path: str = path
+        if self._rank == 0:
+            logging.info(
+                f"TensorBoard SummaryWriter instantiated. Files will be stored in: {path}"
+            )
+            self._writer = summary_writer_method(
+                log_dir=path,
+                *args,
+                filename_suffix=filename_suffix or str(uuid.uuid4()),
+                **kwargs,
+            )
+        else:
+            logging.debug(
+                f"Not logging meters on this host because env RANK: {self._rank} != 0"
+            )
+        atexit.register(self.close)
+
+    @property
+    def writer(self) -> Optional[SummaryWriter]:
+        return self._writer
+
+    @property
+    def path(self) -> str:
+        return self._path
+
+    def flush(self) -> None:
+        """Writes pending logs to disk."""
+
+        if not self._writer:
+            return
+
+        self._writer.flush()
+
+    def close(self) -> None:
+        """Close writer, flushing pending logs to disk.
+        Logs cannot be written after `close` is called.
+        """
+
+        if not self._writer:
+            return
+
+        self._writer.close()
+        self._writer = None
+
+
+class TensorBoardLogger(TensorBoardWriterWrapper):
+    """
+    A simple logger for TensorBoard.
+    """
+
+    def log_dict(self, payload: Dict[str, Scalar], step: int) -> None:
+        """Add multiple scalar values to TensorBoard.
+
+        Args:
+            payload (dict): dictionary of tag name and scalar value
+            step (int, Optional): step value to record
+        """
+        if not self._writer:
+            return
+        for k, v in payload.items():
+            self.log(k, v, step)
+
+    def log(self, name: str, data: Scalar, step: int) -> None:
+        """Add scalar data to TensorBoard.
+
+        Args:
+            name (string): tag name used to group scalars
+            data (float/int/Tensor): scalar data to log
+            step (int, optional): step value to record
+        """
+        if not self._writer:
+            return
+        self._writer.add_scalar(name, data, global_step=step, new_style=True)
+
+    def log_hparams(
+        self, hparams: Dict[str, Scalar], meters: Dict[str, Scalar]
+    ) -> None:
+        """Add hyperparameter data to TensorBoard.
+
+        Args:
+            hparams (dict): dictionary of hyperparameter names and corresponding values
+            meters (dict): dictionary of name of meter and corersponding values
+        """
+        if not self._writer:
+            return
+        self._writer.add_hparams(hparams, meters)
+
+
+class Logger:
+    """
+    A logger class that can interface with multiple loggers. It now supports tensorboard only for simplicity, but you can extend it with your own logger.
+    """
+
+    def __init__(self, logging_conf):
+        # allow turning off TensorBoard with "should_log: false" in config
+        tb_config = logging_conf.tensorboard_writer
+        tb_should_log = tb_config and tb_config.pop("should_log", True)
+        self.tb_logger = instantiate(tb_config) if tb_should_log else None
+
+    def log_dict(self, payload: Dict[str, Scalar], step: int) -> None:
+        if self.tb_logger:
+            self.tb_logger.log_dict(payload, step)
+
+    def log(self, name: str, data: Scalar, step: int) -> None:
+        if self.tb_logger:
+            self.tb_logger.log(name, data, step)
+
+    def log_hparams(
+        self, hparams: Dict[str, Scalar], meters: Dict[str, Scalar]
+    ) -> None:
+        if self.tb_logger:
+            self.tb_logger.log_hparams(hparams, meters)
+
+
+# cache the opened file object, so that different calls to `setup_logger`
+# with the same file name can safely write to the same file.
+@functools.lru_cache(maxsize=None)
+def _cached_log_stream(filename):
+    # we tune the buffering value so that the logs are updated
+    # frequently.
+    log_buffer_kb = 10 * 1024  # 10KB
+    io = g_pathmgr.open(filename, mode="a", buffering=log_buffer_kb)
+    atexit.register(io.close)
+    return io
+
+
+def setup_logging(
+    name,
+    output_dir=None,
+    rank=0,
+    log_level_primary="INFO",
+    log_level_secondary="ERROR",
+):
+    """
+    Setup various logging streams: stdout and file handlers.
+    For file handlers, we only setup for the master gpu.
+    """
+    # get the filename if we want to log to the file as well
+    log_filename = None
+    if output_dir:
+        makedir(output_dir)
+        if rank == 0:
+            log_filename = f"{output_dir}/log.txt"
+
+    logger = logging.getLogger(name)
+    logger.setLevel(log_level_primary)
+
+    # create formatter
+    FORMAT = "%(levelname)s %(asctime)s %(filename)s:%(lineno)4d: %(message)s"
+    formatter = logging.Formatter(FORMAT)
+
+    # Cleanup any existing handlers
+    for h in logger.handlers:
+        logger.removeHandler(h)
+    logger.root.handlers = []
+
+    # setup the console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+    if rank == 0:
+        console_handler.setLevel(log_level_primary)
+    else:
+        console_handler.setLevel(log_level_secondary)
+
+    # we log to file as well if user wants
+    if log_filename and rank == 0:
+        file_handler = logging.StreamHandler(_cached_log_stream(log_filename))
+        file_handler.setLevel(log_level_primary)
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+
+    logging.root = logger
+
+
+def shutdown_logging():
+    """
+    After training is done, we ensure to shut down all the logger streams.
+    """
+    logging.info("Shutting down loggers...")
+    handlers = logging.root.handlers
+    for handler in handlers:
+        handler.close()

之前的代码版本/HuatuoGPT-Vision/MedSAM3/sam3/train/utils/train_utils.py

@@ -0,0 +1,285 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+
+import logging
+import math
+import os
+import random
+import re
+from datetime import timedelta
+from typing import Optional
+
+import hydra
+
+import numpy as np
+import omegaconf
+import torch
+import torch.distributed as dist
+from iopath.common.file_io import g_pathmgr
+from omegaconf import OmegaConf
+
+
+def multiply_all(*args):
+    return np.prod(np.array(args)).item()
+
+
+def collect_dict_keys(config):
+    """This function recursively iterates through a dataset configuration, and collect all the dict_key that are defined"""
+    val_keys = []
+    # If the this config points to the collate function, then it has a key
+    if "_target_" in config and re.match(r".*collate_fn.*", config["_target_"]):
+        val_keys.append(config["dict_key"])
+    else:
+        # Recursively proceed
+        for v in config.values():
+            if isinstance(v, type(config)):
+                val_keys.extend(collect_dict_keys(v))
+            elif isinstance(v, omegaconf.listconfig.ListConfig):
+                for item in v:
+                    if isinstance(item, type(config)):
+                        val_keys.extend(collect_dict_keys(item))
+    return val_keys
+
+
+class Phase:
+    TRAIN = "train"
+    VAL = "val"
+
+
+def register_omegaconf_resolvers():
+    OmegaConf.register_new_resolver("get_method", hydra.utils.get_method)
+    OmegaConf.register_new_resolver("get_class", hydra.utils.get_class)
+    OmegaConf.register_new_resolver("add", lambda x, y: x + y)
+    OmegaConf.register_new_resolver("times", multiply_all)
+    OmegaConf.register_new_resolver("divide", lambda x, y: x / y)
+    OmegaConf.register_new_resolver("pow", lambda x, y: x**y)
+    OmegaConf.register_new_resolver("subtract", lambda x, y: x - y)
+    OmegaConf.register_new_resolver("range", lambda x: list(range(x)))
+    OmegaConf.register_new_resolver("int", lambda x: int(x))
+    OmegaConf.register_new_resolver("ceil_int", lambda x: int(math.ceil(x)))
+    OmegaConf.register_new_resolver("merge", lambda *x: OmegaConf.merge(*x))
+    OmegaConf.register_new_resolver("string", lambda x: str(x))
+
+
+def setup_distributed_backend(backend, timeout_mins):
+    """
+    Initialize torch.distributed and set the CUDA device.
+    Expects environment variables to be set as per
+    https://pytorch.org/docs/stable/distributed.html#environment-variable-initialization
+    along with the environ variable "LOCAL_RANK" which is used to set the CUDA device.
+    """
+    # enable TORCH_NCCL_ASYNC_ERROR_HANDLING to ensure dist nccl ops time out after timeout_mins
+    # of waiting
+    os.environ["TORCH_NCCL_ASYNC_ERROR_HANDLING"] = "1"
+    logging.info(f"Setting up torch.distributed with a timeout of {timeout_mins} mins")
+    dist.init_process_group(backend=backend, timeout=timedelta(minutes=timeout_mins))
+    return dist.get_rank()
+
+
+def get_machine_local_and_dist_rank():
+    """
+    Get the distributed and local rank of the current gpu.
+    """
+    local_rank = int(os.environ.get("LOCAL_RANK", None))
+    distributed_rank = int(os.environ.get("RANK", None))
+    assert (
+        local_rank is not None and distributed_rank is not None
+    ), "Please the set the RANK and LOCAL_RANK environment variables."
+    return local_rank, distributed_rank
+
+
+def print_cfg(cfg):
+    """
+    Supports printing both Hydra DictConfig and also the AttrDict config
+    """
+    logging.info("Training with config:")
+    logging.info(OmegaConf.to_yaml(cfg))
+
+
+def set_seeds(seed_value, max_epochs, dist_rank):
+    """
+    Set the python random, numpy and torch seed for each gpu. Also set the CUDA
+    seeds if the CUDA is available. This ensures deterministic nature of the training.
+    """
+    # Since in the pytorch sampler, we increment the seed by 1 for every epoch.
+    seed_value = (seed_value + dist_rank) * max_epochs
+    logging.info(f"MACHINE SEED: {seed_value}")
+    random.seed(seed_value)
+    np.random.seed(seed_value)
+    torch.manual_seed(seed_value)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed_value)
+
+
+def makedir(dir_path):
+    """
+    Create the directory if it does not exist.
+    """
+    is_success = False
+    try:
+        if not g_pathmgr.exists(dir_path):
+            g_pathmgr.mkdirs(dir_path)
+        is_success = True
+    except BaseException:
+        logging.info(f"Error creating directory: {dir_path}")
+    return is_success
+
+
+def is_dist_avail_and_initialized():
+    if not dist.is_available():
+        return False
+    if not dist.is_initialized():
+        return False
+    return True
+
+
+def get_amp_type(amp_type: Optional[str] = None):
+    if amp_type is None:
+        return None
+    assert amp_type in ["bfloat16", "float16"], "Invalid Amp type."
+    if amp_type == "bfloat16":
+        return torch.bfloat16
+    else:
+        return torch.float16
+
+
+def log_env_variables():
+    env_keys = sorted(list(os.environ.keys()))
+    st = ""
+    for k in env_keys:
+        v = os.environ[k]
+        st += f"{k}={v}\n"
+    logging.info("Logging ENV_VARIABLES")
+    logging.info(st)
+
+
+class AverageMeter:
+    """Computes and stores the average and current value"""
+
+    def __init__(self, name, device, fmt=":f"):
+        self.name = name
+        self.fmt = fmt
+        self.device = device
+        self.reset()
+
+    def reset(self):
+        self.val = 0
+        self.avg = 0
+        self.sum = 0
+        self.count = 0
+        self._allow_updates = True
+
+    def update(self, val, n=1):
+        self.val = val
+        self.sum += val * n
+        self.count += n
+        self.avg = self.sum / self.count
+
+    def __str__(self):
+        fmtstr = "{name}: {val" + self.fmt + "} ({avg" + self.fmt + "})"
+        return fmtstr.format(**self.__dict__)
+
+
+class MemMeter:
+    """Computes and stores the current, avg, and max of peak Mem usage per iteration"""
+
+    def __init__(self, name, device, fmt=":f"):
+        self.name = name
+        self.fmt = fmt
+        self.device = device
+        self.reset()
+
+    def reset(self):
+        self.val = 0  # Per iteration max usage
+        self.avg = 0  # Avg per iteration max usage
+        self.peak = 0  # Peak usage for lifetime of program
+        self.sum = 0
+        self.count = 0
+        self._allow_updates = True
+
+    def update(self, n=1, reset_peak_usage=True):
+        self.val = torch.cuda.max_memory_allocated() // 1e9
+        self.sum += self.val * n
+        self.count += n
+        self.avg = self.sum / self.count
+        self.peak = max(self.peak, self.val)
+        if reset_peak_usage:
+            torch.cuda.reset_peak_memory_stats()
+
+    def __str__(self):
+        fmtstr = (
+            "{name}: {val"
+            + self.fmt
+            + "} ({avg"
+            + self.fmt
+            + "}/{peak"
+            + self.fmt
+            + "})"
+        )
+        return fmtstr.format(**self.__dict__)
+
+
+def human_readable_time(time_seconds):
+    time = int(time_seconds)
+    minutes, seconds = divmod(time, 60)
+    hours, minutes = divmod(minutes, 60)
+    days, hours = divmod(hours, 24)
+    return f"{days:02}d {hours:02}h {minutes:02}m"
+
+
+class DurationMeter:
+    def __init__(self, name, device, fmt=":f"):
+        self.name = name
+        self.device = device
+        self.fmt = fmt
+        self.val = 0
+
+    def reset(self):
+        self.val = 0
+
+    def update(self, val):
+        self.val = val
+
+    def add(self, val):
+        self.val += val
+
+    def __str__(self):
+        return f"{self.name}: {human_readable_time(self.val)}"
+
+
+class ProgressMeter:
+    def __init__(self, num_batches, meters, real_meters, prefix=""):
+        self.batch_fmtstr = self._get_batch_fmtstr(num_batches)
+        self.meters = meters
+        self.real_meters = real_meters
+        self.prefix = prefix
+
+    def display(self, batch, enable_print=False):
+        entries = [self.prefix + self.batch_fmtstr.format(batch)]
+        entries += [str(meter) for meter in self.meters]
+        entries += [
+            " | ".join(
+                [
+                    f"{os.path.join(name, subname)}: {val:.4f}"
+                    for subname, val in meter.compute().items()
+                ]
+            )
+            for name, meter in self.real_meters.items()
+        ]
+        logging.info(" | ".join(entries))
+        if enable_print:
+            print(" | ".join(entries))
+
+    def _get_batch_fmtstr(self, num_batches):
+        num_digits = len(str(num_batches // 1))
+        fmt = "{:" + str(num_digits) + "d}"
+        return "[" + fmt + "/" + fmt.format(num_batches) + "]"
+
+
+def get_resume_checkpoint(checkpoint_save_dir):
+    if not g_pathmgr.isdir(checkpoint_save_dir):
+        return None
+    ckpt_file = os.path.join(checkpoint_save_dir, "checkpoint.pt")
+    if not g_pathmgr.isfile(ckpt_file):
+        return None
+
+    return ckpt_file

之前的代码版本/HuatuoGPT-Vision/MedSAM3/sam3/visualization_utils.py

@@ -0,0 +1,941 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates. All Rights Reserved
+import json
+import os
+import subprocess
+from pathlib import Path
+
+import cv2
+import matplotlib.patches as patches
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import pycocotools.mask as mask_utils
+import torch
+from matplotlib.colors import to_rgb
+from PIL import Image
+from skimage.color import lab2rgb, rgb2lab
+from sklearn.cluster import KMeans
+from torchvision.ops import masks_to_boxes
+from tqdm import tqdm
+
+
+def generate_colors(n_colors=256, n_samples=5000):
+    # Step 1: Random RGB samples
+    np.random.seed(42)
+    rgb = np.random.rand(n_samples, 3)
+    # Step 2: Convert to LAB for perceptual uniformity
+    # print(f"Converting {n_samples} RGB samples to LAB color space...")
+    lab = rgb2lab(rgb.reshape(1, -1, 3)).reshape(-1, 3)
+    # print("Conversion to LAB complete.")
+    # Step 3: k-means clustering in LAB
+    kmeans = KMeans(n_clusters=n_colors, n_init=10)
+    # print(f"Fitting KMeans with {n_colors} clusters on {n_samples} samples...")
+    kmeans.fit(lab)
+    # print("KMeans fitting complete.")
+    centers_lab = kmeans.cluster_centers_
+    # Step 4: Convert LAB back to RGB
+    colors_rgb = lab2rgb(centers_lab.reshape(1, -1, 3)).reshape(-1, 3)
+    colors_rgb = np.clip(colors_rgb, 0, 1)
+    return colors_rgb
+
+
+COLORS = generate_colors(n_colors=128, n_samples=5000)
+
+
+def show_img_tensor(img_batch, vis_img_idx=0):
+    MEAN_IMG = np.array([0.5, 0.5, 0.5])
+    STD_IMG = np.array([0.5, 0.5, 0.5])
+    im_tensor = img_batch[vis_img_idx].detach().cpu()
+    assert im_tensor.dim() == 3
+    im_tensor = im_tensor.numpy().transpose((1, 2, 0))
+    im_tensor = (im_tensor * STD_IMG) + MEAN_IMG
+    im_tensor = np.clip(im_tensor, 0, 1)
+    plt.imshow(im_tensor)
+
+
+def draw_box_on_image(image, box, color=(0, 255, 0)):
+    """
+    Draws a rectangle on a given PIL image using the provided box coordinates in xywh format.
+    :param image: PIL.Image - The image on which to draw the rectangle.
+    :param box: tuple - A tuple (x, y, w, h) representing the top-left corner, width, and height of the rectangle.
+    :param color: tuple - A tuple (R, G, B) representing the color of the rectangle. Default is red.
+    :return: PIL.Image - The image with the rectangle drawn on it.
+    """
+    # Ensure the image is in RGB mode
+    image = image.convert("RGB")
+    # Unpack the box coordinates
+    x, y, w, h = box
+    x, y, w, h = int(x), int(y), int(w), int(h)
+    # Get the pixel data
+    pixels = image.load()
+    # Draw the top and bottom edges
+    for i in range(x, x + w):
+        pixels[i, y] = color
+        pixels[i, y + h - 1] = color
+        pixels[i, y + 1] = color
+        pixels[i, y + h] = color
+        pixels[i, y - 1] = color
+        pixels[i, y + h - 2] = color
+    # Draw the left and right edges
+    for j in range(y, y + h):
+        pixels[x, j] = color
+        pixels[x + 1, j] = color
+        pixels[x - 1, j] = color
+        pixels[x + w - 1, j] = color
+        pixels[x + w, j] = color
+        pixels[x + w - 2, j] = color
+    return image
+
+
+def plot_bbox(
+    img_height,
+    img_width,
+    box,
+    box_format="XYXY",
+    relative_coords=True,
+    color="r",
+    linestyle="solid",
+    text=None,
+    ax=None,
+):
+    if box_format == "XYXY":
+        x, y, x2, y2 = box
+        w = x2 - x
+        h = y2 - y
+    elif box_format == "XYWH":
+        x, y, w, h = box
+    elif box_format == "CxCyWH":
+        cx, cy, w, h = box
+        x = cx - w / 2
+        y = cy - h / 2
+    else:
+        raise RuntimeError(f"Invalid box_format {box_format}")
+
+    if relative_coords:
+        x *= img_width
+        w *= img_width
+        y *= img_height
+        h *= img_height
+
+    if ax is None:
+        ax = plt.gca()
+    rect = patches.Rectangle(
+        (x, y),
+        w,
+        h,
+        linewidth=1.5,
+        edgecolor=color,
+        facecolor="none",
+        linestyle=linestyle,
+    )
+    ax.add_patch(rect)
+    if text is not None:
+        facecolor = "w"
+        ax.text(
+            x,
+            y - 5,
+            text,
+            color=color,
+            weight="bold",
+            fontsize=8,
+            bbox={"facecolor": facecolor, "alpha": 0.75, "pad": 2},
+        )
+
+
+def plot_mask(mask, color="r", ax=None):
+    im_h, im_w = mask.shape
+    mask_img = np.zeros((im_h, im_w, 4), dtype=np.float32)
+    mask_img[..., :3] = to_rgb(color)
+    mask_img[..., 3] = mask * 0.5
+    # Use the provided ax or the current axis
+    if ax is None:
+        ax = plt.gca()
+    ax.imshow(mask_img)
+
+
+def normalize_bbox(bbox_xywh, img_w, img_h):
+    # Assumes bbox_xywh is in XYWH format
+    if isinstance(bbox_xywh, list):
+        assert (
+            len(bbox_xywh) == 4
+        ), "bbox_xywh list must have 4 elements. Batching not support except for torch tensors."
+        normalized_bbox = bbox_xywh.copy()
+        normalized_bbox[0] /= img_w
+        normalized_bbox[1] /= img_h
+        normalized_bbox[2] /= img_w
+        normalized_bbox[3] /= img_h
+    else:
+        assert isinstance(
+            bbox_xywh, torch.Tensor
+        ), "Only torch tensors are supported for batching."
+        normalized_bbox = bbox_xywh.clone()
+        assert (
+            normalized_bbox.size(-1) == 4
+        ), "bbox_xywh tensor must have last dimension of size 4."
+        normalized_bbox[..., 0] /= img_w
+        normalized_bbox[..., 1] /= img_h
+        normalized_bbox[..., 2] /= img_w
+        normalized_bbox[..., 3] /= img_h
+    return normalized_bbox
+
+
+def visualize_frame_output(frame_idx, video_frames, outputs, figsize=(12, 8)):
+    plt.figure(figsize=figsize)
+    plt.title(f"frame {frame_idx}")
+    img = load_frame(video_frames[frame_idx])
+    img_H, img_W, _ = img.shape
+    plt.imshow(img)
+    for i in range(len(outputs["out_probs"])):
+        box_xywh = outputs["out_boxes_xywh"][i]
+        prob = outputs["out_probs"][i]
+        obj_id = outputs["out_obj_ids"][i]
+        binary_mask = outputs["out_binary_masks"][i]
+        color = COLORS[obj_id % len(COLORS)]
+        plot_bbox(
+            img_H,
+            img_W,
+            box_xywh,
+            text=f"(id={obj_id}, {prob=:.2f})",
+            box_format="XYWH",
+            color=color,
+        )
+        plot_mask(binary_mask, color=color)
+
+
+def visualize_formatted_frame_output(
+    frame_idx,
+    video_frames,
+    outputs_list,
+    titles=None,
+    points_list=None,
+    points_labels_list=None,
+    figsize=(12, 8),
+    title_suffix="",
+    prompt_info=None,
+):
+    """Visualize up to three sets of segmentation masks on a video frame.
+
+    Args:
+        frame_idx: Frame index to visualize
+        image_files: List of image file paths
+        outputs_list: List of {frame_idx: {obj_id: mask_tensor}} or single dict {obj_id: mask_tensor}
+        titles: List of titles for each set of outputs_list
+        points_list: Optional list of point coordinates
+        points_labels_list: Optional list of point labels
+        figsize: Figure size tuple
+        save: Whether to save the visualization to file
+        output_dir: Base output directory when saving
+        scenario_name: Scenario name for organizing saved files
+        title_suffix: Additional title suffix
+        prompt_info: Dictionary with prompt information (boxes, points, etc.)
+    """
+    # Handle single output dict case
+    if isinstance(outputs_list, dict) and frame_idx in outputs_list:
+        # This is a single outputs dict with frame indices as keys
+        outputs_list = [outputs_list]
+    elif isinstance(outputs_list, dict) and not any(
+        isinstance(k, int) for k in outputs_list.keys()
+    ):
+        # This is a single frame's outputs {obj_id: mask}
+        single_frame_outputs = {frame_idx: outputs_list}
+        outputs_list = [single_frame_outputs]
+
+    num_outputs = len(outputs_list)
+    if titles is None:
+        titles = [f"Set {i+1}" for i in range(num_outputs)]
+    assert (
+        len(titles) == num_outputs
+    ), "length of `titles` should match that of `outputs_list` if not None."
+
+    _, axes = plt.subplots(1, num_outputs, figsize=figsize)
+    if num_outputs == 1:
+        axes = [axes]  # Make it iterable
+
+    img = load_frame(video_frames[frame_idx])
+    img_H, img_W, _ = img.shape
+
+    for idx in range(num_outputs):
+        ax, outputs_set, ax_title = axes[idx], outputs_list[idx], titles[idx]
+        ax.set_title(f"Frame {frame_idx} - {ax_title}{title_suffix}")
+        ax.imshow(img)
+
+        if frame_idx in outputs_set:
+            _outputs = outputs_set[frame_idx]
+        else:
+            print(f"Warning: Frame {frame_idx} not found in outputs_set")
+            continue
+
+        if prompt_info and frame_idx == 0:  # Show prompts on first frame
+            if "boxes" in prompt_info:
+                for box in prompt_info["boxes"]:
+                    # box is in [x, y, w, h] normalized format
+                    x, y, w, h = box
+                    plot_bbox(
+                        img_H,
+                        img_W,
+                        [x, y, x + w, y + h],  # Convert to XYXY
+                        box_format="XYXY",
+                        relative_coords=True,
+                        color="yellow",
+                        linestyle="dashed",
+                        text="PROMPT BOX",
+                        ax=ax,
+                    )
+
+            if "points" in prompt_info and "point_labels" in prompt_info:
+                points = np.array(prompt_info["points"])
+                labels = np.array(prompt_info["point_labels"])
+                # Convert normalized to pixel coordinates
+                points_pixel = points * np.array([img_W, img_H])
+
+                # Draw positive points (green stars)
+                pos_points = points_pixel[labels == 1]
+                if len(pos_points) > 0:
+                    ax.scatter(
+                        pos_points[:, 0],
+                        pos_points[:, 1],
+                        color="lime",
+                        marker="*",
+                        s=200,
+                        edgecolor="white",
+                        linewidth=2,
+                        label="Positive Points",
+                        zorder=10,
+                    )
+
+                # Draw negative points (red stars)
+                neg_points = points_pixel[labels == 0]
+                if len(neg_points) > 0:
+                    ax.scatter(
+                        neg_points[:, 0],
+                        neg_points[:, 1],
+                        color="red",
+                        marker="*",
+                        s=200,
+                        edgecolor="white",
+                        linewidth=2,
+                        label="Negative Points",
+                        zorder=10,
+                    )
+
+        objects_drawn = 0
+        for obj_id, binary_mask in _outputs.items():
+            mask_sum = (
+                binary_mask.sum()
+                if hasattr(binary_mask, "sum")
+                else np.sum(binary_mask)
+            )
+
+            if mask_sum > 0:  # Only draw if mask has content
+                # Convert to torch tensor if it's not already
+                if not isinstance(binary_mask, torch.Tensor):
+                    binary_mask = torch.tensor(binary_mask)
+
+                # Find bounding box from mask
+                if binary_mask.any():
+                    box_xyxy = masks_to_boxes(binary_mask.unsqueeze(0)).squeeze()
+                    box_xyxy = normalize_bbox(box_xyxy, img_W, img_H)
+                else:
+                    # Fallback: create a small box at center
+                    box_xyxy = [0.45, 0.45, 0.55, 0.55]
+
+                color = COLORS[obj_id % len(COLORS)]
+
+                plot_bbox(
+                    img_H,
+                    img_W,
+                    box_xyxy,
+                    text=f"(id={obj_id})",
+                    box_format="XYXY",
+                    color=color,
+                    ax=ax,
+                )
+
+                # Convert back to numpy for plotting
+                mask_np = (
+                    binary_mask.numpy()
+                    if isinstance(binary_mask, torch.Tensor)
+                    else binary_mask
+                )
+                plot_mask(mask_np, color=color, ax=ax)
+                objects_drawn += 1
+
+        if objects_drawn == 0:
+            ax.text(
+                0.5,
+                0.5,
+                "No objects detected",
+                transform=ax.transAxes,
+                fontsize=16,
+                ha="center",
+                va="center",
+                color="red",
+                weight="bold",
+            )
+
+        # Draw additional points if provided
+        if points_list is not None and points_list[idx] is not None:
+            show_points(
+                points_list[idx], points_labels_list[idx], ax=ax, marker_size=200
+            )
+
+        ax.axis("off")
+
+    plt.tight_layout()
+    plt.show()
+
+
+def render_masklet_frame(img, outputs, frame_idx=None, alpha=0.5):
+    """
+    Overlays masklets and bounding boxes on a single image frame.
+    Args:
+        img: np.ndarray, shape (H, W, 3), uint8 or float32 in [0,255] or [0,1]
+        outputs: dict with keys: out_boxes_xywh, out_probs, out_obj_ids, out_binary_masks
+        frame_idx: int or None, for overlaying frame index text
+        alpha: float, mask overlay alpha
+    Returns:
+        overlay: np.ndarray, shape (H, W, 3), uint8
+    """
+    if img.dtype == np.float32 or img.max() <= 1.0:
+        img = (img * 255).astype(np.uint8)
+    img = img[..., :3]  # drop alpha if present
+    height, width = img.shape[:2]
+    overlay = img.copy()
+
+    for i in range(len(outputs["out_probs"])):
+        obj_id = outputs["out_obj_ids"][i]
+        color = COLORS[obj_id % len(COLORS)]
+        color255 = (color * 255).astype(np.uint8)
+        mask = outputs["out_binary_masks"][i]
+        if mask.shape != img.shape[:2]:
+            mask = cv2.resize(
+                mask.astype(np.float32),
+                (img.shape[1], img.shape[0]),
+                interpolation=cv2.INTER_NEAREST,
+            )
+        mask_bool = mask > 0.5
+        for c in range(3):
+            overlay[..., c][mask_bool] = (
+                alpha * color255[c] + (1 - alpha) * overlay[..., c][mask_bool]
+            ).astype(np.uint8)
+
+    # Draw bounding boxes and text
+    for i in range(len(outputs["out_probs"])):
+        box_xywh = outputs["out_boxes_xywh"][i]
+        obj_id = outputs["out_obj_ids"][i]
+        prob = outputs["out_probs"][i]
+        color = COLORS[obj_id % len(COLORS)]
+        color255 = tuple(int(x * 255) for x in color)
+        x, y, w, h = box_xywh
+        x1 = int(x * width)
+        y1 = int(y * height)
+        x2 = int((x + w) * width)
+        y2 = int((y + h) * height)
+        cv2.rectangle(overlay, (x1, y1), (x2, y2), color255, 2)
+        if prob is not None:
+            label = f"id={obj_id}, p={prob:.2f}"
+        else:
+            label = f"id={obj_id}"
+        cv2.putText(
+            overlay,
+            label,
+            (x1, max(y1 - 10, 0)),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            0.5,
+            color255,
+            1,
+            cv2.LINE_AA,
+        )
+
+    # Overlay frame index at the top-left corner
+    if frame_idx is not None:
+        cv2.putText(
+            overlay,
+            f"Frame {frame_idx}",
+            (10, 30),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            1.0,
+            (255, 255, 255),
+            2,
+            cv2.LINE_AA,
+        )
+
+    return overlay
+
+
+def save_masklet_video(video_frames, outputs, out_path, alpha=0.5, fps=10):
+    # Each outputs dict has keys: "out_boxes_xywh", "out_probs", "out_obj_ids", "out_binary_masks"
+    # video_frames: list of video frame data, same length as outputs_list
+
+    # Read first frame to get size
+    first_img = load_frame(video_frames[0])
+    height, width = first_img.shape[:2]
+    if first_img.dtype == np.float32 or first_img.max() <= 1.0:
+        first_img = (first_img * 255).astype(np.uint8)
+    # Use 'mp4v' for best compatibility with VSCode playback (.mp4 files)
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+    writer = cv2.VideoWriter("temp.mp4", fourcc, fps, (width, height))
+
+    outputs_list = [
+        (video_frames[frame_idx], frame_idx, outputs[frame_idx])
+        for frame_idx in sorted(outputs.keys())
+    ]
+
+    for frame, frame_idx, frame_outputs in tqdm(outputs_list):
+        img = load_frame(frame)
+        overlay = render_masklet_frame(
+            img, frame_outputs, frame_idx=frame_idx, alpha=alpha
+        )
+        writer.write(cv2.cvtColor(overlay, cv2.COLOR_RGB2BGR))
+
+    writer.release()
+
+    # Re-encode the video for VSCode compatibility using ffmpeg
+    subprocess.run(["ffmpeg", "-y", "-i", "temp.mp4", out_path])
+    print(f"Re-encoded video saved to {out_path}")
+
+    os.remove("temp.mp4")  # Clean up temporary file
+
+
+def save_masklet_image(frame, outputs, out_path, alpha=0.5, frame_idx=None):
+    """
+    Save a single image with masklet overlays.
+    """
+    img = load_frame(frame)
+    overlay = render_masklet_frame(img, outputs, frame_idx=frame_idx, alpha=alpha)
+    Image.fromarray(overlay).save(out_path)
+    print(f"Overlay image saved to {out_path}")
+
+
+def prepare_masks_for_visualization(frame_to_output):
+    # frame_to_obj_masks --> {frame_idx: {'output_probs': np.array, `out_obj_ids`: np.array, `out_binary_masks`: np.array}}
+    for frame_idx, out in frame_to_output.items():
+        _processed_out = {}
+        for idx, obj_id in enumerate(out["out_obj_ids"].tolist()):
+            if out["out_binary_masks"][idx].any():
+                _processed_out[obj_id] = out["out_binary_masks"][idx]
+        frame_to_output[frame_idx] = _processed_out
+    return frame_to_output
+
+
+def convert_coco_to_masklet_format(
+    annotations, img_info, is_prediction=False, score_threshold=0.5
+):
+    """
+    Convert COCO format annotations to format expected by render_masklet_frame
+    """
+    outputs = {
+        "out_boxes_xywh": [],
+        "out_probs": [],
+        "out_obj_ids": [],
+        "out_binary_masks": [],
+    }
+
+    img_h, img_w = img_info["height"], img_info["width"]
+
+    for idx, ann in enumerate(annotations):
+        # Get bounding box in relative XYWH format
+        if "bbox" in ann:
+            bbox = ann["bbox"]
+            if max(bbox) > 1.0:  # Convert absolute to relative coordinates
+                bbox = [
+                    bbox[0] / img_w,
+                    bbox[1] / img_h,
+                    bbox[2] / img_w,
+                    bbox[3] / img_h,
+                ]
+        else:
+            mask = mask_utils.decode(ann["segmentation"])
+            rows = np.any(mask, axis=1)
+            cols = np.any(mask, axis=0)
+            if np.any(rows) and np.any(cols):
+                rmin, rmax = np.where(rows)[0][[0, -1]]
+                cmin, cmax = np.where(cols)[0][[0, -1]]
+                # Convert to relative XYWH
+                bbox = [
+                    cmin / img_w,
+                    rmin / img_h,
+                    (cmax - cmin + 1) / img_w,
+                    (rmax - rmin + 1) / img_h,
+                ]
+            else:
+                bbox = [0, 0, 0, 0]
+
+        outputs["out_boxes_xywh"].append(bbox)
+
+        # Get probability/score
+        if is_prediction:
+            prob = ann["score"]
+        else:
+            prob = 1.0  # GT has no probability
+        outputs["out_probs"].append(prob)
+
+        outputs["out_obj_ids"].append(idx)
+        mask = mask_utils.decode(ann["segmentation"])
+        mask = (mask > score_threshold).astype(np.uint8)
+
+        outputs["out_binary_masks"].append(mask)
+
+    return outputs
+
+
+def save_side_by_side_visualization(img, gt_anns, pred_anns, noun_phrase):
+    """
+    Create side-by-side visualization of GT and predictions
+    """
+
+    # Create side-by-side visualization
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 7))
+
+    main_title = f"Noun phrase: '{noun_phrase}'"
+    fig.suptitle(main_title, fontsize=16, fontweight="bold")
+
+    gt_overlay = render_masklet_frame(img, gt_anns, alpha=0.5)
+    ax1.imshow(gt_overlay)
+    ax1.set_title("Ground Truth", fontsize=14, fontweight="bold")
+    ax1.axis("off")
+
+    pred_overlay = render_masklet_frame(img, pred_anns, alpha=0.5)
+    ax2.imshow(pred_overlay)
+    ax2.set_title("Predictions", fontsize=14, fontweight="bold")
+    ax2.axis("off")
+
+    plt.subplots_adjust(top=0.88)
+    plt.tight_layout()
+
+
+def bitget(val, idx):
+    return (val >> idx) & 1
+
+
+def pascal_color_map():
+    colormap = np.zeros((512, 3), dtype=int)
+    ind = np.arange(512, dtype=int)
+    for shift in reversed(list(range(8))):
+        for channel in range(3):
+            colormap[:, channel] |= bitget(ind, channel) << shift
+        ind >>= 3
+
+    return colormap.astype(np.uint8)
+
+
+def draw_masks_to_frame(
+    frame: np.ndarray, masks: np.ndarray, colors: np.ndarray
+) -> np.ndarray:
+    masked_frame = frame
+    for mask, color in zip(masks, colors):
+        curr_masked_frame = np.where(mask[..., None], color, masked_frame)
+        masked_frame = cv2.addWeighted(masked_frame, 0.75, curr_masked_frame, 0.25, 0)
+
+        if int(cv2.__version__[0]) > 3:
+            contours, _ = cv2.findContours(
+                np.array(mask, dtype=np.uint8).copy(),
+                cv2.RETR_TREE,
+                cv2.CHAIN_APPROX_NONE,
+            )
+        else:
+            _, contours, _ = cv2.findContours(
+                np.array(mask, dtype=np.uint8).copy(),
+                cv2.RETR_TREE,
+                cv2.CHAIN_APPROX_NONE,
+            )
+
+        cv2.drawContours(
+            masked_frame, contours, -1, (255, 255, 255), 7
+        )  # White outer contour
+        cv2.drawContours(
+            masked_frame, contours, -1, (0, 0, 0), 5
+        )  # Black middle contour
+        cv2.drawContours(
+            masked_frame, contours, -1, color.tolist(), 3
+        )  # Original color inner contour
+    return masked_frame
+
+
+def get_annot_df(file_path: str):
+    with open(file_path, "r") as f:
+        data = json.load(f)
+
+    dfs = {}
+
+    for k, v in data.items():
+        if k in ("info", "licenses"):
+            dfs[k] = v
+            continue
+        df = pd.DataFrame(v)
+        dfs[k] = df
+
+    return dfs
+
+
+def get_annot_dfs(file_list: list[str]):
+    dfs = {}
+    for annot_file in tqdm(file_list):
+        dataset_name = Path(annot_file).stem
+        dfs[dataset_name] = get_annot_df(annot_file)
+
+    return dfs
+
+
+def get_media_dir(media_dir: str, dataset: str):
+    if dataset in ["saco_veval_sav_test", "saco_veval_sav_val"]:
+        return os.path.join(media_dir, "saco_sav", "JPEGImages_24fps")
+    elif dataset in ["saco_veval_yt1b_test", "saco_veval_yt1b_val"]:
+        return os.path.join(media_dir, "saco_yt1b", "JPEGImages_6fps")
+    elif dataset in ["saco_veval_smartglasses_test", "saco_veval_smartglasses_val"]:
+        return os.path.join(media_dir, "saco_sg", "JPEGImages_6fps")
+    elif dataset == "sa_fari_test":
+        return os.path.join(media_dir, "sa_fari", "JPEGImages_6fps")
+    else:
+        raise ValueError(f"Dataset {dataset} not found")
+
+
+def get_all_annotations_for_frame(
+    dataset_df: pd.DataFrame, video_id: int, frame_idx: int, data_dir: str, dataset: str
+):
+    media_dir = os.path.join(data_dir, "media")
+
+    # Load the annotation and video data
+    annot_df = dataset_df["annotations"]
+    video_df = dataset_df["videos"]
+
+    # Get the frame
+    video_df_current = video_df[video_df.id == video_id]
+    assert (
+        len(video_df_current) == 1
+    ), f"Expected 1 video row, got {len(video_df_current)}"
+    video_row = video_df_current.iloc[0]
+    file_name = video_row.file_names[frame_idx]
+    file_path = os.path.join(
+        get_media_dir(media_dir=media_dir, dataset=dataset), file_name
+    )
+    frame = cv2.imread(file_path)
+    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+
+    # Get the masks and noun phrases annotated in this video in this frame
+    annot_df_current_video = annot_df[annot_df.video_id == video_id]
+    if len(annot_df_current_video) == 0:
+        print(f"No annotations found for video_id {video_id}")
+        return frame, None, None
+    else:
+        empty_mask = np.zeros(frame.shape[:2], dtype=np.uint8)
+        mask_np_pairs = annot_df_current_video.apply(
+            lambda row: (
+                (
+                    mask_utils.decode(row.segmentations[frame_idx])
+                    if row.segmentations[frame_idx]
+                    else empty_mask
+                ),
+                row.noun_phrase,
+            ),
+            axis=1,
+        )
+        # sort based on noun_phrases
+        mask_np_pairs = sorted(mask_np_pairs, key=lambda x: x[1])
+        masks, noun_phrases = zip(*mask_np_pairs)
+
+    return frame, masks, noun_phrases
+
+
+def visualize_prompt_overlay(
+    frame_idx,
+    video_frames,
+    title="Prompt Visualization",
+    text_prompt=None,
+    point_prompts=None,
+    point_labels=None,
+    bounding_boxes=None,
+    box_labels=None,
+    obj_id=None,
+):
+    """Simple prompt visualization function"""
+    img = Image.fromarray(load_frame(video_frames[frame_idx]))
+    fig, ax = plt.subplots(1, figsize=(6, 4))
+    ax.imshow(img)
+
+    img_w, img_h = img.size
+
+    if text_prompt:
+        ax.text(
+            0.02,
+            0.98,
+            f'Text: "{text_prompt}"',
+            transform=ax.transAxes,
+            fontsize=12,
+            color="white",
+            weight="bold",
+            bbox=dict(boxstyle="round,pad=0.3", facecolor="red", alpha=0.7),
+            verticalalignment="top",
+        )
+
+    if point_prompts:
+        for i, point in enumerate(point_prompts):
+            x, y = point
+            # Convert relative to absolute coordinates
+            x_img, y_img = x * img_w, y * img_h
+
+            # Use different colors for positive/negative points
+            if point_labels and len(point_labels) > i:
+                color = "green" if point_labels[i] == 1 else "red"
+                marker = "o" if point_labels[i] == 1 else "x"
+            else:
+                color = "green"
+                marker = "o"
+
+            ax.plot(
+                x_img,
+                y_img,
+                marker=marker,
+                color=color,
+                markersize=10,
+                markeredgewidth=2,
+                markeredgecolor="white",
+            )
+            ax.text(
+                x_img + 5,
+                y_img - 5,
+                f"P{i+1}",
+                color=color,
+                fontsize=10,
+                weight="bold",
+                bbox=dict(boxstyle="round,pad=0.2", facecolor="white", alpha=0.8),
+            )
+
+    if bounding_boxes:
+        for i, box in enumerate(bounding_boxes):
+            x, y, w, h = box
+            # Convert relative to absolute coordinates
+            x_img, y_img = x * img_w, y * img_h
+            w_img, h_img = w * img_w, h * img_h
+
+            # Use different colors for positive/negative boxes
+            if box_labels and len(box_labels) > i:
+                color = "green" if box_labels[i] == 1 else "red"
+            else:
+                color = "green"
+
+            rect = patches.Rectangle(
+                (x_img, y_img),
+                w_img,
+                h_img,
+                linewidth=2,
+                edgecolor=color,
+                facecolor="none",
+            )
+            ax.add_patch(rect)
+            ax.text(
+                x_img,
+                y_img - 5,
+                f"B{i+1}",
+                color=color,
+                fontsize=10,
+                weight="bold",
+                bbox=dict(boxstyle="round,pad=0.2", facecolor="white", alpha=0.8),
+            )
+
+    # Add object ID info if provided
+    if obj_id is not None:
+        ax.text(
+            0.02,
+            0.02,
+            f"Object ID: {obj_id}",
+            transform=ax.transAxes,
+            fontsize=10,
+            color="white",
+            weight="bold",
+            bbox=dict(boxstyle="round,pad=0.3", facecolor="blue", alpha=0.7),
+            verticalalignment="bottom",
+        )
+
+    ax.set_title(title)
+    ax.axis("off")
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_results(img, results):
+    plt.figure(figsize=(12, 8))
+    plt.imshow(img)
+    nb_objects = len(results["scores"])
+    print(f"found {nb_objects} object(s)")
+    for i in range(nb_objects):
+        color = COLORS[i % len(COLORS)]
+        plot_mask(results["masks"][i].squeeze(0).cpu(), color=color)
+        w, h = img.size
+        prob = results["scores"][i].item()
+        plot_bbox(
+            h,
+            w,
+            results["boxes"][i].cpu(),
+            text=f"(id={i}, {prob=:.2f})",
+            box_format="XYXY",
+            color=color,
+            relative_coords=False,
+        )
+
+
+def single_visualization(img, anns, title):
+    """
+    Create a single image visualization with overlays.
+    """
+    fig, ax = plt.subplots(figsize=(7, 7))
+    fig.suptitle(title, fontsize=16, fontweight="bold")
+    overlay = render_masklet_frame(img, anns, alpha=0.5)
+    ax.imshow(overlay)
+    ax.axis("off")
+    plt.tight_layout()
+
+
+def show_mask(mask, ax, obj_id=None, random_color=False):
+    if random_color:
+        color = np.concatenate([np.random.random(3), np.array([0.6])], axis=0)
+    else:
+        cmap = plt.get_cmap("tab10")
+        cmap_idx = 0 if obj_id is None else obj_id
+        color = np.array([*cmap(cmap_idx)[:3], 0.6])
+    h, w = mask.shape[-2:]
+    mask_image = mask.reshape(h, w, 1) * color.reshape(1, 1, -1)
+    ax.imshow(mask_image)
+
+
+def show_box(box, ax):
+    x0, y0 = box[0], box[1]
+    w, h = box[2] - box[0], box[3] - box[1]
+    ax.add_patch(
+        plt.Rectangle((x0, y0), w, h, edgecolor="green", facecolor=(0, 0, 0, 0), lw=2)
+    )
+
+
+def show_points(coords, labels, ax, marker_size=375):
+    pos_points = coords[labels == 1]
+    neg_points = coords[labels == 0]
+    ax.scatter(
+        pos_points[:, 0],
+        pos_points[:, 1],
+        color="green",
+        marker="*",
+        s=marker_size,
+        edgecolor="white",
+        linewidth=1.25,
+    )
+    ax.scatter(
+        neg_points[:, 0],
+        neg_points[:, 1],
+        color="red",
+        marker="*",
+        s=marker_size,
+        edgecolor="white",
+        linewidth=1.25,
+    )
+
+
+def load_frame(frame):
+    if isinstance(frame, np.ndarray):
+        img = frame
+    elif isinstance(frame, Image.Image):
+        img = np.array(frame)
+    elif isinstance(frame, str) and os.path.isfile(frame):
+        img = plt.imread(frame)
+    else:
+        raise ValueError(f"Invalid video frame type: {type(frame)=}")
+    return img