Hugging Face's logo

Transformers documentation

SAM3

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo fue aportado a Hugging Face Transformers el 2025-11-19.

SAM3

SDPA FlashAttention

Resumen

SAM3 (Segment Anything Model 3) se presentó en SAM 3: Segment Anything with Concepts.

SAM3 realiza Segmentación de Conceptos con Prompt (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 videos basándose en prompts de concepto, que definimos como frases nominales cortas (p. ej., “yellow school bus”), 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 produce un conjunto de datos de alta calidad con 4M de etiquetas de concepto únicas, incluyendo negativos difíciles, en imágenes y videos. Nuestro modelo consiste en un detector a nivel de imagen y un rastreador de video 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 imágenes como de videos, 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 y ronghanghu.

Ejemplos de uso con 🤗 Transformers

Prompts solo de texto

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:

# 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:

# 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:

# 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:

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:

# 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:

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:

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:

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 1008px.

Para una inferencia más rápida o un menor uso de memoria:

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

clase transformers.Sam3Config

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonegeometry_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonedetr_encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonedetr_decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonemask_decoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneinitializer_range: float = 0.02 )

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 para el 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 del 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

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Ejemplo:

>>> 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

clase transformers.Sam3ViTConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 1024intermediate_size: int = 4736num_hidden_layers: int = 32num_attention_heads: int = 16num_channels: int = 3image_size: int | list[int] | tuple[int, int] = 1008patch_size: int | list[int] | tuple[int, int] = 14hidden_act: str = 'gelu'layer_norm_eps: float = 1e-06attention_dropout: float | int = 0.0window_size: int = 24global_attn_indexes: list[int] | None = Nonelayer_scale_init_value: float | None = Nonepretrain_image_size: int | list[int] | tuple[int, int] = 336hidden_dropout: float | int = 0.0initializer_range: float = 0.02rope_parameters: dict | None = None )

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 del 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 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) — La epsilon utilizada por las capas de normalización de capa.
  • 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 grande. 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 del 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, los 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

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Sam3VisionConfig

clase transformers.Sam3VisionConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonebackbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonefpn_hidden_size: int = 256backbone_feature_sizes: list | None = Nonescale_factors: list[float] | None = Nonehidden_act: str = 'gelu'layer_norm_eps: float = 1e-06initializer_range: float = 0.02 )

Parámetros

  • backbone_config (Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — La configuración del modelo backbone.
  • 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) — La epsilon utilizada por las capas de normalización de capa.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del 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

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Sam3GeometryEncoderConfig

clase transformers.Sam3GeometryEncoderConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 256num_layers: int = 3num_attention_heads: int = 8intermediate_size: int = 2048dropout: float | int = 0.1hidden_act: str = 'relu'hidden_dropout: float | int = 0.0layer_norm_eps: float = 1e-06roi_size: int = 7initializer_range: float = 0.02 )

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 Transformer.
  • intermediate_size (int, opcional, valor predeterminado 2048) — Dimensión de las representaciones del 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 totalmente conectadas en las incrustaciones, el codificador y el pooler.
  • layer_norm_eps (float, opcional, valor predeterminado 1e-06) — La epsilon utilizada por las capas de normalización de capa.
  • 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 del 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

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Sam3DETREncoderConfig

clase transformers.Sam3DETREncoderConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 256num_layers: int = 6num_attention_heads: int = 8intermediate_size: int = 2048dropout: float | int = 0.1hidden_act: str = 'relu'hidden_dropout: float | int = 0.0layer_norm_eps: float = 1e-06initializer_range: float = 0.02 )

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 Transformer.
  • intermediate_size (int, opcional, valor predeterminado 2048) — Dimensión de las representaciones del 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) — La epsilon utilizada por las capas de normalización de capa.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del 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

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Sam3DETRDecoderConfig

clase transformers.Sam3DETRDecoderConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 256num_layers: int = 6num_queries: int = 200num_attention_heads: int = 8intermediate_size: int = 2048dropout: float | int = 0.1hidden_act: str = 'relu'hidden_dropout: float | int = 0.0layer_norm_eps: float = 1e-06initializer_range: float = 0.02 )

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 objetos.
  • num_attention_heads (int, opcional, valor predeterminado 8) — Número de cabezas de atención para cada capa de atención en el decodificador Transformer.
  • intermediate_size (int, opcional, valor predeterminado 2048) — Dimensión de las representaciones del 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 totalmente conectadas en las incrustaciones, el codificador y el pooler.
  • layer_norm_eps (float, opcional, valor predeterminado 1e-06) — La epsilon utilizada por las capas de normalización de capa.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del 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

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Sam3MaskDecoderConfig

clase transformers.Sam3MaskDecoderConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 256num_upsampling_stages: int = 3layer_norm_eps: float = 1e-06dropout: float | int = 0.0num_attention_heads: int = 8initializer_range: float = 0.02 )

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) — La epsilon utilizada por las capas de normalización de capa.
  • 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 Transformer.
  • initializer_range (float, opcional, valor predeterminado 0.02) — La desviación estándar del 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

Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.

Sam3Processor

clase transformers.Sam3Processor

< >

( image_processortokenizertarget_size: int | None = Nonepoint_pad_value: int = -10**kwargs )

Parámetros

  • image_processor (Sam3ImageProcessor) — El procesador de imágenes es una entrada obligatoria.
  • 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 ofrece todas las funcionalidades de Sam3ImageProcessor y CLIPTokenizer. Consulte ~Sam3ImageProcessor y ~CLIPTokenizer para obtener más información.

__call__

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonetext: str | list[str] | list[list[str]] | None = Nonesegmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Noneinput_boxes: typing.Union[list[list[list[float]]], torch.Tensor, NoneType] = Noneinput_boxes_labels: typing.Union[list[list[list[int]]], torch.Tensor, NoneType] = Noneoriginal_sizes: typing.Union[list[list[float]], torch.Tensor, NoneType] = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = None**kwargs ) → A BatchEncoding with the following fields

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 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

clase transformers.Sam3ImageProcessor

< >

( **kwargs: *<class 'transformers.models.sam3.image_processing_sam3.Sam3ImageProcessorKwargs'> )

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 de entrada máximas para el modelo.
  • default_to_square (bool, kwargs, opcional, valor predeterminado True) — Si se debe usar una imagen cuadrada por defecto al redimensionar, si size es un int.
  • 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 a 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) — 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 se establece 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 se rellenan las imágenes. Debe ser mayor que cualquier tamaño de imagen proporcionado 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 canales para la imagen de entrada. Si no se establece, el formato de la dimensión de canales 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 (altura, ancho, num_canales).
    • "none" o ChannelDimension.NONE: imagen en formato (altura, ancho).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — El dispositivo en el que se procesarán los videos. Si no se establece, el dispositivo se infiere a partir de los videos 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. Añadido por compatibilidad con versiones anteriores, pero en futuros modelos debería establecerse como un atributo del procesador.
  • mask_size (dict[str, *kwargs*, int], opcional) — El tamaño {"height": int, "width": int} al que redimensionar los mapas de segmentación.

Construye un procesador de imágenes Sam3ImageProcessor.

preprocesar

< >

( 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: *<class 'transformers.models.sam3.image_processing_sam3.Sam3ImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature

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 de entrada máximas del modelo.
  • default_to_square (bool, kwargs, opcional) — Si se debe usar una imagen cuadrada por defecto al redimensionar, si size es un int.
  • 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 a utilizar si se redimensiona la imagen. Puede ser uno de los enum 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 cualquier tamaño de imagen proporcionado 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 canales para la imagen de entrada. Si no se establece, el formato de la dimensión de canales 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 (altura, ancho, num_canales).
    • "none" o ChannelDimension.NONE: imagen en formato (altura, ancho).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — El dispositivo en el que se procesarán los videos. Si no se establece, el dispositivo se infiere a partir de los videos 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. Añadido por compatibilidad con versiones anteriores, pero en futuros modelos debería establecerse como un atributo del procesador.
  • mask_size (dict[str, *kwargs*, int], opcional) — El tamaño {"height": int, "width": int} al que redimensionar 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

clase transformers.Sam3ViTModel

< >

( config: Sam3ViTConfig )

Parámetros

  • config (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() 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. Consulta 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 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

< >

( pixel_values: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutput or tuple(torch.FloatTensor)

Parámetros

Devuelve

BaseModelOutput o tuple(torch.FloatTensor)

Un BaseModelOutput o una tupla de torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (Sam3Config) y las entradas.

El método forward de 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 pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • last_hidden_state (torch.FloatTensor 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.FloatTensor), opcional, se devuelve cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.FloatTensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + 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.FloatTensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.FloatTensor (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

clase transformers.Sam3VisionModel

< >

( config: Sam3VisionConfig )

Parámetros

  • config (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() 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. Consulta 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 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

< >

( pixel_values: typing.Optional[torch.FloatTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )

Sam3Model

clase transformers.Sam3Model

< >

( config: Sam3Config )

forward

< >

( pixel_values: typing.Optional[torch.FloatTensor] = Nonevision_embeds: transformers.models.sam3.modeling_sam3.Sam3VisionEncoderOutput | None = Noneinput_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetext_embeds: typing.Optional[torch.FloatTensor] = Noneinput_boxes: typing.Optional[torch.FloatTensor] = Noneinput_boxes_labels: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sam3ImageSegmentationOutput or tuple(torch.FloatTensor)

Parámetros

  • pixel_values (torch.FloatTensor 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 utilizando Sam3ImageProcessor. Consulte Sam3ImageProcessor.call() para más detalles (Sam3Processor utiliza 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 usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

  • text_embeds (torch.FloatTensor 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 proporciona, no se debe pasar input_ids. Es mutuamente excluyente con input_ids.
  • input_boxes (torch.FloatTensor de forma (batch_size, num_boxes, 4), opcional) — Coordenadas de cajas 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 (positivo), 0 (negativo).

Devuelve

Sam3ImageSegmentationOutput o tuple(torch.FloatTensor)

Un Sam3ImageSegmentationOutput o una tupla de torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (Sam3Config) y las entradas.

El método forward de 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 pre y postprocesamiento, mientras que la segunda los ignora silenciosamente.

  • pred_masks (torch.FloatTensor de forma (batch_size, num_queries, height, width)) — Máscaras de segmentación predichas para cada consulta.
  • pred_boxes (torch.FloatTensor de forma (batch_size, num_queries, 4)) — Cajas delimitadoras predichas en el formato (x1, y1, x2, y2).
  • pred_logits (torch.FloatTensor 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.FloatTensor 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 usar para calcular las puntuaciones finales multiplicando por pred_logits: final_scores = pred_logits.sigmoid() * presence_logits.sigmoid().
  • semantic_seg (torch.FloatTensor de forma (batch_size, 1, height, width), opcional) — Salida de segmentación semántica.
  • decoder_hidden_states (tuple[torch.FloatTensor], opcional) — Tupla de estados ocultos de todas las capas del decodificador de DETR. Cada tensor tiene forma (batch_size, num_queries, hidden_size).
  • decoder_reference_boxes (torch.FloatTensor 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.FloatTensor], opcional) — Tupla de estados ocultos de todas las capas del codificador DETR.
  • vision_hidden_states (tuple[torch.FloatTensor], opcional) — Tupla de estados ocultos de todas las capas del codificador de visión (ViT).
  • vision_attentions (tuple[torch.FloatTensor], opcional) — Pesos de atención de las capas del codificador de visión (ViT).
  • detr_encoder_attentions (tuple[torch.FloatTensor], opcional) — Pesos de atención de las capas del codificador de DETR.
  • detr_decoder_attentions (tuple[torch.FloatTensor], opcional) — Pesos de atención de las capas decodificadoras de DETR (autoatención y atención cruzada).
  • mask_decoder_attentions (tuple[torch.FloatTensor], opcional) — Pesos de atención de las capas del decodificador de máscaras.

Ejemplo:

>>> 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

< >

( input_ids: LongTensorattention_mask: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.FloatTensor)

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 usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.

    ¿Qué son los IDs de entrada?

  • 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 máscara seleccionados en [0, 1]:
    • 1 para los tokens que no están enmascarados,
    • 0 para los tokens que están enmascarados.

    ¿Qué son las máscaras de atención?

Devuelve

BaseModelOutputWithPooling o tuple(torch.FloatTensor)

Un BaseModelOutputWithPooling o una tupla de torch.FloatTensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios elementos según la configuración (Sam3Config) y las entradas.

  • last_hidden_state (torch.FloatTensor de forma (batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo.

  • pooler_output (torch.FloatTensor 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.FloatTensor), opcional, se devuelve cuando se pasa output_hidden_states=True o cuando config.output_hidden_states=True) — Tupla de torch.FloatTensor (una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + 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.FloatTensor), opcional, se devuelve cuando se pasa output_attentions=True o cuando config.output_attentions=True) — Tupla de torch.FloatTensor (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:

>>> 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)
Update on GitHub

←Qwen3VLMoe SAM3 Video→