# SAM3-LiteText

## Resumen

SAM3-LiteText fue propuesto en [SAM3-LiteText: An Anatomical Study of the SAM3 Text Encoder for Efficient Vision-Language Segmentation](https://huggingface.co/papers/2602.12173) por Chengxi Zeng, Yuxuan Jiang, Ge Gao, Shuai Wang, Duolikun Danier, Bin Zhu, Stevan Rudinac, David Bull y Fan Zhang.

SAM3-LiteText es una variante ligera de [SAM3](sam3) que reemplaza el codificador de texto pesado de SAM3 (353M de parámetros) por un codificador de texto compacto basado en MobileCLIP, optimizado mediante destilación de conocimiento. El codificador de imágenes ViT-H de SAM3 se mantiene intacto. Esto reduce los parámetros del codificador de texto hasta en un 88%, manteniendo un rendimiento de segmentación comparable al del modelo original.

El resumen del artículo es el siguiente:

*Los modelos de segmentación visuales-lingüísticos, como SAM3, permiten un anclaje visual flexible y dirigido por indicaciones, pero heredan codificadores de texto grandes y de propósito general diseñados originalmente para la comprensión lingüística abierta. En la práctica, las indicaciones de segmentación son cortas, estructuradas y semánticamente restringidas, lo que provoca una sobredimensionación sustancial de la capacidad del codificador de texto y un sobrecoste computacional y de memoria persistente. En este artículo, realizamos un análisis anatómico a gran escala de las indicaciones de texto en la segmentación visual-lingüística, cubriendo 404.796 indicaciones reales en varios conjuntos de evaluación. Nuestro análisis revela una redundancia severa: la mayoría de las ventanas de contexto están subutilizadas, el uso del vocabulario es altamente disperso y los incrustados de texto se encuentran en una variedad de baja dimensión, a pesar de las representaciones de alta dimensión. Motivados por estos hallazgos, proponemos SAM3-LiteText, un marco ligero de codificación de texto que reemplaza el codificador de texto original de SAM3 con un estudiante MobileCLIP compacto optimizado mediante destilación de conocimiento. Experimentos extensos en conjuntos de evaluación de segmentación de imágenes y videos muestran que SAM3-LiteText reduce los parámetros del codificador de texto hasta en un 88%, reduciendo sustancialmente la huella de memoria estática, mientras mantiene un rendimiento de segmentación comparable al del modelo original.*

La arquitectura del codificador de texto se basa en [MobileCLIP](https://huggingface.co/papers/2311.17049) y viene en tres variantes:

| Variante | Codificador de texto | Parámetros de texto | Reducción |
|---|---|---|---|
| SAM3-LiteText-S0-16 | MobileCLIP-S0 | 42.54M | ~88% |
| SAM3-LiteText-S1-16 | MobileCLIP-S1 | 63.53M | ~82% |
| SAM3-LiteText-L-16 | MobileCLIP2-L | 123.80M | ~65% |

Este modelo fue aportado por [nielsr](https://huggingface.co/nielsr) y [yonigozlan](https://huggingface.co/yonigozlan). El código original se puede encontrar [aquí](https://github.com/SimonZeng7108/efficientsam3/tree/sam3_litetext).

## Uso

SAM3-LiteText es un reemplazo directo para SAM3 con un codificador de texto ligero. Utiliza el mismo procesador ([Sam3Processor](/docs/transformers/v5.23.0/es/model_doc/sam3#transformers.Sam3Processor)) y admite la misma interfaz de indicaciones. Consulte la [documentación de SAM3](sam3) para ejemplos detallados de uso, incluidos prompts de texto, prompts de caja, inferencia por lotes y más.

```python
from io import BytesIO

from huggingface_hub.utils import httpx
from PIL import Image

from transformers import AutoModel, AutoProcessor

model = AutoModel.from_pretrained("yonigozlan/sam3-litetext-s0", device_map="auto")
processor = AutoProcessor.from_pretrained("yonigozlan/sam3-litetext-s0")

image_url = "http://images.cocodataset.org/val2017/000000077595.jpg"
image = Image.open(BytesIO(httpx.get(image_url).content)).convert("RGB")

inputs = processor(images=image, text="ear", return_tensors="pt").to(model.device)

outputs = model(**inputs)

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")
```

## Sam3LiteTextConfig[[transformers.Sam3LiteTextConfig]]

#### transformers.Sam3LiteTextConfig[[transformers.Sam3LiteTextConfig]]

```python
transformers.Sam3LiteTextConfig(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/v5.23.0/src/transformers/models/sam3_lite_text/configuration_sam3_lite_text.py#L145)

**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 `Sam3LiteTextGeometryEncoderConfig`, *opcional*) : Configuración del codificador de geometría.

detr_encoder_config (`dict` o `Sam3LiteTextDETREncoderConfig`, *opcional*) : Configuración del codificador DETR.

detr_decoder_config (`dict` o `Sam3LiteTextDETRDecoderConfig`, *opcional*) : Configuración del decodificador DETR.

mask_decoder_config (`dict` o `Sam3LiteTextMaskDecoderConfig`, *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 Sam3LiteTextModel. Se utiliza para instanciar un modelo Sam3 Lite Text 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 [yonigozlan/sam3-litetext-s0](https://huggingface.co/yonigozlan/sam3-litetext-s0)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

Ejemplo:
```python
>>> from transformers import Sam3LiteTextConfig, Sam3LiteTextModel

>>> # Initializing a SAM3_LITE_TEXT configuration
>>> configuration = Sam3LiteTextConfig()

>>> # Initializing a model from the configuration
>>> model = Sam3LiteTextModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## Sam3LiteTextTextConfig[[transformers.Sam3LiteTextTextConfig]]

#### transformers.Sam3LiteTextTextConfig[[transformers.Sam3LiteTextTextConfig]]

```python
transformers.Sam3LiteTextTextConfig(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, vocab_size: int = 49408, hidden_size: int = 512, intermediate_size: int = 2048, projection_dim: int = 512, num_hidden_layers: int = 12, num_attention_heads: int = 8, max_position_embeddings: int = 77, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-05, attention_dropout: float = 0.0, use_repmixer_blocks: bool = True, layer_scale_init_value: float = 1e-05, repmixer_kernel_size: int = 11)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_lite_text/configuration_sam3_lite_text.py#L115)

**Parámetros:**

vocab_size (`int`, *opcional*, valor predeterminado `49408`) : Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante `input_ids`.

hidden_size (`int`, *opcional*, valor predeterminado `512`) : Dimensión de las representaciones ocultas.

intermediate_size (`int`, *opcional*, valor predeterminado `2048`) : Dimensión de las representaciones MLP.

projection_dim (`int`, *opcional*, valor predeterminado `512`) : Dimensionalidad de las capas de proyección de texto y visión.

num_hidden_layers (`int`, *opcional*, valor predeterminado `12`) : 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.

max_position_embeddings (`int`, *opcional*, valor predeterminado `77`) : La longitud máxima de secuencia con la que se podría utilizar este modelo.

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-05`) : El epsilon utilizado por las capas de normalización de capas.

attention_dropout (`float`, *opcional*, valor predeterminado `0.0`) : La proporción de dropout para las probabilidades de atención.

use_repmixer_blocks (`bool`, *opcional*, valor predeterminado `True`) : Si se deben usar bloques RepMixer (estilo MobileCLIP) para las capas de codificador inicial y final. Cuando es `False`, todas las capas son capas de codificador Transformer estándar.

layer_scale_init_value (`float`, *opcional*, valor predeterminado `1e-5`) : Valor inicial para los parámetros de layer-scale aprendibles en los bloques RepMixer (ramas residuales).

repmixer_kernel_size (`int`, *opcional*, valor predeterminado `11`) : Tamaño del kernel para las convoluciones depthwise en los bloques RepMixer (ruta de mezcla de tokens y ruta de feed-forward convolucional).

Esta es la clase de configuración para almacenar la configuración de un Sam3LiteTextModel. Se utiliza para instanciar un modelo Sam3 Lite Text 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 [yonigozlan/sam3-litetext-s0](https://huggingface.co/yonigozlan/sam3-litetext-s0)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

## Sam3LiteTextGeometryEncoderConfig[[transformers.Sam3LiteTextGeometryEncoderConfig]]

#### transformers.Sam3LiteTextGeometryEncoderConfig[[transformers.Sam3LiteTextGeometryEncoderConfig]]

```python
transformers.Sam3LiteTextGeometryEncoderConfig(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/v5.23.0/src/transformers/models/sam3_lite_text/configuration_sam3_lite_text.py#L30)

**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 Sam3LiteTextModel. Se utiliza para instanciar un modelo Sam3 Lite Text 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 [yonigozlan/sam3-litetext-s0](https://huggingface.co/yonigozlan/sam3-litetext-s0)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

## Sam3LiteTextDETREncoderConfig[[transformers.Sam3LiteTextDETREncoderConfig]]

#### transformers.Sam3LiteTextDETREncoderConfig[[transformers.Sam3LiteTextDETREncoderConfig]]

```python
transformers.Sam3LiteTextDETREncoderConfig(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/v5.23.0/src/transformers/models/sam3_lite_text/configuration_sam3_lite_text.py#L52)

**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 Sam3LiteTextModel. Se utiliza para instanciar un modelo Sam3 Lite Text 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 [yonigozlan/sam3-litetext-s0](https://huggingface.co/yonigozlan/sam3-litetext-s0)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

## Sam3LiteTextDETRDecoderConfig[[transformers.Sam3LiteTextDETRDecoderConfig]]

#### transformers.Sam3LiteTextDETRDecoderConfig[[transformers.Sam3LiteTextDETRDecoderConfig]]

```python
transformers.Sam3LiteTextDETRDecoderConfig(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/v5.23.0/src/transformers/models/sam3_lite_text/configuration_sam3_lite_text.py#L74)

**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 Sam3LiteTextModel. Se utiliza para instanciar un modelo Sam3 Lite Text 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 [yonigozlan/sam3-litetext-s0](https://huggingface.co/yonigozlan/sam3-litetext-s0)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

## Sam3LiteTextMaskDecoderConfig[[transformers.Sam3LiteTextMaskDecoderConfig]]

#### transformers.Sam3LiteTextMaskDecoderConfig[[transformers.Sam3LiteTextMaskDecoderConfig]]

```python
transformers.Sam3LiteTextMaskDecoderConfig(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/v5.23.0/src/transformers/models/sam3_lite_text/configuration_sam3_lite_text.py#L97)

**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 Sam3LiteTextModel. Se utiliza para instanciar un modelo Sam3 Lite Text 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 [yonigozlan/sam3-litetext-s0](https://huggingface.co/yonigozlan/sam3-litetext-s0)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

## Sam3LiteTextTextModel[[transformers.Sam3LiteTextTextModel]]

#### transformers.Sam3LiteTextTextModel[[transformers.Sam3LiteTextTextModel]]

```python
transformers.Sam3LiteTextTextModel(config: Sam3LiteTextTextConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_lite_text/modeling_sam3_lite_text.py#L371)

**Parámetros:**

config ([Sam3LiteTextTextConfig](/docs/transformers/v5.23.0/es/model_doc/sam3_lite_text#transformers.Sam3LiteTextTextConfig)) : 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/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

Codificador de texto MobileCLIP MCT utilizado en EfficientSAM3 LiteText.

Cuando `config.use_repmixer_blocks` es `True`, las capas primera y última son módulos `Sam3LiteTextRepMixerBlock`; el resto son capas estándar `Sam3LiteTextTextEncoderLayer`.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/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.Sam3LiteTextTextModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_lite_text/modeling_sam3_lite_text.py#L393)

**Parámetros:**

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/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/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:** `Sam3LiteTextTextEncoderOutput` o `tuple(torch.Tensor)`

Un `Sam3LiteTextTextEncoderOutput` 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 ([Sam3LiteTextConfig](/docs/transformers/v5.23.0/es/model_doc/sam3_lite_text#transformers.Sam3LiteTextConfig)) y las entradas.

El método forward de [Sam3LiteTextTextModel](/docs/transformers/v5.23.0/es/model_doc/sam3_lite_text#transformers.Sam3LiteTextTextModel) 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 completa de estados ocultos del codificador de texto.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, projection_dim)`) -- Salida agrupada por EOT proyectada a `projection_dim` mediante la proyección interna de estilo CLIP.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*) -- Tupla de estados ocultos en cada capa, devuelta cuando `output_hidden_states=True`.
- **attentions** (`tuple(torch.Tensor)`, *opcional*) -- Tupla de pesos de atención en cada capa del transformador, devuelta cuando `output_attentions=True`.

## Sam3LiteTextModel[[transformers.Sam3LiteTextModel]]

#### transformers.Sam3LiteTextModel[[transformers.Sam3LiteTextModel]]

```python
transformers.Sam3LiteTextModel(config: Sam3LiteTextConfig)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_lite_text/modeling_sam3_lite_text.py#L1922)

#### forward[[transformers.Sam3LiteTextModel.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, vision_embeds: transformers.models.sam3_lite_text.modeling_sam3_lite_text.Sam3LiteTextVisionEncoderOutput | 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: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_lite_text/modeling_sam3_lite_text.py#L2038)

**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/v5.23.0/es/model_doc/sam3#transformers.Sam3ImageProcessor). Consulte [Sam3ImageProcessor.__call__()](/docs/transformers/v5.23.0/es/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para más detalles ([Sam3Processor](/docs/transformers/v5.23.0/es/model_doc/sam3#transformers.Sam3Processor) utiliza [Sam3ImageProcessor](/docs/transformers/v5.23.0/es/model_doc/sam3#transformers.Sam3ImageProcessor) para procesar las imágenes).

vision_embeds (`Sam3LiteTextVisionEncoderOutput`, *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/v5.23.0/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/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:** `Sam3LiteTextImageSegmentationOutput` o `tuple(torch.Tensor)`

Un `Sam3LiteTextImageSegmentationOutput` 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 ([Sam3LiteTextConfig](/docs/transformers/v5.23.0/es/model_doc/sam3_lite_text#transformers.Sam3LiteTextConfig)) y las entradas.

El método forward de [Sam3LiteTextModel](/docs/transformers/v5.23.0/es/model_doc/sam3_lite_text#transformers.Sam3LiteTextModel) sobrescribe 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_lite_text")
>>> processor = AutoProcessor.from_pretrained("facebook/sam3_lite_text")

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

## Sam3LiteTextPreTrainedModel[[transformers.Sam3LiteTextPreTrainedModel]]

#### transformers.Sam3LiteTextPreTrainedModel[[transformers.Sam3LiteTextPreTrainedModel]]

```python
transformers.Sam3LiteTextPreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs)
```

[Fuente](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/sam3_lite_text/modeling_sam3_lite_text.py#L343)

**Parámetros:**

config ([PreTrainedConfig](/docs/transformers/v5.23.0/es/main_classes/configuration#transformers.PreTrainedConfig)) : 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/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

Este modelo hereda de [PreTrainedModel](/docs/transformers/v5.23.0/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.Sam3LiteTextPreTrainedModel.forward]]

```python
forward(*args, **kwargs)
```

Un valor simulado para una ruta con puntos (p. ej., `torch.float32`): las cadenas de acceso a atributos y las llamadas se comportan como decoradores de paso, `repr` es la ruta con puntos, y su uso como clase base sustituye una base de `type` simple (PEP 560 `__mro_entries__`), de modo que las subclases reales conservan un metaclass normal y `inspect.signature` lee su `__init__` real en lugar del de un simulacro.