# SAM3 ## Resumen SAM3 (Segment Anything Model 3) se presentó en [SAM 3: Segment Anything with Concepts](https://ai.meta.com/research/publications/sam-3-segment-anything-with-concepts/). SAM3 realiza **Segmentación de Conceptos con Prompts (PCS)** en imágenes. PCS toma como entrada texto y/o ejemplos de imagen (p. ej., "autobús escolar amarillo") y predice máscaras de instancia y semánticas para **cada objeto** que coincida con el concepto. El resumen del artículo es el siguiente: *Presentamos Segment Anything Model (SAM) 3, un modelo unificado que detecta, segmenta y realiza seguimiento de objetos en imágenes y vídeos a partir de prompts de concepto, que definimos como frases nominales cortas (p. ej., "autobús escolar amarillo"), ejemplos de imagen o una combinación de ambos. La Segmentación de Conceptos con Prompts (PCS) toma dichos prompts y devuelve máscaras de segmentación e identidades únicas para todas las instancias de objetos coincidentes. Para avanzar en PCS, construimos un motor de datos escalable que genera un conjunto de datos de alta calidad con 4M de etiquetas de concepto únicas, incluyendo negativos difíciles, en imágenes y vídeos. Nuestro modelo consta de un detector a nivel de imagen y un rastreador de vídeo basado en memoria que comparten un único backbone. El reconocimiento y la localización se desacoplan mediante una presencia head, lo que mejora la precisión de la detección. SAM 3 duplica la precisión de los sistemas existentes tanto en PCS de imagen como de vídeo, y mejora las capacidades anteriores de SAM en tareas de segmentación visual. Publicamos SAM 3 en código abierto junto con nuestro nuevo benchmark Segment Anything with Concepts (SA-Co) para la segmentación de conceptos con prompts.* Este modelo fue aportado por [yonigozlan](https://huggingface.co/yonigozlan) y [ronghanghu](https://huggingface.co/ronghanghu). ## Ejemplos de uso con 🤗 Transformers ### Prompts solo de texto ```python import requests import torch from PIL import Image from transformers import Sam3Model, Sam3Processor model = Sam3Model.from_pretrained("facebook/sam3", device_map="auto") processor = Sam3Processor.from_pretrained("facebook/sam3") # Load image image_url = "http://images.cocodataset.org/val2017/000000077595.jpg" image = Image.open(requests.get(image_url, stream=True).raw).convert("RGB") # Segment using text prompt inputs = processor(images=image, text="ear", return_tensors="pt").to(model.device) with torch.no_grad(): outputs = model(**inputs) # Post-process results results = processor.post_process_instance_segmentation( outputs, threshold=0.5, mask_threshold=0.5, target_sizes=inputs.get("original_sizes").tolist() )[0] print(f"Found {len(results['masks'])} objects") # Results contain: # - masks: Binary masks resized to original image size # - boxes: Bounding boxes in absolute pixel coordinates (xyxy format) # - scores: Confidence scores ``` ### Prompt de una sola caja delimitadora Segmenta objetos usando un recuadro delimitador en el concepto visual: ```python # Box in xyxy format: [x1, y1, x2, y2] in pixel coordinates # Example: laptop region box_xyxy = [100, 150, 500, 450] input_boxes = [[box_xyxy]] # [batch, num_boxes, 4] input_boxes_labels = [[1]] # 1 = positive box inputs = processor( images=image, input_boxes=input_boxes, input_boxes_labels=input_boxes_labels, return_tensors="pt" ).to(model.device) with torch.no_grad(): outputs = model(**inputs) # Post-process results results = processor.post_process_instance_segmentation( outputs, threshold=0.5, mask_threshold=0.5, target_sizes=inputs.get("original_sizes").tolist() )[0] ``` ### Varios prompts de caja (positivos y negativos) Use multiple boxes with positive and negative labels to refine the concept: ```python # Load kitchen image kitchen_url = "http://images.cocodataset.org/val2017/000000136466.jpg" kitchen_image = Image.open(requests.get(kitchen_url, stream=True).raw).convert("RGB") # Define two positive boxes (e.g., dial and button on oven) # Boxes are in xyxy format [x1, y1, x2, y2] in pixel coordinates box1_xyxy = [59, 144, 76, 163] # Dial box box2_xyxy = [87, 148, 104, 159] # Button box input_boxes = [[box1_xyxy, box2_xyxy]] input_boxes_labels = [[1, 1]] # Both positive inputs = processor( images=kitchen_image, input_boxes=input_boxes, input_boxes_labels=input_boxes_labels, return_tensors="pt" ).to(model.device) with torch.no_grad(): outputs = model(**inputs) # Post-process results results = processor.post_process_instance_segmentation( outputs, threshold=0.5, mask_threshold=0.5, target_sizes=inputs.get("original_sizes").tolist() )[0] ``` ### Prompts combinados (texto + cuadro negativo) Use prompts de texto con prompts visuales negativos para refinar el concepto: ```python # Segment "handle" but exclude the oven handle using a negative box text = "handle" # Negative box covering oven handle area (xyxy): [40, 183, 318, 204] oven_handle_box = [40, 183, 318, 204] input_boxes = [[oven_handle_box]] inputs = processor( images=kitchen_image, text=text, input_boxes=input_boxes, input_boxes_labels=[[0]], # 0 = negative (exclude this region) return_tensors="pt" ).to(model.device) with torch.no_grad(): outputs = model(**inputs) # Post-process results results = processor.post_process_instance_segmentation( outputs, threshold=0.5, mask_threshold=0.5, target_sizes=inputs.get("original_sizes").tolist() )[0] # This will segment pot handles but exclude the oven handle ``` ### Inferencia por lotes con prompts de texto Procesar varias imágenes con diferentes indicaciones de texto de manera eficiente: ```python cat_url = "http://images.cocodataset.org/val2017/000000077595.jpg" kitchen_url = "http://images.cocodataset.org/val2017/000000136466.jpg" images = [ Image.open(requests.get(cat_url, stream=True).raw).convert("RGB"), Image.open(requests.get(kitchen_url, stream=True).raw).convert("RGB") ] # Different text prompt for each image text_prompts = ["ear", "dial"] inputs = processor(images=images, text=text_prompts, return_tensors="pt").to(model.device) with torch.no_grad(): outputs = model(**inputs) # Post-process results for both images results = processor.post_process_instance_segmentation( outputs, threshold=0.5, mask_threshold=0.5, target_sizes=inputs.get("original_sizes").tolist() ) print(f"Image 1: {len(results[0]['masks'])} objects found") print(f"Image 2: {len(results[1]['masks'])} objects found") ``` ### Prompts mixtos por lotes Usa diferentes tipos de prompt para diferentes imágenes en el mismo batch: ```python # Image 1: text prompt "laptop" # Image 2: visual prompt (dial box) box2_xyxy = [59, 144, 76, 163] inputs = processor( images=images, text=["laptop", None], # Only first image has text input_boxes=[None, [box2_xyxy]], # Only second image has box input_boxes_labels=[None, [1]], # Positive box for second image return_tensors="pt" ).to(model.device) with torch.no_grad(): outputs = model(**inputs) # Post-process results for both images results = processor.post_process_instance_segmentation( outputs, threshold=0.5, mask_threshold=0.5, target_sizes=inputs.get("original_sizes").tolist() ) # Both images processed in single forward pass ``` ### Salida de segmentación semántica SAM3 también proporciona segmentación semántica junto con máscaras de instancias: ```python inputs = processor(images=image, text="ear", return_tensors="pt").to(model.device) with torch.no_grad(): outputs = model(**inputs) # Instance segmentation masks instance_masks = torch.sigmoid(outputs.pred_masks) # [batch, num_queries, H, W] # Semantic segmentation (single channel) semantic_seg = outputs.semantic_seg # [batch, 1, H, W] print(f"Instance masks: {instance_masks.shape}") print(f"Semantic segmentation: {semantic_seg.shape}") ``` ### Inferencia eficiente de múltiples indicaciones en una sola imagen Al ejecutar varios prompts de texto en la misma imagen, precalcula los embeddings visuales para evitar cálculos redundantes: ```python from transformers import Sam3Processor, Sam3Model import torch from PIL import Image import requests model = Sam3Model.from_pretrained("facebook/sam3", device_map="auto") processor = Sam3Processor.from_pretrained("facebook/sam3") # Load image image_url = "http://images.cocodataset.org/val2017/000000077595.jpg" image = Image.open(requests.get(image_url, stream=True).raw).convert("RGB") # Pre-process image and compute vision embeddings once img_inputs = processor(images=image, return_tensors="pt").to(model.device) with torch.no_grad(): vision_embeds = model.get_vision_features(pixel_values=img_inputs.pixel_values) # Run multiple text prompts efficiently text_prompts = ["ear", "eye", "nose"] all_results = [] for prompt in text_prompts: text_inputs = processor(text=prompt, return_tensors="pt").to(model.device) with torch.no_grad(): outputs = model(vision_embeds=vision_embeds, **text_inputs) ... results = processor.post_process_instance_segmentation( outputs, threshold=0.5, mask_threshold=0.5, target_sizes=img_inputs.get("original_sizes").tolist() )[0] all_results.append({"prompt": prompt, "results": results}) for item in all_results: print(f"Prompt '{item['prompt']}': {len(item['results']['masks'])} objects found") ``` ### Inferencia eficiente de un solo prompt en múltiples imágenes Al ejecutar el mismo prompt de texto en varias imágenes, precalcule los embeddings de texto para evitar cálculos redundantes: ```python from transformers import Sam3Processor, Sam3Model import torch from PIL import Image import requests model = Sam3Model.from_pretrained("facebook/sam3", device_map="auto") processor = Sam3Processor.from_pretrained("facebook/sam3") # Pre-compute text embeddings once text_prompt = "ear" text_inputs = processor(text=text_prompt, return_tensors="pt").to(model.device) with torch.no_grad(): text_embeds = model.get_text_features(**text_inputs) # Load multiple images image_urls = [ "http://images.cocodataset.org/val2017/000000077595.jpg", "http://images.cocodataset.org/val2017/000000039769.jpg", ] images = [Image.open(requests.get(url, stream=True).raw).convert("RGB") for url in image_urls] # Run inference on each image reusing text embeddings # Note: attention_mask must be passed along with text_embeds for proper masking all_results = [] for image in images: img_inputs = processor(images=image, return_tensors="pt").to(model.device) with torch.no_grad(): outputs = model( pixel_values=img_inputs.pixel_values, text_embeds=text_embeds, attention_mask=text_inputs.attention_mask, ) ... results = processor.post_process_instance_segmentation( outputs, threshold=0.5, mask_threshold=0.5, target_sizes=img_inputs.get("original_sizes").tolist() )[0] all_results.append(results) for i, results in enumerate(all_results): print(f"Image {i+1}: {len(results['masks'])} '{text_prompt}' objects found") ``` ### Inferencia con resolución personalizada ⚠️ **Nota sobre el rendimiento**: las resoluciones personalizadas pueden degradar la precisión. El modelo está diseñado para usarse con una resolución de 1008 px. Para una inferencia más rápida o un menor uso de memoria: ```python config = Sam3Config.from_pretrained("facebook/sam3") config.image_size = 560 model = Sam3Model.from_pretrained("facebook/sam3", config=config, device_map="auto") processor = Sam3Processor.from_pretrained("facebook/sam3", size={"height": 560, "width": 560}) ``` ### Convenciones de etiquetas de prompt SAM3 utiliza las siguientes convenciones de etiquetas: **Para puntos y cajas:** - `1`: Prompt positivo (incluye esta región/objeto) - `0`: Prompt negativo (excluir esta región/objeto) - `-10`: Valor de relleno para entradas por lotes **Formatos de coordenadas:** - **Cajas de entrada**: `[x1, y1, x2, y2]` (formato xyxy) en coordenadas de píxeles - **Cajas de salida** (crudas): `[x1, y1, x2, y2]` (formato xyxy), normalizadas a [0, 1] - **Cajas de salida** (postprocesadas): `[x1, y1, x2, y2]` (formato xyxy) en coordenadas de píxeles absolutas ## Sam3Config[[transformers.Sam3Config]] #### transformers.Sam3Config[[transformers.Sam3Config]] ```python transformers.Sam3Config(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, geometry_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, detr_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, detr_decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, mask_decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, initializer_range: float = 0.02) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/configuration_sam3.py#L197) **Parámetros:** vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : El objeto de configuración o el diccionario del backbone de visión. text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : El objeto de configuración o el diccionario del backbone de texto. geometry_encoder_config (`dict` o `Sam3GeometryEncoderConfig`, *opcional*) : Configuración del codificador de geometría. detr_encoder_config (`dict` o `Sam3DETREncoderConfig`, *opcional*) : Configuración del codificador DETR. detr_decoder_config (`dict` o `Sam3DETRDecoderConfig`, *opcional*) : Configuración del decodificador DETR. mask_decoder_config (`dict` o `Sam3MaskDecoderConfig`, *opcional*) : Configuración del decodificador de máscaras. initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos. Esta es la clase de configuración para almacenar la configuración de un Sam3Model. Se utiliza para instanciar un modelo Sam3 según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [facebook/sam3](https://huggingface.co/facebook/sam3) Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información. Ejemplo: ```python >>> from transformers import Sam3Config, Sam3Model >>> # Initializing a SAM3 configuration >>> configuration = Sam3Config() >>> # Initializing a model from the configuration >>> model = Sam3Model(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Sam3ViTConfig[[transformers.Sam3ViTConfig]] #### transformers.Sam3ViTConfig[[transformers.Sam3ViTConfig]] ```python transformers.Sam3ViTConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 1024, intermediate_size: int = 4736, num_hidden_layers: int = 32, num_attention_heads: int = 16, num_channels: int = 3, image_size: int | list[int] | tuple[int, int] = 1008, patch_size: int | list[int] | tuple[int, int] = 14, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-06, attention_dropout: float | int = 0.0, window_size: int = 24, global_attn_indexes: list[int] | None = None, layer_scale_init_value: float | None = None, pretrain_image_size: int | list[int] | tuple[int, int] = 336, hidden_dropout: float | int = 0.0, initializer_range: float = 0.02, rope_parameters: dict | None = None) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/configuration_sam3.py#L25) **Parámetros:** hidden_size (`int`, *opcional*, valor predeterminado `1024`) : Dimensión de las representaciones ocultas. intermediate_size (`int`, *opcional*, valor predeterminado `4736`) : Dimensión de las representaciones MLP. num_hidden_layers (`int`, *opcional*, valor predeterminado `32`) : Número de capas ocultas en el decodificador del Transformer. num_attention_heads (`int`, *opcional*, valor predeterminado `16`) : Número de cabezas de atención para cada capa de atención en el decodificador del Transformer. num_channels (`int`, *opcional*, valor predeterminado `3`) : El número de canales de entrada. image_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, valor predeterminado `1008`) : El tamaño (resolución) de cada imagen. patch_size (`Union[int, list[int], tuple[int, int]]`, *opcional*, valor predeterminado `14`) : El tamaño (resolución) de cada parche. hidden_act (`str`, *opcional*, valor predeterminado `gelu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc. layer_norm_eps (`float`, *opcional*, valor predeterminado `1e-06`) : El epsilon utilizado por las capas de normalización de capas. attention_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La proporción de dropout para las probabilidades de atención. window_size (`int`, *opcional*, valor predeterminado 24) : Tamaño de la ventana para la atención con ventanas. global_attn_indexes (`list[int]`, *opcional*, valor predeterminado `[7, 15, 23, 31]`) : Índices de las capas con atención global. layer_scale_init_value (`float`, *opcional*) : Escala a utilizar en las capas de autoatención. 0.1 para base, 1e-6 para large. Establezca 0 para deshabilitar la escala de capa. pretrain_image_size (`int`, *opcional*, valor predeterminado 336) : Tamaño de imagen del modelo preentrenado para la inicialización de la incrustación de posición. hidden_dropout (`float`, *opcional*, valor predeterminado 0.0) : Probabilidad de dropout para los estados ocultos. initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos. rope_parameters (`dict`, *opcional*) : Diccionario que contiene los parámetros de configuración para las incrustaciones RoPE. El diccionario debe contener un valor para `rope_theta` y, opcionalmente, parámetros utilizados para el escalado en caso de que desee usar RoPE con `max_position_embeddings` más largos. Esta es la clase de configuración para almacenar la configuración de un Sam3Model. Se utiliza para instanciar un modelo Sam3 según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [facebook/sam3](https://huggingface.co/facebook/sam3) Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información. ## Sam3VisionConfig[[transformers.Sam3VisionConfig]] #### transformers.Sam3VisionConfig[[transformers.Sam3VisionConfig]] ```python transformers.Sam3VisionConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, fpn_hidden_size: int = 256, backbone_feature_sizes: list | None = None, scale_factors: list[float] | None = None, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-06, initializer_range: float = 0.02) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/configuration_sam3.py#L68) **Parámetros:** backbone_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : La configuración del modelo de base. fpn_hidden_size (`int`, *opcional*, valor predeterminado 256) : La dimensión oculta del FPN. backbone_feature_sizes (`List[List[int]]`, *opcional*, valor predeterminado `[[288, 288], [144, 144], [72, 72]]`) : Los tamaños espaciales (altura, ancho) de los mapas de características del backbone en diferentes escalas. scale_factors (`list[float]`, *opcional*, valor predeterminado `[4.0, 2.0, 1.0, 0.5]`) : Factores de escala para las características multiescala de FPN. Lista de factores de escala para cada nivel de FPN. hidden_act (`str`, *opcional*, valor predeterminado `gelu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc. layer_norm_eps (`float`, *opcional*, valor predeterminado `1e-06`) : El epsilon utilizado por las capas de normalización de capas. initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos. Esta es la clase de configuración para almacenar la configuración de un Sam3Model. Se utiliza para instanciar un modelo Sam3 según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [facebook/sam3](https://huggingface.co/facebook/sam3) Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información. ## Sam3GeometryEncoderConfig[[transformers.Sam3GeometryEncoderConfig]] #### transformers.Sam3GeometryEncoderConfig[[transformers.Sam3GeometryEncoderConfig]] ```python transformers.Sam3GeometryEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 256, num_layers: int = 3, num_attention_heads: int = 8, intermediate_size: int = 2048, dropout: float | int = 0.1, hidden_act: str = 'relu', hidden_dropout: float | int = 0.0, layer_norm_eps: float = 1e-06, roi_size: int = 7, initializer_range: float = 0.02) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/configuration_sam3.py#L112) **Parámetros:** hidden_size (`int`, *opcional*, valor predeterminado `256`) : Dimensión de las representaciones ocultas. num_layers (`int`, *opcional*, valor predeterminado `3`) : Número de capas ocultas en el decodificador del Transformer. num_attention_heads (`int`, *opcional*, valor predeterminado `8`) : Número de cabezas de atención para cada capa de atención en el decodificador del Transformer. intermediate_size (`int`, *opcional*, valor predeterminado `2048`) : Dimensión de las representaciones MLP. dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La proporción para todas las capas de dropout. hidden_act (`str`, *opcional*, valor predeterminado `relu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc. hidden_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La probabilidad de dropout para todas las capas completamente conectadas en los embeddings, el codificador y el pooler. layer_norm_eps (`float`, *opcional*, valor predeterminado `1e-06`) : El epsilon utilizado por las capas de normalización de capas. roi_size (`int`, *opcional*, valor predeterminado 7) : Tamaño del ROI para las operaciones de box pooling. initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos. Esta es la clase de configuración para almacenar la configuración de un Sam3Model. Se utiliza para instanciar un modelo Sam3 según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [facebook/sam3](https://huggingface.co/facebook/sam3) Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información. ## Sam3DETREncoderConfig[[transformers.Sam3DETREncoderConfig]] #### transformers.Sam3DETREncoderConfig[[transformers.Sam3DETREncoderConfig]] ```python transformers.Sam3DETREncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 256, num_layers: int = 6, num_attention_heads: int = 8, intermediate_size: int = 2048, dropout: float | int = 0.1, hidden_act: str = 'relu', hidden_dropout: float | int = 0.0, layer_norm_eps: float = 1e-06, initializer_range: float = 0.02) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/configuration_sam3.py#L134) **Parámetros:** hidden_size (`int`, *opcional*, valor predeterminado `256`) : Dimensión de las representaciones ocultas. num_layers (`int`, *opcional*, valor predeterminado `6`) : Número de capas ocultas en el decodificador del Transformer. num_attention_heads (`int`, *opcional*, valor predeterminado `8`) : Número de cabezas de atención para cada capa de atención en el decodificador del Transformer. intermediate_size (`int`, *opcional*, valor predeterminado `2048`) : Dimensión de las representaciones MLP. dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La proporción para todas las capas de dropout. hidden_act (`str`, *opcional*, valor predeterminado `relu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc. hidden_dropout (`float`, *opcional*, valor predeterminado 0.0) : Probabilidad de dropout para los estados ocultos. layer_norm_eps (`float`, *opcional*, valor predeterminado `1e-06`) : El epsilon utilizado por las capas de normalización de capas. initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos. Esta es la clase de configuración para almacenar la configuración de un Sam3Model. Se utiliza para instanciar un modelo Sam3 según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [facebook/sam3](https://huggingface.co/facebook/sam3) Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información. ## Sam3DETRDecoderConfig[[transformers.Sam3DETRDecoderConfig]] #### transformers.Sam3DETRDecoderConfig[[transformers.Sam3DETRDecoderConfig]] ```python transformers.Sam3DETRDecoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 256, num_layers: int = 6, num_queries: int = 200, num_attention_heads: int = 8, intermediate_size: int = 2048, dropout: float | int = 0.1, hidden_act: str = 'relu', hidden_dropout: float | int = 0.0, layer_norm_eps: float = 1e-06, initializer_range: float = 0.02) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/configuration_sam3.py#L156) **Parámetros:** hidden_size (`int`, *opcional*, valor predeterminado `256`) : Dimensión de las representaciones ocultas. num_layers (`int`, *opcional*, valor predeterminado `6`) : Número de capas ocultas en el decodificador del Transformer. num_queries (`int`, *opcional*, valor predeterminado 200) : Número de consultas de objeto. num_attention_heads (`int`, *opcional*, valor predeterminado `8`) : Número de cabezas de atención para cada capa de atención en el decodificador del Transformer. intermediate_size (`int`, *opcional*, valor predeterminado `2048`) : Dimensión de las representaciones MLP. dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La proporción para todas las capas de dropout. hidden_act (`str`, *opcional*, valor predeterminado `relu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc. hidden_dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La probabilidad de dropout para todas las capas completamente conectadas en los embeddings, el codificador y el pooler. layer_norm_eps (`float`, *opcional*, valor predeterminado `1e-06`) : El epsilon utilizado por las capas de normalización de capas. initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos. Esta es la clase de configuración para almacenar la configuración de un Sam3Model. Se utiliza para instanciar un modelo Sam3 según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [facebook/sam3](https://huggingface.co/facebook/sam3) Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información. ## Sam3MaskDecoderConfig[[transformers.Sam3MaskDecoderConfig]] #### transformers.Sam3MaskDecoderConfig[[transformers.Sam3MaskDecoderConfig]] ```python transformers.Sam3MaskDecoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 256, num_upsampling_stages: int = 3, layer_norm_eps: float = 1e-06, dropout: float | int = 0.0, num_attention_heads: int = 8, initializer_range: float = 0.02) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/configuration_sam3.py#L179) **Parámetros:** hidden_size (`int`, *opcional*, valor predeterminado `256`) : Dimensión de las representaciones ocultas. num_upsampling_stages (`int`, *opcional*, valor predeterminado 3) : Número de etapas de remuestreo ascendente en el decodificador de píxeles (FPN). layer_norm_eps (`float`, *opcional*, valor predeterminado `1e-06`) : El epsilon utilizado por las capas de normalización de capas. dropout (`Union[float, int]`, *opcional*, valor predeterminado `0.0`) : La proporción para todas las capas de dropout. num_attention_heads (`int`, *opcional*, valor predeterminado `8`) : Número de cabezas de atención para cada capa de atención en el decodificador del Transformer. initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos. Esta es la clase de configuración para almacenar la configuración de un Sam3Model. Se utiliza para instanciar un modelo Sam3 según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [facebook/sam3](https://huggingface.co/facebook/sam3) Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información. ## Sam3Processor[[transformers.Sam3Processor]] #### transformers.Sam3Processor[[transformers.Sam3Processor]] ```python transformers.Sam3Processor(image_processor, tokenizer, target_size: int | None = None, point_pad_value: int = -10, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/processing_sam3.py#L87) **Parámetros:** image_processor (`Sam3ImageProcessor`) : El procesador de imágenes es un parámetro de entrada obligatorio. tokenizer (`CLIPTokenizer`) : El tokenizador es una entrada obligatoria. target_size (`int`, *opcional*) : El tamaño objetivo (target_size, target_size) al que se redimensionará la imagen. point_pad_value (`int`, *opcional*, valor predeterminado: -10) : El valor utilizado para rellenar las cajas de entrada. Construye un Sam3Processor que envuelve un procesador de imágenes y un tokenizador en un único procesador. [Sam3Processor](/docs/transformers/main/es/model_doc/sam3#transformers.Sam3Processor) ofrece todas las funcionalidades de [Sam3ImageProcessor](/docs/transformers/main/es/model_doc/sam3#transformers.Sam3ImageProcessor) y [CLIPTokenizer](/docs/transformers/main/es/model_doc/clip#transformers.CLIPTokenizer). Consulte [~Sam3ImageProcessor](/docs/transformers/main/es/model_doc/sam3#transformers.Sam3ImageProcessor) y [~CLIPTokenizer](/docs/transformers/main/es/model_doc/clip#transformers.CLIPTokenizer) para obtener más información. #### __llamada__[[transformers.Sam3Processor.__call__]] ```python __call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] | list[list[str]] | None = None, segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, input_boxes: typing.Union[list[list[list[float]]], torch.Tensor, NoneType] = None, input_boxes_labels: typing.Union[list[list[list[int]]], torch.Tensor, NoneType] = None, original_sizes: typing.Union[list[list[float]], torch.Tensor, NoneType] = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, **kwargs) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/processing_sam3.py#L101) **Parámetros:** images (`ImageInput`, *opcional*) : La(s) imagen(es) a procesar. text (`str`, `list[str]`, `list[list[str]]`, *opcional*) : El texto a procesar. segmentation_maps (`ImageInput`, *opcional*) : Los mapas de segmentación a procesar. input_boxes (`list[list[list[float]]]`, `torch.Tensor`, *opcional*) : Las cajas delimitadoras a procesar. input_boxes_labels (`list[list[int]]`, `torch.Tensor`, *opcional*) : Las etiquetas para las cajas delimitadoras. original_sizes (`list[list[float]]`, `torch.Tensor`, *opcional*) : Los tamaños originales de las imágenes. return_tensors (`Union[str, ~utils.generic.TensorType]`, *opcional*) : Si se establece, devolverá tensores de un marco de trabajo específico. Los valores aceptables son: - `'pt'`: Devuelve objetos `torch.Tensor` de PyTorch. - `'np'`: Devuelve objetos `np.ndarray` de NumPy. **Devuelve:** un [BatchEncoding](/docs/transformers/main/es/main_classes/tokenizer#transformers.BatchEncoding) con los siguientes campos - `pixel_values` (`torch.Tensor`): La(s) imagen(es) procesada(s). - `original_sizes` (`list[list[float]]`): Los tamaños originales de las imágenes. - `labels` (`torch.Tensor`): Los mapas de segmentación procesados (si se proporcionan). - `input_boxes_labels` (`torch.Tensor`): Las etiquetas procesadas para las cajas delimitadoras. - `input_boxes` (`torch.Tensor`): Las cajas delimitadoras procesadas. ## Sam3ImageProcessor[[transformers.Sam3ImageProcessor]] #### transformers.Sam3ImageProcessor[[transformers.Sam3ImageProcessor]] ```python transformers.Sam3ImageProcessor(**kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/image_processing_sam3.py#L400) **Parámetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe convertir la imagen a RGB. do_resize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe redimensionar la imagen. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, por defecto `{'height' : 1008, 'width': 1008}`): Describe las dimensiones máximas de entrada para el modelo. default_to_square (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe usar una imagen cuadrada por defecto al redimensionar, cuando el tamaño es un entero. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, por defecto `2`) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`. do_rescale (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Indica si se debe reescalar la imagen. rescale_factor (`float`, *kwargs*, *opcional*, valor predeterminado `0.00392156862745098`) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`. do_normalize (`bool`, *kwargs*, *opcional*, valor predeterminado `True`) : Si se debe normalizar la imagen. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.5, 0.5, 0.5]`) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, valor predeterminado `[0.5, 0.5, 0.5]`) : Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. do_pad (`bool`, *kwargs*, *opcional*, valor predeterminado `None`) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, por defecto `None`) : El tamaño en `{"height": int, "width" int}` al que rellenas las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador. mask_size (`dict[str, *kwargs*, int]`, *opcional*) : El tamaño `{"height": int, "width": int}` al que se redimensionarán los mapas de segmentación. Construye un procesador de imágenes Sam3ImageProcessor. #### preprocess[[transformers.Sam3ImageProcessor.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/image_processing_sam3.py#L420) **Parámetros:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Imagen a preprocesar. Espera una imagen única o un lote de imágenes con valores de píxeles que van de 0 a 255. Si se pasan imágenes con valores de píxeles entre 0 y 1, establezca `do_rescale=False`. segmentation_maps (`ImageInput`, *opcional*) : Los mapas de segmentación que se van a preprocesar. do_convert_rgb (`bool`, *kwargs*, *opcional*) : Si se debe convertir la imagen a RGB. do_resize (`bool`, *kwargs*, *opcional*) : Si se debe redimensionar la imagen. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Describe las dimensiones máximas de entrada del modelo. default_to_square (`bool`, *kwargs*, *opcional*) : Si el tamaño es un entero, si se debe usar una imagen cuadrada por defecto al redimensionar. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamaño de la imagen de salida tras aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de remuestreo que se utilizará si se redimensiona la imagen. Puede ser uno de los valores de la enumeración `PILImageResampling`. Solo tiene efecto si `do_resize` está establecido en `True`. do_rescale (`bool`, *kwargs*, *opcional*) : Si se debe reescalar la imagen. rescale_factor (`float`, *kwargs*, *opcional*) : Factor de reescalado para reescalar la imagen si `do_rescale` está establecido en `True`. do_normalize (`bool`, *kwargs*, *opcional*) : Si se debe normalizar la imagen. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Media de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desviación estándar de la imagen a utilizar para la normalización. Solo tiene efecto si `do_normalize` está establecido en `True`. do_pad (`bool`, *kwargs*, *opcional*) : Indica si se debe aplicar relleno a la imagen. El relleno se realiza hasta el tamaño más grande del lote o hasta un tamaño cuadrado fijo por imagen. La estrategia exacta de relleno depende del modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : El tamaño en `{"height": int, "width" int}` al que se rellenan las imágenes. Debe ser mayor que el tamaño de cualquier imagen proporcionada para el preprocesamiento. Si no se proporciona `pad_size`, las imágenes se rellenarán hasta la mayor altura y anchura del lote. Se aplica solo cuando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Si se debe recortar la imagen centrada. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Solo se admite `ChannelDimension.FIRST`. Se añadió para garantizar la compatibilidad con los procesadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : El formato de la dimensión de canal para la imagen de entrada. Si no se establece, el formato de la dimensión de canal se infiere a partir de la imagen de entrada. Puede ser uno de: - `"channels_first"` o `ChannelDimension.FIRST`: imagen en formato (num_channels, height, width). - `"channels_last"` o `ChannelDimension.LAST`: imagen en formato (height, width, num_channels). - `"none"` o `ChannelDimension.NONE`: imagen en formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : El dispositivo en el que se procesarán los vídeos. Si no se establece, el dispositivo se infiere a partir de los vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Devuelve tensores apilados si se establece en `'pt'`; en caso contrario, devuelve una lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Si se debe deshabilitar el agrupamiento de imágenes por tamaño para procesarlas de forma individual y no en lotes. Si es None, se establecerá en True si las imágenes están en CPU, y en False en caso contrario. Esta elección se basa en observaciones empíricas, como se detalla aquí: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : El número de tokens de imagen que se utilizarán para cada imagen en la entrada. Se añadió por compatibilidad con versiones anteriores, pero en los modelos futuros esto debería configurarse como un atributo del procesador. mask_size (`dict[str, *kwargs*, int]`, *opcional*) : El tamaño `{"height": int, "width": int}` al que se redimensionarán los mapas de segmentación. **Devuelve:** `~image_processing_base.BatchFeature` - **data** (`dict`) -- Diccionario de listas/arrays/tensores devueltos por el método __call__ ('pixel_values', etc.). - **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Puede especificar un tensor_type aquí para convertir las listas de enteros en Tensors de PyTorch/Numpy durante la inicialización. ## Sam3ViTModel[[transformers.Sam3ViTModel]] #### transformers.Sam3ViTModel[[transformers.Sam3ViTModel]] ```python transformers.Sam3ViTModel(config: Sam3ViTConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/modeling_sam3.py#L828) **Parámetros:** config ([Sam3ViTConfig](/docs/transformers/main/es/model_doc/sam3#transformers.Sam3ViTConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo. El modelo Sam3 básico que genera estados ocultos sin ningún cabezal específico en la parte superior. Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.). Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales. #### forward[[transformers.Sam3ViTModel.forward]] ```python forward(pixel_values: Tensor, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/modeling_sam3.py#L851) **Parámetros:** pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener mediante [Sam3ImageProcessor](/docs/transformers/main/es/model_doc/sam3#transformers.Sam3ImageProcessor). Consulte [Sam3ImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para obtener más detalles ([Sam3Processor](/docs/transformers/main/es/model_doc/sam3#transformers.Sam3Processor) utiliza [Sam3ImageProcessor](/docs/transformers/main/es/model_doc/sam3#transformers.Sam3ImageProcessor) para procesar las imágenes). **Devuelve:** [BaseModelOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutput) o `tuple(torch.Tensor)` Un [BaseModelOutput](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutput) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Sam3Config](/docs/transformers/main/es/model_doc/sam3#transformers.Sam3Config)) y las entradas. El método forward de [Sam3ViTModel](/docs/transformers/main/es/model_doc/sam3#transformers.Sam3ViTModel) reemplaza el método especial `__call__`. Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. ## Sam3VisionModel[[transformers.Sam3VisionModel]] #### transformers.Sam3VisionModel[[transformers.Sam3VisionModel]] ```python transformers.Sam3VisionModel(config: Sam3VisionConfig) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/modeling_sam3.py#L1088) **Parámetros:** config ([Sam3VisionConfig](/docs/transformers/main/es/model_doc/sam3#transformers.Sam3VisionConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo. El modelo de visión de Sam sin ninguna cabeza ni proyección en la parte superior. Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.). Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales. #### forward[[transformers.Sam3VisionModel.forward]] ```python forward(pixel_values: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/modeling_sam3.py#L1103) ## Sam3Model[[transformers.Sam3Model]] #### transformers.Sam3Model[[transformers.Sam3Model]] ```python transformers.Sam3Model(config: Sam3Config) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/modeling_sam3.py#L2187) #### forward[[transformers.Sam3Model.forward]] ```python forward(pixel_values: typing.Optional[torch.Tensor] = None, vision_embeds: transformers.models.sam3.modeling_sam3.Sam3VisionEncoderOutput | None = None, input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, text_embeds: typing.Optional[torch.Tensor] = None, input_boxes: typing.Optional[torch.Tensor] = None, input_boxes_labels: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/modeling_sam3.py#L2300) **Parámetros:** pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener usando [Sam3ImageProcessor](/docs/transformers/main/es/model_doc/sam3#transformers.Sam3ImageProcessor). Consulte [Sam3ImageProcessor.__call__()](/docs/transformers/main/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles ([Sam3Processor](/docs/transformers/main/es/model_doc/sam3#transformers.Sam3Processor) utiliza [Sam3ImageProcessor](/docs/transformers/main/es/model_doc/sam3#transformers.Sam3ImageProcessor) para procesar las imágenes). vision_embeds (`Sam3VisionEncoderOutput`, *opcional*) : Incrustaciones visuales precalculadas. Se pueden utilizar para reutilizar fácilmente las incrustaciones visuales. Si se proporciona, no se debe pasar `pixel_values`. Es mutuamente excluyente con `pixel_values`. input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) text_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Incrustaciones de texto precalculadas. Se pueden utilizar para reutilizar fácilmente las incrustaciones de texto. Si se proporcionan, no se debe pasar `input_ids`. Es mutuamente excluyente con `input_ids`. input_boxes (`torch.Tensor` de forma `(batch_size, num_boxes, 4)`, *opcional*) : Coordenadas de caja normalizadas en el rango [0, 1], en formato (cx, cy, w, h). input_boxes_labels (`torch.LongTensor` de forma `(batch_size, num_boxes)`, *opcional*) : Etiquetas para las cajas: 1 (positiva), 0 (negativa). **Devuelve:** `Sam3ImageSegmentationOutput` o `tuple(torch.Tensor)` Un `Sam3ImageSegmentationOutput` o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Sam3Config](/docs/transformers/main/es/model_doc/sam3#transformers.Sam3Config)) y las entradas. El método forward de [Sam3Model](/docs/transformers/main/es/model_doc/sam3#transformers.Sam3Model) reemplaza el método especial `__call__`. Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente. - **pred_masks** (`torch.Tensor` de forma `(batch_size, num_queries, height, width)`) -- Máscaras de segmentación predichas para cada consulta. - **pred_boxes** (`torch.Tensor` de forma `(batch_size, num_queries, 4)`) -- Cajas delimitadoras predichas en formato (x1, y1, x2, y2). - **pred_logits** (`torch.Tensor` de forma `(batch_size, num_queries)`, *opcional*) -- Puntuaciones de confianza de clasificación para cada consulta, calculadas mediante el producto punto entre las características de consulta del decodificador y las características de texto. - **presence_logits** (`torch.Tensor` de forma `(batch_size, 1)`, *opcional*) -- Logits de presencia del token de presencia del decodificador DETR (solo la última capa). Estos indican si hay objetos presentes en la escena. Se pueden utilizar para calcular las puntuaciones finales multiplicando por pred_logits: `final_scores = pred_logits.sigmoid() * presence_logits.sigmoid()`. - **semantic_seg** (`torch.Tensor` de forma `(batch_size, 1, height, width)`, *opcional*) -- Salida de segmentación semántica. - **decoder_hidden_states** (`tuple[torch.Tensor]`, *opcional*) -- Tupla de estados ocultos de todas las capas del decodificador de DETR. Cada tensor tiene la forma `(batch_size, num_queries, hidden_size)`. - **decoder_reference_boxes** (`torch.Tensor` de forma `(num_layers, batch_size, num_queries, 4)`, *opcional*) -- Cajas de referencia de todas las capas del decodificador DETR. - **encoder_hidden_states** (`tuple[torch.Tensor]`, *opcional*) -- Tupla de estados ocultos de todas las capas del codificador DETR. - **vision_hidden_states** (`tuple[torch.Tensor]`, *opcional*) -- Tupla de estados ocultos de todas las capas del codificador de visión (ViT). - **vision_attentions** (`tuple[torch.Tensor]`, *opcional*) -- Pesos de atención de las capas del codificador de visión (ViT). - **detr_encoder_attentions** (`tuple[torch.Tensor]`, *opcional*) -- Pesos de atención de las capas del codificador de DETR. - **detr_decoder_attentions** (`tuple[torch.Tensor]`, *opcional*) -- Pesos de atención de las capas del decodificador de DETR (autoatención y atención cruzada). - **mask_decoder_attentions** (`tuple[torch.Tensor]`, *opcional*) -- Pesos de atención de las capas del decodificador de máscaras. Ejemplo: ```python >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from transformers import AutoModel, AutoProcessor >>> model = AutoModel.from_pretrained("facebook/sam3") >>> processor = AutoProcessor.from_pretrained("facebook/sam3") >>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/sam-car.png" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())).convert("RGB") >>> text = "car" >>> inputs = processor(images=image, text=text, return_tensors="pt") >>> # Get segmentation output >>> outputs = model(**inputs) >>> pred_masks = outputs.pred_masks >>> pred_boxes = outputs.pred_boxes ``` #### get_text_features[[transformers.Sam3Model.get_text_features]] ```python get_text_features(input_ids: LongTensor, attention_mask: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Fuente](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3/modeling_sam3.py#L2227) **Parámetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`) : Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`: - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**. [¿Qué son las máscaras de atención?](../glossary#attention-mask) **Devuelve:** [BaseModelOutputWithPooling](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o `tuple(torch.Tensor)` Un [BaseModelOutputWithPooling](/docs/transformers/main/es/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([Sam3Config](/docs/transformers/main/es/model_doc/sam3#transformers.Sam3Config)) y las entradas. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto de la última capa del primer token de la secuencia (token de clasificación) después de un procesamiento adicional a través de las capas utilizadas para la tarea de preentrenamiento auxiliar. Por ejemplo, para la familia de modelos BERT, esto devuelve el token de clasificación después de procesarlo a través de una capa lineal y una función de activación tanh. Los pesos de la capa lineal se entrenan a partir del objetivo de predicción de la siguiente oración (clasificación) durante el preentrenamiento. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. Ejemplo: ```python >>> from transformers import Sam3Model, Sam3Processor >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> model = Sam3Model.from_pretrained("facebook/sam3") >>> processor = Sam3Processor.from_pretrained("facebook/sam3") >>> # Pre-compute text embeddings >>> text_inputs = processor(text="cat", return_tensors="pt") >>> text_embeds = model.get_text_features(**text_inputs).pooler_output >>> # Reuse text embeddings for multiple images >>> url = "http://images.cocodataset.org/val2017/000000077595.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> img_inputs = processor(images=image, return_tensors="pt") >>> outputs = model(pixel_values=img_inputs.pixel_values, text_embeds=text_embeds) ```