transformers 5.0.0__py3-none-any.whl → 5.0.0rc0__py3-none-any.whl

transformers/models/sam2_video/modular_sam2_video.py

@@ -1,3 +1,4 @@
+# coding=utf-8
 # Copyright 2025 The Meta AI Authors and The HuggingFace Team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,7 +18,7 @@ import math
 from collections import OrderedDict
 from collections.abc import Callable, Iterator
 from dataclasses import dataclass
-from typing import Any, Union
+from typing import Any, Optional, Union
 
 import numpy as np
 import torch
@@ -50,7 +51,6 @@ from ..sam2.modeling_sam2 import (
     Sam2ImageSegmentationOutput,
     Sam2LayerNorm,
     Sam2Model,
-    Sam2PositionalEmbedding,
     Sam2SinePositionEmbedding,
     Sam2TwoWayAttentionBlock,
     eager_attention_forward,
@@ -319,8 +319,8 @@ class Sam2VideoInferenceCache:
 
     def __init__(
         self,
-        inference_device: torch.device | str = "cpu",
-        inference_state_device: torch.device | str = "cpu",
+        inference_device: Union[torch.device, str] = "cpu",
+        inference_state_device: Union[torch.device, str] = "cpu",
         max_vision_features_cache_size: int = 1,
     ):
         self.inference_device = inference_device
@@ -345,7 +345,7 @@ class Sam2VideoInferenceCache:
                 cached[key] = value
         self._vision_features[frame_idx] = cached
 
-    def get_vision_features(self, frame_idx: int) -> dict | None:
+    def get_vision_features(self, frame_idx: int) -> Optional[dict]:
         """Get cached vision features, automatically moved to inference device."""
         if frame_idx not in self._vision_features:
             return None
@@ -391,13 +391,13 @@ class Sam2VideoInferenceSession:
 
     def __init__(
         self,
-        video: torch.FloatTensor | None = None,
-        video_height: int | None = None,
-        video_width: int | None = None,
-        inference_device: torch.device | str = "cpu",
-        inference_state_device: torch.device | str = "cpu",
-        video_storage_device: torch.device | str = "cpu",
-        dtype: torch.dtype | str = "float32",
+        video: Optional[torch.FloatTensor] = None,
+        video_height: Optional[int] = None,
+        video_width: Optional[int] = None,
+        inference_device: Union[torch.device, str] = "cpu",
+        inference_state_device: Union[torch.device, str] = "cpu",
+        video_storage_device: Union[torch.device, str] = "cpu",
+        dtype: Union[torch.dtype, str] = "float32",
         max_vision_features_cache_size: int = 1,
     ):
         # store as a dictionary to avoid double memory allocation with torch.cat when adding new frames
@@ -437,7 +437,7 @@ class Sam2VideoInferenceSession:
         self.obj_with_new_inputs = []
 
     @property
-    def num_frames(self) -> int | None:
+    def num_frames(self) -> Optional[int]:
         return len(self.processed_frames) if self.processed_frames is not None else None
 
     # Object management
@@ -477,7 +477,7 @@ class Sam2VideoInferenceSession:
         device_inputs = {}
         for key, value in inputs.items():
             if isinstance(value, torch.Tensor):
-                device_inputs[key] = value.to(self.inference_device, non_blocking=False)
+                device_inputs[key] = value.to(self.inference_device, non_blocking=True)
             else:
                 device_inputs[key] = value
         self.point_inputs_per_obj[obj_idx][frame_idx] = device_inputs
@@ -501,8 +501,8 @@ class Sam2VideoInferenceSession:
         self,
         obj_idx: int,
         frame_idx: int,
-        output_key: str | None = None,
-        output_value: torch.Tensor | dict | None = None,
+        output_key: Optional[str] = None,
+        output_value: Optional[Union[torch.Tensor, dict]] = None,
         is_conditioning_frame: bool = True,
     ):
         """
@@ -561,7 +561,7 @@ class Sam2VideoInferenceSession:
         return value
 
     # Video frame management
-    def add_new_frame(self, pixel_values: torch.Tensor, frame_idx: int | None = None) -> int:
+    def add_new_frame(self, pixel_values: torch.Tensor, frame_idx: Optional[int] = None) -> int:
         """Add new frame with automatic device placement."""
         pixel_values = pixel_values.to(self.video_storage_device, dtype=self.dtype, non_blocking=True)
         if pixel_values.dim() == 4:
@@ -607,8 +607,26 @@ class Sam2VideoInferenceSession:
 
 
 class Sam2VideoProcessor(Sam2Processor):
+    r"""
+    Constructs a SAM2 processor which wraps a SAM2 image processor and an 2D points & Bounding boxes processor into a
+    single processor.
+
+    [`Sam2VideoProcessor`] offers all the functionalities of [`Sam2ImageProcessorFast`] and [`Sam2VideoProcessor`]. See the docstring of
+    [`~Sam2ImageProcessorFast.__call__`] and [`~Sam2VideoProcessor.__call__`] for more information.
+
+    Args:
+        image_processor (`Sam2ImageProcessorFast`):
+            An instance of [`Sam2ImageProcessorFast`].
+        video_processor (`Sam2VideoVideoProcessor`):
+            An instance of [`Sam2VideoVideoProcessor`].
+        target_size (`int`, *optional*):
+            The target size (target_size, target_size) to which the image will be resized.
+        point_pad_value (`int`, *optional*, defaults to -10):
+            The value used for padding input points.
+    """
+
     def __init__(
-        self, image_processor, video_processor, target_size: int | None = None, point_pad_value: int = -10, **kwargs
+        self, image_processor, video_processor, target_size: Optional[int] = None, point_pad_value: int = -10, **kwargs
     ):
         ProcessorMixin.__init__(self, image_processor, video_processor, **kwargs)
         self.point_pad_value = point_pad_value
@@ -616,11 +634,11 @@ class Sam2VideoProcessor(Sam2Processor):
 
     def init_video_session(
         self,
-        video: VideoInput | None = None,
+        video: Optional[VideoInput] = None,
         inference_device: Union[str, "torch.device"] = "cpu",
-        inference_state_device: Union[str, "torch.device"] | None = None,
-        processing_device: Union[str, "torch.device"] | None = None,
-        video_storage_device: Union[str, "torch.device"] | None = None,
+        inference_state_device: Optional[Union[str, "torch.device"]] = None,
+        processing_device: Optional[Union[str, "torch.device"]] = None,
+        video_storage_device: Optional[Union[str, "torch.device"]] = None,
         max_vision_features_cache_size: int = 1,
         dtype: torch.dtype = torch.float32,
     ):
@@ -671,12 +689,12 @@ class Sam2VideoProcessor(Sam2Processor):
         self,
         inference_session: Sam2VideoInferenceSession,
         frame_idx: int,
-        obj_ids: list[int] | int,
-        input_points: list[list[list[list[float]]]] | torch.Tensor | None = None,
-        input_labels: list[list[list[int]]] | torch.Tensor | None = None,
-        input_boxes: list[list[list[float]]] | torch.Tensor | None = None,
-        input_masks: np.ndarray | torch.Tensor | list[np.ndarray] | list[torch.Tensor] | None = None,
-        original_size: tuple[int, int] | None = None,
+        obj_ids: Union[list[int], int],
+        input_points: Optional[Union[list[list[list[list[float]]]], torch.Tensor]] = None,
+        input_labels: Optional[Union[list[list[list[int]]], torch.Tensor]] = None,
+        input_boxes: Optional[Union[list[list[list[float]]], torch.Tensor]] = None,
+        input_masks: Optional[Union[np.ndarray, torch.Tensor, list[np.ndarray], list[torch.Tensor]]] = None,
+        original_size: Optional[tuple[int, int]] = None,
         clear_old_inputs: bool = True,
     ) -> Sam2VideoInferenceSession:
         """
@@ -734,10 +752,10 @@ class Sam2VideoProcessor(Sam2Processor):
         inference_session: Sam2VideoInferenceSession,
         frame_idx: int,
         obj_ids: list[int],
-        input_points: list[list[list[list[float]]]] | torch.Tensor | None = None,
-        input_labels: list[list[list[int]]] | torch.Tensor | None = None,
-        input_boxes: list[list[list[float]]] | torch.Tensor | None = None,
-        original_size: tuple[int, int] | None = None,
+        input_points: Optional[Union[list[list[list[list[float]]]], torch.Tensor]] = None,
+        input_labels: Optional[Union[list[list[list[int]]], torch.Tensor]] = None,
+        input_boxes: Optional[Union[list[list[list[float]]], torch.Tensor]] = None,
+        original_size: Optional[tuple[int, int]] = None,
         clear_old_inputs: bool = True,
     ) -> Sam2VideoInferenceSession:
         """
@@ -843,7 +861,7 @@ class Sam2VideoProcessor(Sam2Processor):
         inference_session: Sam2VideoInferenceSession,
         frame_idx: int,
         obj_ids: list[int],
-        input_masks: np.ndarray | torch.Tensor | list[np.ndarray] | list[torch.Tensor],
+        input_masks: Union[np.ndarray, torch.Tensor, list[np.ndarray], list[torch.Tensor]],
     ):
         """
         Add new mask to a frame and add them to the inference session.
@@ -946,8 +964,8 @@ class Sam2VideoImageSegmentationOutput(Sam2ImageSegmentationOutput):
         A tensor representing the object pointer, used for tracking in videos. Only used for Sam2VideoModel.
     """
 
-    high_res_masks: torch.FloatTensor | None = None
-    object_pointer: torch.FloatTensor | None = None
+    high_res_masks: Optional[torch.FloatTensor] = None
+    object_pointer: Optional[torch.FloatTensor] = None
 
 
 @dataclass
@@ -964,10 +982,10 @@ class Sam2VideoSegmentationOutput(ModelOutput):
         The frame index of the video.
     """
 
-    object_ids: list[int] | None = None
-    pred_masks: torch.FloatTensor | None = None
-    object_score_logits: torch.FloatTensor | None = None
-    frame_idx: int | None = None
+    object_ids: Optional[list[int]] = None
+    pred_masks: Optional[torch.FloatTensor] = None
+    object_score_logits: Optional[torch.FloatTensor] = None
+    frame_idx: Optional[int] = None
 
 
 @auto_docstring
@@ -977,7 +995,7 @@ class Sam2VideoPreTrainedModel(PreTrainedModel):
     main_input_name = "pixel_values"
     input_modalities = "video"
     _supports_sdpa = True
-    _supports_flash_attn = True
+    _supports_flash_attn_2 = True
     _supports_attention_backend = True
 
     @torch.no_grad()
@@ -995,12 +1013,6 @@ class Sam2VideoPreTrainedModel(PreTrainedModel):
         if isinstance(module, Sam2VideoMemoryFuserCXBlock):
             if module.scale is not None:
                 init.zeros_(module.scale)
-        elif isinstance(module, Sam2VideoVisionRotaryEmbedding):
-            inv_freq = module.create_inv_freq()
-            init.copy_(module.rope_embeddings_cos, inv_freq.cos())
-            init.copy_(module.rope_embeddings_sin, inv_freq.sin())
-        elif isinstance(module, Sam2VideoPositionalEmbedding):
-            init.normal_(module.positional_embedding, std=module.scale)
 
 
 class Sam2VideoVisionRotaryEmbedding(nn.Module):
@@ -1011,17 +1023,24 @@ class Sam2VideoVisionRotaryEmbedding(nn.Module):
 
     def __init__(self, config: Sam2VideoConfig):
         super().__init__()
-        self.dim = config.memory_attention_hidden_size // (
+        dim = config.memory_attention_hidden_size // (
             config.memory_attention_downsample_rate * config.memory_attention_num_attention_heads
         )
         # Ensure even dimension for proper axial splitting
-        if self.dim % 4 != 0:
+        if dim % 4 != 0:
             raise ValueError("Dimension must be divisible by 4 for axial RoPE")
-        self.end_x, self.end_y = config.memory_attention_rope_feat_sizes
-        self.memory_attention_rope_theta = config.memory_attention_rope_theta
+        end_x, end_y = config.memory_attention_rope_feat_sizes
+        freqs = 1.0 / (config.memory_attention_rope_theta ** (torch.arange(0, dim, 4)[: (dim // 4)].float() / dim))
 
+        # Generate 2D position indices for axial rotary embedding
+        flattened_indices = torch.arange(end_x * end_y, dtype=torch.long)
+        x_positions = flattened_indices % end_x
+        y_positions = torch.div(flattened_indices, end_x, rounding_mode="floor")
+        freqs_x = torch.outer(x_positions, freqs).float()
+        freqs_y = torch.outer(y_positions, freqs).float()
+        inv_freq = torch.cat([freqs_x, freqs_y], dim=-1)
+        inv_freq = inv_freq.repeat_interleave(2, dim=-1)
         # directly register the cos and sin embeddings as we have a fixed feature shape
-        inv_freq = self.create_inv_freq()
         self.register_buffer("rope_embeddings_cos", inv_freq.cos(), persistent=False)
         self.register_buffer("rope_embeddings_sin", inv_freq.sin(), persistent=False)
 
@@ -1030,20 +1049,6 @@ class Sam2VideoVisionRotaryEmbedding(nn.Module):
         # As the feature map size is fixed, we can just return the pre-computed embeddings.
         return self.rope_embeddings_cos, self.rope_embeddings_sin
 
-    def create_inv_freq(self):
-        freqs = 1.0 / (
-            self.memory_attention_rope_theta ** (torch.arange(0, self.dim, 4)[: (self.dim // 4)].float() / self.dim)
-        )
-        # Generate 2D position indices for axial rotary embedding
-        flattened_indices = torch.arange(self.end_x * self.end_y, dtype=torch.long)
-        x_positions = flattened_indices % self.end_x
-        y_positions = torch.div(flattened_indices, self.end_x, rounding_mode="floor")
-        freqs_x = torch.outer(x_positions, freqs).float()
-        freqs_y = torch.outer(y_positions, freqs).float()
-        inv_freq = torch.cat([freqs_x, freqs_y], dim=-1)
-        inv_freq = inv_freq.repeat_interleave(2, dim=-1)
-        return inv_freq
-
 
 def rotate_pairwise(x):
     """
@@ -1117,7 +1122,7 @@ class Sam2VideoRoPEAttention(nn.Module):
     def __init__(
         self,
         config: Sam2VideoConfig,
-        kv_in_dim: int | None = None,
+        kv_in_dim: Optional[int] = None,
         rope_k_repeat=False,
     ):
         super().__init__()
@@ -1248,8 +1253,8 @@ class Sam2VideoMemoryAttention(nn.Module):
         self,
         current_vision_features: torch.Tensor,
         memory: torch.Tensor,
-        current_vision_position_embeddings: Tensor | None = None,
-        memory_posision_embeddings: Tensor | None = None,
+        current_vision_position_embeddings: Optional[Tensor] = None,
+        memory_posision_embeddings: Optional[Tensor] = None,
         num_object_pointer_tokens: int = 0,
     ):
         """
@@ -1421,10 +1426,6 @@ class Sam2VideoMemoryEncoder(nn.Module):
         return vision_features, vision_pos_enc
 
 
-class Sam2VideoPositionalEmbedding(Sam2PositionalEmbedding):
-    pass
-
-
 # a large negative value as a placeholder score for missing objects
 NO_OBJ_SCORE = -1024.0
 
@@ -1445,6 +1446,11 @@ def get_1d_sine_pe(pos_inds, dim, temperature=10000):
 @auto_docstring
 class Sam2VideoModel(Sam2Model):
     input_modalities = ("video", "text")
+    _tied_weights_keys = {
+        "prompt_encoder.shared_embedding.positional_embedding": "shared_image_embedding.positional_embedding"
+    }
+    # need to be ignored, as it's a buffer and will not be correctly detected as tied weight
+    _keys_to_ignore_on_load_missing = ["prompt_encoder.shared_embedding.positional_embedding"]
     _keys_to_ignore_on_load_unexpected = []
     _can_record_outputs = {"mask_decoder_attentions": OutputRecorder(Sam2VideoTwoWayAttentionBlock, index=2)}
 
@@ -1489,10 +1495,10 @@ class Sam2VideoModel(Sam2Model):
     @torch.no_grad()
     def get_prompt_embeddings(
         self,
-        input_points: torch.FloatTensor | None = None,
-        input_labels: torch.LongTensor | None = None,
-        input_boxes: torch.FloatTensor | None = None,
-        input_masks: torch.LongTensor | None = None,
+        input_points: Optional[torch.FloatTensor] = None,
+        input_labels: Optional[torch.LongTensor] = None,
+        input_boxes: Optional[torch.FloatTensor] = None,
+        input_masks: Optional[torch.LongTensor] = None,
     ) -> tuple[torch.Tensor, torch.Tensor]:
         r"""
         Returns the prompt embeddings by passing the input points, labels, boxes and masks through the prompt encoder.
@@ -1534,9 +1540,7 @@ class Sam2VideoModel(Sam2Model):
         else:
             # Compute features using image encoder
             image_batch = inference_session.get_frame(frame_idx).unsqueeze(0)  # Add batch dimension
-            image_outputs = self.get_image_features(image_batch, return_dict=True)
-            vision_feats = image_outputs.fpn_hidden_states
-            vision_pos_embeds = image_outputs.fpn_position_embeddings
+            vision_feats, vision_pos_embeds, _, _ = self.get_image_features(image_batch)
             # Cache features
             inference_session.cache.cache_vision_features(
                 frame_idx, {"vision_feats": vision_feats, "vision_pos_embeds": vision_pos_embeds}
@@ -1551,15 +1555,15 @@ class Sam2VideoModel(Sam2Model):
 
     def _single_frame_forward(
         self,
-        pixel_values: torch.FloatTensor | None = None,
-        input_points: torch.FloatTensor | None = None,
-        input_labels: torch.LongTensor | None = None,
-        input_boxes: torch.FloatTensor | None = None,
-        input_masks: torch.LongTensor | None = None,
-        image_embeddings: torch.FloatTensor | None = None,
+        pixel_values: Optional[torch.FloatTensor] = None,
+        input_points: Optional[torch.FloatTensor] = None,
+        input_labels: Optional[torch.LongTensor] = None,
+        input_boxes: Optional[torch.FloatTensor] = None,
+        input_masks: Optional[torch.LongTensor] = None,
+        image_embeddings: Optional[torch.FloatTensor] = None,
         multimask_output: bool = True,
-        attention_similarity: torch.FloatTensor | None = None,
-        target_embedding: torch.FloatTensor | None = None,
+        attention_similarity: Optional[torch.FloatTensor] = None,
+        target_embedding: Optional[torch.FloatTensor] = None,
         **kwargs: Unpack[TransformersKwargs],
     ) -> Sam2VideoImageSegmentationOutput:
         """
@@ -1641,10 +1645,10 @@ class Sam2VideoModel(Sam2Model):
         vision_hidden_states = None
 
         if pixel_values is not None:
-            image_outputs = self.get_image_features(pixel_values, return_dict=True, **kwargs)
-            feature_maps = image_outputs.fpn_hidden_states
-            vision_hidden_states = image_outputs.hidden_states
-            vision_attentions = image_outputs.attentions
+            feature_maps, _, vision_hidden_states, vision_attentions = self.get_image_features(
+                pixel_values,
+                **kwargs,
+            )
 
             # add no memory embedding to the last feature map
             feature_maps[-1] = feature_maps[-1] + self.no_memory_embedding
@@ -2134,7 +2138,7 @@ class Sam2VideoModel(Sam2Model):
                 num_object_pointer_tokens = object_pointers.shape[0]
 
         # Step 4: Concatenate all retrieved memories and their positional embeddings
-        combined_memory = torch.cat(memories_to_concatenate, dim=0).to(dtype=inference_session.dtype)
+        combined_memory = torch.cat(memories_to_concatenate, dim=0)
         combined_memory_positional_embeddings = torch.cat(memory_positional_embeddings_to_concatenate, dim=0)
 
         # Step 5: Forward through the memory attention mechanism
@@ -2152,7 +2156,7 @@ class Sam2VideoModel(Sam2Model):
         )
         return conditioned_feature_map
 
-    def _use_multimask(self, is_init_cond_frame: bool, point_inputs: dict | None) -> bool:
+    def _use_multimask(self, is_init_cond_frame: bool, point_inputs: Optional[dict]) -> bool:
         """Whether to use multimask output in the SAM head."""
         num_pts = 0 if point_inputs is None else point_inputs["point_labels"].size(2)
         multimask_output = (
@@ -2169,10 +2173,10 @@ class Sam2VideoModel(Sam2Model):
         obj_idx: int,
         batch_size: int,
         is_init_cond_frame: bool,
-        point_inputs: torch.Tensor | None,
-        mask_inputs: torch.Tensor | None,
+        point_inputs: Optional[torch.Tensor],
+        mask_inputs: Optional[torch.Tensor],
         reverse: bool,
-        prev_sam_mask_logits: torch.Tensor | None = None,
+        prev_sam_mask_logits: Optional[torch.Tensor] = None,
         streaming: bool = False,
     ) -> dict[str, Any]:
         """
@@ -2329,11 +2333,10 @@ class Sam2VideoModel(Sam2Model):
     def forward(
         self,
         inference_session: Sam2VideoInferenceSession,
-        frame_idx: int | None = None,
-        frame: torch.Tensor | None = None,
+        frame_idx: Optional[int] = None,
+        frame: Optional[torch.Tensor] = None,
         reverse: bool = False,
         run_mem_encoder: bool = True,
-        **kwargs,
     ) -> Sam2VideoSegmentationOutput:
         r"""
         inference_session (`Sam2VideoInferenceSession`):
@@ -2516,8 +2519,8 @@ class Sam2VideoModel(Sam2Model):
     def propagate_in_video_iterator(
         self,
         inference_session: Sam2VideoInferenceSession,
-        start_frame_idx: int | None = None,
-        max_frame_num_to_track: int | None = None,
+        start_frame_idx: Optional[int] = None,
+        max_frame_num_to_track: Optional[int] = None,
         reverse: bool = False,
         show_progress_bar: bool = False,
     ) -> Iterator[Sam2VideoSegmentationOutput]:

transformers/models/sam2_video/processing_sam2_video.py

@@ -4,6 +4,7 @@
 #             the file from the modular. If any change should be done, please apply the change to the
 #                          modular_sam2_video.py file directly. One of our CI enforces this.
 #                🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# coding=utf-8
 # Copyright 2025 The Meta AI Authors and The HuggingFace Team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,7 +19,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from copy import deepcopy
-from typing import Union
+from typing import Optional, Union
 
 import numpy as np
 import torch
@@ -26,55 +27,71 @@ import torch
 from ...image_utils import ImageInput
 from ...processing_utils import ProcessorMixin
 from ...tokenization_utils_base import BatchEncoding
-from ...utils import TensorType, auto_docstring
+from ...utils import TensorType
 from ...utils.import_utils import requires
 from ...video_utils import VideoInput
 from .modeling_sam2_video import Sam2VideoInferenceSession
 
 
 @requires(backends=("torch",))
-@auto_docstring
 class Sam2VideoProcessor(ProcessorMixin):
-    def __init__(
-        self, image_processor, video_processor, target_size: int | None = None, point_pad_value: int = -10, **kwargs
-    ):
-        r"""
+    r"""
+    Constructs a SAM2 processor which wraps a SAM2 image processor and an 2D points & Bounding boxes processor into a
+    single processor.
+
+    [`Sam2VideoProcessor`] offers all the functionalities of [`Sam2ImageProcessorFast`] and [`Sam2VideoProcessor`]. See the docstring of
+    [`~Sam2ImageProcessorFast.__call__`] and [`~Sam2VideoProcessor.__call__`] for more information.
+
+    Args:
+        image_processor (`Sam2ImageProcessorFast`):
+            An instance of [`Sam2ImageProcessorFast`].
+        video_processor (`Sam2VideoVideoProcessor`):
+            An instance of [`Sam2VideoVideoProcessor`].
         target_size (`int`, *optional*):
-            The target size (in pixels) for normalizing input points and bounding boxes. If not provided, defaults
-            to the image processor's size configuration. All input coordinates (points and boxes) are normalized
-            to this size before being passed to the model. This ensures consistent coordinate representation
-            regardless of the original image dimensions.
+            The target size (target_size, target_size) to which the image will be resized.
         point_pad_value (`int`, *optional*, defaults to -10):
-            The value used for padding input points when batching sequences of different lengths. This value is
-            used to mark padded positions and is preserved during coordinate normalization.
-        """
+            The value used for padding input points.
+    """
+
+    def __init__(
+        self, image_processor, video_processor, target_size: Optional[int] = None, point_pad_value: int = -10, **kwargs
+    ):
         super().__init__(image_processor, video_processor, **kwargs)
         self.point_pad_value = point_pad_value
         self.target_size = target_size if target_size is not None else self.image_processor.size["height"]
 
-    @auto_docstring
     def __call__(
         self,
-        images: ImageInput | None = None,
-        segmentation_maps: ImageInput | None = None,
-        input_points: list[list[list[list[float]]]] | torch.Tensor | None = None,
-        input_labels: list[list[list[int]]] | torch.Tensor | None = None,
-        input_boxes: list[list[list[float]]] | torch.Tensor | None = None,
-        original_sizes: list[list[float]] | torch.Tensor | None = None,
-        return_tensors: str | TensorType | None = None,
+        images: Optional[ImageInput] = None,
+        segmentation_maps: Optional[ImageInput] = None,
+        input_points: Optional[Union[list[list[list[list[float]]]], torch.Tensor]] = None,
+        input_labels: Optional[Union[list[list[list[int]]], torch.Tensor]] = None,
+        input_boxes: Optional[Union[list[list[list[float]]], torch.Tensor]] = None,
+        original_sizes: Optional[Union[list[list[float]], torch.Tensor]] = None,
+        return_tensors: Optional[Union[str, TensorType]] = None,
         **kwargs,
     ) -> BatchEncoding:
         r"""
-        segmentation_maps (`ImageInput`, *optional*):
-            The segmentation maps to process.
-        input_points (`list[list[list[list[float]]]]`, `torch.Tensor`, *optional*):
-            The points to add to the frame.
-        input_labels (`list[list[list[int]]]`, `torch.Tensor`, *optional*):
-            The labels for the points.
-        input_boxes (`list[list[list[float]]]`, `torch.Tensor`, *optional*):
-            The bounding boxes to add to the frame.
-        original_sizes (`list[list[float]]`, `torch.Tensor`, *optional*):
-            The original sizes of the images.
+        This method uses [`Sam2VideoImageProcessorFast.__call__`] method to prepare image(s) for the model. It also prepares 2D
+        points and bounding boxes for the model if they are provided.
+
+        Args:
+            images (`ImageInput`, *optional*):
+                The image(s) to process.
+            segmentation_maps (`ImageInput`, *optional*):
+                The segmentation maps to process.
+            input_points (`list[list[list[list[float]]]]`, `torch.Tensor`, *optional*):
+                The points to add to the frame.
+            input_labels (`list[list[list[int]]]`, `torch.Tensor`, *optional*):
+                The labels for the points.
+            input_boxes (`list[list[list[float]]]`, `torch.Tensor`, *optional*):
+                The bounding boxes to add to the frame.
+            original_sizes (`list[list[float]]`, `torch.Tensor`, *optional*):
+                The original sizes of the images.
+            return_tensors (`str` or `TensorType`, *optional*):
+                The type of tensors to return.
+            **kwargs:
+                Additional keyword arguments to pass to the image processor.
 
         Returns:
             A [`BatchEncoding`] with the following fields:
@@ -375,11 +392,11 @@ class Sam2VideoProcessor(ProcessorMixin):
 
     def _validate_single_input(
         self,
-        data: torch.Tensor | np.ndarray | list,
+        data: Union[torch.Tensor, np.ndarray, list],
         expected_depth: int,
         input_name: str,
         expected_format: str,
-        expected_coord_size: int | None = None,
+        expected_coord_size: Optional[int] = None,
     ) -> list:
         """
                 Validate a single input by ensuring proper nesting and raising an error if the input is not valid.
@@ -511,11 +528,11 @@ class Sam2VideoProcessor(ProcessorMixin):
 
     def init_video_session(
         self,
-        video: VideoInput | None = None,
+        video: Optional[VideoInput] = None,
         inference_device: Union[str, "torch.device"] = "cpu",
-        inference_state_device: Union[str, "torch.device"] | None = None,
-        processing_device: Union[str, "torch.device"] | None = None,
-        video_storage_device: Union[str, "torch.device"] | None = None,
+        inference_state_device: Optional[Union[str, "torch.device"]] = None,
+        processing_device: Optional[Union[str, "torch.device"]] = None,
+        video_storage_device: Optional[Union[str, "torch.device"]] = None,
         max_vision_features_cache_size: int = 1,
         dtype: torch.dtype = torch.float32,
     ):
@@ -566,12 +583,12 @@ class Sam2VideoProcessor(ProcessorMixin):
         self,
         inference_session: Sam2VideoInferenceSession,
         frame_idx: int,
-        obj_ids: list[int] | int,
-        input_points: list[list[list[list[float]]]] | torch.Tensor | None = None,
-        input_labels: list[list[list[int]]] | torch.Tensor | None = None,
-        input_boxes: list[list[list[float]]] | torch.Tensor | None = None,
-        input_masks: np.ndarray | torch.Tensor | list[np.ndarray] | list[torch.Tensor] | None = None,
-        original_size: tuple[int, int] | None = None,
+        obj_ids: Union[list[int], int],
+        input_points: Optional[Union[list[list[list[list[float]]]], torch.Tensor]] = None,
+        input_labels: Optional[Union[list[list[list[int]]], torch.Tensor]] = None,
+        input_boxes: Optional[Union[list[list[list[float]]], torch.Tensor]] = None,
+        input_masks: Optional[Union[np.ndarray, torch.Tensor, list[np.ndarray], list[torch.Tensor]]] = None,
+        original_size: Optional[tuple[int, int]] = None,
         clear_old_inputs: bool = True,
     ) -> Sam2VideoInferenceSession:
         """
@@ -629,10 +646,10 @@ class Sam2VideoProcessor(ProcessorMixin):
         inference_session: Sam2VideoInferenceSession,
         frame_idx: int,
         obj_ids: list[int],
-        input_points: list[list[list[list[float]]]] | torch.Tensor | None = None,
-        input_labels: list[list[list[int]]] | torch.Tensor | None = None,
-        input_boxes: list[list[list[float]]] | torch.Tensor | None = None,
-        original_size: tuple[int, int] | None = None,
+        input_points: Optional[Union[list[list[list[list[float]]]], torch.Tensor]] = None,
+        input_labels: Optional[Union[list[list[list[int]]], torch.Tensor]] = None,
+        input_boxes: Optional[Union[list[list[list[float]]], torch.Tensor]] = None,
+        original_size: Optional[tuple[int, int]] = None,
         clear_old_inputs: bool = True,
     ) -> Sam2VideoInferenceSession:
         """
@@ -738,7 +755,7 @@ class Sam2VideoProcessor(ProcessorMixin):
         inference_session: Sam2VideoInferenceSession,
         frame_idx: int,
         obj_ids: list[int],
-        input_masks: np.ndarray | torch.Tensor | list[np.ndarray] | list[torch.Tensor],
+        input_masks: Union[np.ndarray, torch.Tensor, list[np.ndarray], list[torch.Tensor]],
     ):
         """
         Add new mask to a frame and add them to the inference session.

transformers/models/sam2_video/video_processing_sam2_video.py

@@ -1,3 +1,4 @@
+# coding=utf-8
 # Copyright 2025 The HuggingFace Inc. team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,6 +14,8 @@
 # limitations under the License.
 """Fast Image processor class for SAM2."""
 
+from typing import Optional, Union
+
 import numpy as np
 import torch
 import torch.nn.functional as F
@@ -38,7 +41,7 @@ class Sam2VideoVideoProcessor(BaseVideoProcessor):
         self,
         videos: list["torch.Tensor"],
         size: SizeDict,
-        return_tensors: str | TensorType | None,
+        return_tensors: Optional[Union[str, TensorType]],
         **kwargs,
     ) -> BatchFeature:
         original_sizes = [video.shape[-2:] for video in videos]