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

transformers/models/sam3_tracker_video/modular_sam3_tracker_video.py

@@ -1,3 +1,4 @@
+# coding=utf-8
 # Copyright 2025 the HuggingFace Team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -12,12 +13,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from typing import Optional
 
 import torch
 
 from ...configuration_utils import PreTrainedConfig
 from ...processing_utils import Unpack
-from ...utils import TransformersKwargs, auto_docstring, can_return_tuple
+from ...utils.generic import TransformersKwargs
 from ..auto import CONFIG_MAPPING, AutoConfig, AutoModel
 from ..sam2_video.configuration_sam2_video import Sam2VideoMaskDecoderConfig, Sam2VideoPromptEncoderConfig
 from ..sam2_video.modeling_sam2_video import (
@@ -351,31 +353,6 @@ class Sam3TrackerVideoConfig(PreTrainedConfig):
 
         super().__init__(**kwargs)
 
-    @property
-    def image_size(self):
-        """Image size for the tracker video model."""
-        return self.vision_config.image_size
-
-    @image_size.setter
-    def image_size(self, value):
-        """Set the image size and propagate to sub-configs. Calculates feature sizes based on patch_size."""
-        self.prompt_encoder_config.image_size = value
-        self.vision_config.image_size = value
-
-        patch_size = self.vision_config.backbone_config.patch_size
-        self.vision_config.backbone_feature_sizes = [
-            [4 * value // patch_size, 4 * value // patch_size],
-            [2 * value // patch_size, 2 * value // patch_size],
-            [value // patch_size, value // patch_size],
-        ]
-        self.memory_attention_rope_feat_sizes = [
-            value // patch_size,
-            value // patch_size,
-        ]
-
-        # keep the image_size in the __dict__ to save the value in the config file (backward compatibility)
-        self.__dict__["image_size"] = value
-
 
 class Sam3TrackerVideoInferenceCache(Sam2VideoInferenceCache):
     pass
@@ -484,6 +461,8 @@ class Sam3TrackerVideoModel(Sam2VideoModel):
         "tracker_neck.": "vision_encoder.neck.",
     }
     _keys_to_ignore_on_load_unexpected = [r"^detector_model."]
+    _tied_weights_keys = {}
+    _keys_to_ignore_on_load_missing = []
 
     def __init__(self, config: Sam3TrackerVideoConfig, remove_vision_encoder: bool = False):
         r"""
@@ -544,19 +523,33 @@ class Sam3TrackerVideoModel(Sam2VideoModel):
 
         self.post_init()
 
-    @can_return_tuple
-    @auto_docstring
     def get_image_features(
         self,
         pixel_values: torch.FloatTensor,
         **kwargs: Unpack[TransformersKwargs],
-    ) -> tuple | Sam3TrackerVideoVisionEncoderOutput:
+    ) -> tuple[
+        list[torch.Tensor],
+        list[torch.Tensor],
+        Optional[tuple[torch.FloatTensor, ...]],
+        Optional[tuple[torch.FloatTensor, ...]],
+    ]:
         r"""
-        pixel_values (`torch.FloatTensor`):
-            Input pixel values of shape `(batch_size, num_channels, height, width)`.
+        Extract and preprocess image features using the vision encoder.
+
+        Args:
+            pixel_values (`torch.FloatTensor`):
+                Input pixel values of shape `(batch_size, num_channels, height, width)`.
+
+        Returns:
+            `tuple`: A tuple containing:
+                - feature_maps (`list[torch.Tensor]`): List of feature maps from different levels.
+                - feature_maps_position_embeddings (`list[torch.Tensor]`): List of positional embeddings for each feature level.
+                - vision_hidden_states (`tuple[torch.FloatTensor]`, *optional*): Hidden states from the vision encoder.
+                - vision_attentions (`tuple[torch.FloatTensor]`, *optional*): Attention weights from the vision encoder.
         """
         vision_outputs: Sam3TrackerVideoVisionEncoderOutput = self.vision_encoder(
-            pixel_values, return_dict=True, **kwargs
+            pixel_values,
+            **kwargs,
         )
 
         feature_maps = vision_outputs.fpn_hidden_states
@@ -574,10 +567,8 @@ class Sam3TrackerVideoModel(Sam2VideoModel):
             feature_map_position_embedding.flatten(2).permute(2, 0, 1)
             for feature_map_position_embedding in feature_maps_position_embeddings[:-1]
         ]
-        vision_outputs.fpn_hidden_states = feature_maps
-        vision_outputs.fpn_position_encoding = feature_maps_position_embeddings
 
-        return vision_outputs
+        return feature_maps, feature_maps_position_embeddings, vision_outputs.hidden_states, vision_outputs.attentions
 
 
 __all__ = [

transformers/models/sam3_tracker_video/processing_sam3_tracker_video.py

@@ -4,6 +4,7 @@
 #             the file from the modular. If any change should be done, please apply the change to the
 #                          modular_sam3_tracker_video.py file directly. One of our CI enforces this.
 #                🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# coding=utf-8
 # Copyright 2025 the HuggingFace Team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,9 +19,8 @@
 # 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
@@ -28,55 +28,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_sam3_tracker_video import Sam3TrackerVideoInferenceSession
 
 
 @requires(backends=("torch",))
-@auto_docstring
 class Sam3TrackerVideoProcessor(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.
+
+    [`Sam3TrackerVideoProcessor`] offers all the functionalities of [`Sam2ImageProcessorFast`] and [`Sam3TrackerVideoProcessor`]. See the docstring of
+    [`~Sam2ImageProcessorFast.__call__`] and [`~Sam3TrackerVideoProcessor.__call__`] for more information.
+
+    Args:
+        image_processor (`Sam2ImageProcessorFast`):
+            An instance of [`Sam2ImageProcessorFast`].
+        video_processor (`Sam3TrackerVideoVideoProcessor`):
+            An instance of [`Sam3TrackerVideoVideoProcessor`].
         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 [`Sam3TrackerVideoImageProcessorFast.__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:
@@ -377,11 +393,11 @@ class Sam3TrackerVideoProcessor(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.
@@ -513,11 +529,11 @@ class Sam3TrackerVideoProcessor(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,
     ):
@@ -568,12 +584,12 @@ class Sam3TrackerVideoProcessor(ProcessorMixin):
         self,
         inference_session: Sam3TrackerVideoInferenceSession,
         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,
     ) -> Sam3TrackerVideoInferenceSession:
         """
@@ -631,10 +647,10 @@ class Sam3TrackerVideoProcessor(ProcessorMixin):
         inference_session: Sam3TrackerVideoInferenceSession,
         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,
     ) -> Sam3TrackerVideoInferenceSession:
         """
@@ -740,7 +756,7 @@ class Sam3TrackerVideoProcessor(ProcessorMixin):
         inference_session: Sam3TrackerVideoInferenceSession,
         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/sam3_video/configuration_sam3_video.py

@@ -1,3 +1,4 @@
+# coding=utf-8
 # Copyright 2025 The HuggingFace Team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -95,9 +96,6 @@ class Sam3VideoConfig(PreTrainedConfig):
     >>> # Initializing a SAM3 Video configuration with default detector and tracker
     >>> configuration = Sam3VideoConfig()
 
-    >>> # Changing image size for custom resolution inference (automatically propagates to all nested configs)
-    >>> configuration.image_size = 560
-
     >>> # Initializing a model from the configuration
     >>> model = Sam3VideoModel(configuration)
 
@@ -227,16 +225,5 @@ class Sam3VideoConfig(PreTrainedConfig):
         self.high_conf_thresh = high_conf_thresh
         self.high_iou_thresh = high_iou_thresh
 
-    @property
-    def image_size(self):
-        """Image size for the video model."""
-        return self.detector_config.image_size
-
-    @image_size.setter
-    def image_size(self, value):
-        """Recursively propagate the image size to detector and tracker configs."""
-        self.detector_config.image_size = value
-        self.tracker_config.image_size = value
-
 
 __all__ = ["Sam3VideoConfig"]

transformers/models/sam3_video/modeling_sam3_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");
@@ -16,7 +17,7 @@
 from collections import OrderedDict, defaultdict
 from copy import deepcopy
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, Optional, Union
 
 import torch
 import torch.nn.functional as F
@@ -32,7 +33,7 @@ from .configuration_sam3_video import Sam3VideoConfig
 
 
 if is_kernels_available():
-    from ...integrations.hub_kernels import get_kernel
+    from kernels import get_kernel
 
 logger = logging.get_logger(__name__)
 
@@ -68,8 +69,8 @@ class Sam3VideoInferenceCache:
 
     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
@@ -94,7 +95,7 @@ class Sam3VideoInferenceCache:
                 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
@@ -140,13 +141,13 @@ class Sam3VideoInferenceSession:
 
     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
@@ -207,7 +208,7 @@ class Sam3VideoInferenceSession:
         self.output_buffer = []
 
     @property
-    def num_frames(self) -> int | None:
+    def num_frames(self) -> Optional[int]:
         """Number of frames in the video."""
         return len(self.processed_frames) if self.processed_frames is not None else None
 
@@ -320,8 +321,8 @@ class Sam3VideoInferenceSession:
         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,
     ):
         """
@@ -380,7 +381,7 @@ class Sam3VideoInferenceSession:
         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:
@@ -477,13 +478,13 @@ class Sam3VideoSegmentationOutput(ModelOutput):
         The frame index of the video.
     """
 
-    object_ids: list[int] | None = None
-    obj_id_to_mask: dict[int, torch.FloatTensor] | None = None
-    obj_id_to_score: dict[int, float] | None = None
-    obj_id_to_tracker_score: dict[int, float] | None = None
-    removed_obj_ids: set[int] | None = None
-    suppressed_obj_ids: set[int] | None = None
-    frame_idx: int | None = None
+    object_ids: Optional[list[int]] = None
+    obj_id_to_mask: Optional[dict[int, torch.FloatTensor]] = None
+    obj_id_to_score: Optional[dict[int, float]] = None
+    obj_id_to_tracker_score: Optional[dict[int, float]] = None
+    removed_obj_ids: Optional[set[int]] = None
+    suppressed_obj_ids: Optional[set[int]] = None
+    frame_idx: Optional[int] = None
 
 
 class Sam3VideoPreTrainedModel(PreTrainedModel):
@@ -504,6 +505,8 @@ class Sam3VideoPreTrainedModel(PreTrainedModel):
 
 @auto_docstring
 class Sam3VideoModel(Sam3VideoPreTrainedModel):
+    all_tied_weights_keys = {}
+
     def __init__(self, config: Sam3VideoConfig):
         super().__init__(config)
         self.config = config
@@ -539,8 +542,6 @@ class Sam3VideoModel(Sam3VideoPreTrainedModel):
 
         self.tracker_neck = Sam3VisionNeck(config.detector_config.vision_config)
 
-        self.post_init()
-
     def get_vision_features_for_tracker(self, vision_embeds: torch.Tensor):
         hidden_states = vision_embeds.last_hidden_state
         batch_size = hidden_states.shape[0]
@@ -1144,7 +1145,7 @@ class Sam3VideoModel(Sam3VideoPreTrainedModel):
     def _suppress_object_pw_area_shrinkage(
         self,
         pred_masks,
-        prompt_ids: list[int] | None = None,
+        prompt_ids: Optional[list[int]] = None,
     ):
         """
         This function suppresses masks that shrink in area after applying pixelwise non-overlapping constraints.
@@ -1178,7 +1179,7 @@ class Sam3VideoModel(Sam3VideoPreTrainedModel):
         inference_session: Sam3VideoInferenceSession,
         frame_idx: int,
         low_res_masks: Tensor,
-        reconditioned_masks: dict[int, Tensor] | None = None,
+        reconditioned_masks: Optional[dict[int, Tensor]] = None,
     ):
         """
         Run Sam3Tracker memory encoder, enforcing non-overlapping constraints globally.
@@ -1501,7 +1502,7 @@ class Sam3VideoModel(Sam3VideoPreTrainedModel):
         det_out: dict[str, Tensor],
         tracker_low_res_masks_global: Tensor,
         tracker_update_plan: dict,
-        reconditioned_obj_ids: set | None = None,
+        reconditioned_obj_ids: Optional[set] = None,
     ):
         """
         Build output dictionary with low-resolution masks.
@@ -1693,10 +1694,9 @@ class Sam3VideoModel(Sam3VideoPreTrainedModel):
     def forward(
         self,
         inference_session: Sam3VideoInferenceSession,
-        frame_idx: int | None = None,
-        frame: torch.Tensor | None = None,
+        frame_idx: Optional[int] = None,
+        frame: Optional[torch.Tensor] = None,
         reverse: bool = False,
-        **kwargs,
     ):
         r"""
         inference_session (`Sam3VideoInferenceSession`):
@@ -1762,7 +1762,7 @@ class Sam3VideoModel(Sam3VideoPreTrainedModel):
         self,
         inference_session: Sam3VideoInferenceSession,
         start_frame_idx: int,
-        max_frame_num_to_track: int | None = None,
+        max_frame_num_to_track: Optional[int] = None,
         reverse: bool = False,
     ):
         num_frames = inference_session.num_frames
@@ -1826,7 +1826,8 @@ class Sam3VideoModel(Sam3VideoPreTrainedModel):
             else:
                 yield_list = [out]  # output the current frame
 
-            yield from yield_list
+            for yield_out in yield_list:
+                yield yield_out
 
 
 @torch.jit.script

transformers/models/sam3_video/processing_sam3_video.py

@@ -1,3 +1,4 @@
+# coding=utf-8
 # Copyright 2025 The HuggingFace Team. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -11,7 +12,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from typing import Union
+from typing import Optional, Union
 
 import torch
 from torchvision.ops import masks_to_boxes
@@ -19,46 +20,65 @@ from torchvision.ops import masks_to_boxes
 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_sam3_video import Sam3VideoInferenceSession
 
 
 @requires(backends=("torch",))
-@auto_docstring
 class Sam3VideoProcessor(ProcessorMixin):
+    r"""
+    Constructs a SAM3 processor which wraps a SAM3 image processor and an 2D points & Bounding boxes processor into a
+    single processor.
+
+    [`Sam3Processor`] offers all the functionalities of [`Sam3ImageProcessor`] and [`Sam3VideoProcessor`]. See the docstring of
+    [`~Sam3ImageProcessor.__call__`] and [`~Sam3VideoProcessor.__call__`] for more information.
+
+    Args:
+        image_processor (`Sam3ImageProcessorFast`):
+            An instance of [`Sam3ImageProcessorFast`].
+        video_processor (`Sam2VideoVideoProcessor`):
+            An instance of [`Sam2VideoVideoProcessor`].
+        tokenizer ([`CLIPTokenizer`, `CLIPTokenizerFast`]):
+            An instance of [`PreTrainedTokenizer`, `PreTrainedTokenizerFast`]. The tokenizer is a required input.
+        target_size (`int`, *optional*):
+            The target size (target_size, target_size) to which the image will be resized.
+    """
+
     def __init__(
         self,
         image_processor,
         video_processor,
         tokenizer,
-        target_size: int | None = None,
+        target_size: Optional[int] = None,
         **kwargs,
     ):
-        r"""
-        target_size (`int`, *optional*):
-            The target size (target_size, target_size) to which the image will be resized.
-        """
         super().__init__(image_processor, video_processor, tokenizer, **kwargs)
         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,
-        original_sizes: list[list[float]] | torch.Tensor | None = None,
-        return_tensors: str | TensorType | None = None,
+        images: Optional[ImageInput] = None,
+        segmentation_maps: Optional[ImageInput] = None,
+        original_sizes: Optional[Union[list[list[float]], torch.Tensor]] = None,
+        return_tensors: Optional[Union[str, TensorType]] = None,
         **kwargs,
     ) -> BatchEncoding:
         r"""
-        images (`ImageInput`, *optional*):
-            The image(s) to process.
-        segmentation_maps (`ImageInput`, *optional*):
-            The segmentation maps to process (optional, for image processor).
-        original_sizes (`list[list[float]]`, `torch.Tensor`, *optional*):
-            The original sizes of the images. Only used when images is not provided.
+        This method uses [`Sam3VideoImageProcessorFast.__call__`] method to prepare image(s) for the model.
+
+        Args:
+            images (`ImageInput`, *optional*):
+                The image(s) to process.
+            segmentation_maps (`ImageInput`, *optional*):
+                The segmentation maps to process (optional, for image processor).
+            original_sizes (`list[list[float]]`, `torch.Tensor`, *optional*):
+                The original sizes of the images. Only used when images is not provided.
+            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:
@@ -89,7 +109,7 @@ class Sam3VideoProcessor(ProcessorMixin):
 
         return encoding_image_processor
 
-    def add_text_prompt(self, inference_session: Sam3VideoInferenceSession, text: str | list[str]):
+    def add_text_prompt(self, inference_session: Sam3VideoInferenceSession, text: Union[str, list[str]]):
         """
         Add text prompt(s) to the inference session.
 
@@ -123,11 +143,11 @@ class Sam3VideoProcessor(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,
     ):
@@ -239,7 +259,7 @@ class Sam3VideoProcessor(ProcessorMixin):
         self,
         inference_session,
         model_outputs,
-        original_sizes: list[list[float]] | torch.Tensor | None = None,
+        original_sizes: Optional[Union[list[list[float]], torch.Tensor]] = None,
     ):
         """
         Post-process model outputs to get final masks, boxes, and scores.
@@ -320,7 +340,7 @@ class Sam3VideoProcessor(ProcessorMixin):
 
             # slice those valid entries from the original outputs
             keep_idx = torch.nonzero(keep, as_tuple=True)[0]
-            keep_idx_gpu = keep_idx.to(device=out_binary_masks.device, non_blocking=True)
+            keep_idx_gpu = keep_idx.pin_memory().to(device=out_binary_masks.device, non_blocking=True)
 
             out_obj_ids = torch.index_select(out_obj_ids, 0, keep_idx)
             out_probs = torch.index_select(out_probs, 0, keep_idx)