# SAM3-LiteText

## Visão geral

SAM3-LiteText foi proposto em [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 e Fan Zhang.

SAM3-LiteText é uma variante leve do [SAM3](sam3) que substitui o codificador de texto pesado do SAM3 (353M de parâmetros) por um codificador de texto compacto baseado em MobileCLIP, otimizado por meio de destilação de conhecimento. O codificador de imagem ViT-H do SAM3 é mantido intacto. Isso reduz os parâmetros do codificador de texto em até 88%, mantendo um desempenho de segmentação comparável ao do modelo original.

O resumo do artigo é o seguinte:

*Modelos de segmentação visão-linguagem, como o SAM3, permitem um enraizamento visual flexível e orientado por prompts, mas herdam codificadores de texto grandes e de uso geral, originalmente projetados para a compreensão de linguagem aberta. Na prática, os prompts de segmentação são curtos, estruturados e semanticamente restritos, o que leva a um superdimensionamento significativo na capacidade do codificador de texto e a um sobrecarga computacional e de memória persistente. Neste artigo, realizamos uma análise anatômica em larga escala do uso de prompts de texto na segmentação visão-linguagem, cobrindo 404.796 prompts reais em vários benchmarks. Nossa análise revela uma redundância severa: a maioria das janelas de contexto está subutilizada, o uso do vocabulário é altamente esparsa e os embeddings de texto estão em uma variedade de baixa dimensão, apesar das representações de alta dimensão. Motivados por essas descobertas, propomos o SAM3-LiteText, um framework leve de codificação de texto que substitui o codificador de texto original do SAM3 por um aluno MobileCLIP compacto, otimizado por destilação de conhecimento. Experimentos extensos em benchmarks de segmentação de imagem e vídeo mostram que o SAM3-LiteText reduz os parâmetros do codificador de texto em até 88%, reduzindo substancialmente a pegada de memória estática, enquanto mantém um desempenho de segmentação comparável ao do modelo original.*

A arquitetura do codificador de texto é baseada no [MobileCLIP](https://huggingface.co/papers/2311.17049) e vem em três variantes:

| Variante | Codificador de Texto | Parâmetros de Texto | Redução |
|---|---|---|---|
| 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 foi contribuído por [nielsr](https://huggingface.co/nielsr) e [yonigozlan](https://huggingface.co/yonigozlan). O código original pode ser encontrado [aqui](https://github.com/SimonZeng7108/efficientsam3/tree/sam3_litetext).

## Uso

SAM3-LiteText é uma substituição direta para o SAM3 com um codificador de texto leve. Ele usa o mesmo processador ([Sam3Processor](/docs/transformers/main/pt/model_doc/sam3#transformers.Sam3Processor)) e suporta a mesma interface de prompt. Consulte a [documentação do SAM3](sam3) para exemplos detalhados de uso, incluindo prompts de texto, prompts de caixa, inferência em lote e muito mais.

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_lite_text/configuration_sam3_lite_text.py#L143)

**Parâmetros:**

vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de visão.

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de texto.

geometry_encoder_config (`dict` ou `Sam3LiteTextGeometryEncoderConfig`, *opcional*) : Configuração para o codificador de geometria.

detr_encoder_config (`dict` ou `Sam3LiteTextDETREncoderConfig`, *opcional*) : Configuração para o codificador DETR.

detr_decoder_config (`dict` ou `Sam3LiteTextDETRDecoderConfig`, *opcional*) : Configuração para o decodificador DETR.

mask_decoder_config (`dict` ou `Sam3LiteTextMaskDecoderConfig`, *opcional*) : Configuração para o decodificador de máscaras.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

Esta é a classe de configuração para armazenar a configuração de um Sam3LiteTextModel. Ela é usada para instanciar um modelo Sam3 Lite Text de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [yonigozlan/sam3-litetext-s0](https://huggingface.co/yonigozlan/sam3-litetext-s0)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

Exemplo:
```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)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_lite_text/configuration_sam3_lite_text.py#L113)

**Parâmetros:**

vocab_size (`int`, *opcional*, padrão `49408`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`.

hidden_size (`int`, *opcional*, padrão `512`) : Dimensão das representações ocultas.

intermediate_size (`int`, *opcional*, padrão `2048`) : Dimensão das representações do MLP.

projection_dim (`int`, *opcional*, padrão `512`) : Dimensionalidade das camadas de projeção de texto e visão.

num_hidden_layers (`int`, *opcional*, padrão `12`) : Número de camadas ocultas no decodificador do Transformer.

num_attention_heads (`int`, *opcional*, padrão `8`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

max_position_embeddings (`int`, *opcional*, padrão `77`) : O comprimento máximo de sequência com o qual este modelo pode ser usado.

hidden_act (`str`, *opcional*, padrão `gelu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

layer_norm_eps (`float`, *opcional*, padrão `1e-05`) : O epsilon usado pelas camadas de normalização de camada.

attention_dropout (`float`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção.

use_repmixer_blocks (`bool`, *opcional*, padrão `True`) : Se deve usar blocos RepMixer (estilo MobileCLIP) para as primeiras e últimas camadas do codificador. Quando `False`, todas as camadas são camadas padrão de codificador Transformer.

layer_scale_init_value (`float`, *opcional*, padrão `1e-5`) : Valor inicial para os parâmetros de layer-scale aprendíveis nos blocos RepMixer (ramos residuais).

repmixer_kernel_size (`int`, *opcional*, padrão `11`) : Tamanho do kernel para convoluções depthwise nos blocos RepMixer (caminho do misturador de tokens e do feed-forward convolucional).

Esta é a classe de configuração para armazenar a configuração de um Sam3LiteTextModel. Ela é usada para instanciar um modelo Sam3 Lite Text de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [yonigozlan/sam3-litetext-s0](https://huggingface.co/yonigozlan/sam3-litetext-s0)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_lite_text/configuration_sam3_lite_text.py#L30)

**Parâmetros:**

hidden_size (`int`, *opcional*, padrão `256`) : Dimensão das representações ocultas.

num_layers (`int`, *opcional*, padrão `3`) : Número de camadas ocultas no decodificador do Transformer.

num_attention_heads (`int`, *opcional*, padrão `8`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

intermediate_size (`int`, *opcional*, padrão `2048`) : Dimensão das representações do MLP.

dropout (`Union[float, int]`, *opcional*, padrão `0.1`) : A proporção para todas as camadas de dropout.

hidden_act (`str`, *opcional*, padrão `relu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

hidden_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no encoder e no pooler.

layer_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização de camada.

roi_size (`int`, *opcional*, padrão 7) : Tamanho da ROI para operações de box pooling.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

Esta é a classe de configuração para armazenar a configuração de um Sam3LiteTextModel. Ela é usada para instanciar um modelo Sam3 Lite Text de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [yonigozlan/sam3-litetext-s0](https://huggingface.co/yonigozlan/sam3-litetext-s0)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_lite_text/configuration_sam3_lite_text.py#L52)

**Parâmetros:**

hidden_size (`int`, *opcional*, padrão `256`) : Dimensão das representações ocultas.

num_layers (`int`, *opcional*, padrão `6`) : Número de camadas ocultas no decodificador do Transformer.

num_attention_heads (`int`, *opcional*, padrão `8`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

intermediate_size (`int`, *opcional*, padrão `2048`) : Dimensão das representações do MLP.

dropout (`Union[float, int]`, *opcional*, padrão `0.1`) : A proporção para todas as camadas de dropout.

hidden_act (`str`, *opcional*, padrão `relu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

hidden_dropout (`float`, *opcional*, padrão 0.0) : Probabilidade de dropout para os estados ocultos.

layer_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização de camada.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

Esta é a classe de configuração para armazenar a configuração de um Sam3LiteTextModel. Ela é usada para instanciar um modelo Sam3 Lite Text de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [yonigozlan/sam3-litetext-s0](https://huggingface.co/yonigozlan/sam3-litetext-s0)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_lite_text/configuration_sam3_lite_text.py#L73)

**Parâmetros:**

hidden_size (`int`, *opcional*, padrão `256`) : Dimensão das representações ocultas.

num_layers (`int`, *opcional*, padrão `6`) : Número de camadas ocultas no decodificador do Transformer.

num_queries (`int`, *opcional*, padrão 200) : Número de consultas de objeto.

num_attention_heads (`int`, *opcional*, padrão `8`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

intermediate_size (`int`, *opcional*, padrão `2048`) : Dimensão das representações do MLP.

dropout (`Union[float, int]`, *opcional*, padrão `0.1`) : A proporção para todas as camadas de dropout.

hidden_act (`str`, *opcional*, padrão `relu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

hidden_dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no encoder e no pooler.

layer_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização de camada.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

Esta é a classe de configuração para armazenar a configuração de um Sam3LiteTextModel. Ela é usada para instanciar um modelo Sam3 Lite Text de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [yonigozlan/sam3-litetext-s0](https://huggingface.co/yonigozlan/sam3-litetext-s0)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

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

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/sam3_lite_text/configuration_sam3_lite_text.py#L95)

**Parâmetros:**

hidden_size (`int`, *opcional*, padrão `256`) : Dimensão das representações ocultas.

num_upsampling_stages (`int`, *opcional*, padrão 3) : Número de estágios de aumento de amostragem no decodificador de pixels (FPN).

layer_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização de camada.

dropout (`Union[float, int]`, *opcional*, padrão `0.0`) : A proporção para todas as camadas de dropout.

num_attention_heads (`int`, *opcional*, padrão `8`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.

Esta é a classe de configuração para armazenar a configuração de um Sam3LiteTextModel. Ela é usada para instanciar um modelo Sam3 Lite Text de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [yonigozlan/sam3-litetext-s0](https://huggingface.co/yonigozlan/sam3-litetext-s0)

Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações.

## Sam3LiteTextTextModel[[transformers.Sam3LiteTextTextModel]]

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

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

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

**Parâmetros:**

config ([Sam3LiteTextTextConfig](/docs/transformers/main/pt/model_doc/sam3_lite_text#transformers.Sam3LiteTextTextConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. Inicializar com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

Codificador de texto MobileCLIP MCT usado no EfficientSAM3 LiteText.

Quando `config.use_repmixer_blocks` é `True`, as primeiras e últimas camadas são módulos `Sam3LiteTextRepMixerBlock`; as demais são camadas padrão `Sam3LiteTextTextEncoderLayer`.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

#### 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'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/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 dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

**Retorna:** `Sam3LiteTextTextEncoderOutput` ou `tuple(torch.Tensor)`

Uma `Sam3LiteTextTextEncoderOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([Sam3LiteTextConfig](/docs/transformers/main/pt/model_doc/sam3_lite_text#transformers.Sam3LiteTextConfig)) e das entradas.

O método forward do [Sam3LiteTextTextModel](/docs/transformers/main/pt/model_doc/sam3_lite_text#transformers.Sam3LiteTextTextModel) sobrescreve o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência completa de estados ocultos do codificador de texto.
- **pooler_output** (`torch.Tensor` de forma `(batch_size, projection_dim)`) -- Saída com pooling EOT projetada para `projection_dim` por meio da projeção interna estilo CLIP.
- **hidden_states** (`tuple(torch.Tensor)`, *opcional*) -- Tupla de estados ocultos em cada camada, retornada quando `output_hidden_states=True`.
- **attentions** (`tuple(torch.Tensor)`, *opcional*) -- Tupla de pesos de atenção em cada camada do transformer, retornada quando `output_attentions=True`.

## Sam3LiteTextModel[[transformers.Sam3LiteTextModel]]

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

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

[Origem](https://github.com/huggingface/transformers/blob/main/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'>)
```

[Origem](https://github.com/huggingface/transformers/blob/main/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*) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [Sam3ImageProcessor](/docs/transformers/main/pt/model_doc/sam3#transformers.Sam3ImageProcessor). Veja [Sam3ImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([Sam3Processor](/docs/transformers/main/pt/model_doc/sam3#transformers.Sam3Processor) usa [Sam3ImageProcessor](/docs/transformers/main/pt/model_doc/sam3#transformers.Sam3ImageProcessor) para processar imagens).

vision_embeds (`Sam3LiteTextVisionEncoderOutput`, *opcional*) : Incorporações de visão pré-computadas. Pode ser usado para reutilizar facilmente incorporações de visão. Se fornecido, `pixel_values` não deve ser passado. Mutuamente exclusivo com `pixel_values`.

input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`:  - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**.  [O que são máscaras de atenção?](../glossary#attention-mask)

text_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Incorporações de texto pré-computadas. Pode ser usado para reutilizar facilmente incorporações de texto. Se fornecido, `input_ids` não deve ser passado. Mutuamente exclusivo com `input_ids`.

input_boxes (`torch.Tensor` de forma `(batch_size, num_boxes, 4)`, *opcional*) : Coordenadas de caixa normalizadas no intervalo [0, 1], no formato (cx, cy, w, h).

input_boxes_labels (`torch.LongTensor` de forma `(batch_size, num_boxes)`, *opcional*) : Rótulos para as caixas: 1 (positivo), 0 (negativo).

**Retorna:** `Sam3LiteTextImageSegmentationOutput` ou `tuple(torch.Tensor)`

Um `Sam3LiteTextImageSegmentationOutput` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([Sam3LiteTextConfig](/docs/transformers/main/pt/model_doc/sam3_lite_text#transformers.Sam3LiteTextConfig)) e das entradas.

O método forward do [Sam3LiteTextModel](/docs/transformers/main/pt/model_doc/sam3_lite_text#transformers.Sam3LiteTextModel) substitui o método especial `__call__`.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

- **pred_masks** (`torch.Tensor` de forma `(batch_size, num_queries, height, width)`) -- Máscaras de segmentação previstas para cada query.
- **pred_boxes** (`torch.Tensor` de forma `(batch_size, num_queries, 4)`) -- Caixas delimitadoras previstas no formato (x1, y1, x2, y2).
- **pred_logits** (`torch.Tensor` de forma `(batch_size, num_queries)`, *opcional*) -- Pontuações de confiança de classificação para cada consulta, calculadas por meio do produto escalar entre os recursos de consulta do decodificador e os recursos de texto.
- **presence_logits** (`torch.Tensor` de forma `(batch_size, 1)`, *opcional*) -- Logits de presença do token de presença do decodificador DETR (apenas a última camada). Esses valores indicam se há objetos presentes na cena. Podem ser usados para calcular as pontuações finais multiplicando-os por pred_logits: `final_scores = pred_logits.sigmoid() * presence_logits.sigmoid()`.
- **semantic_seg** (`torch.Tensor` de forma `(batch_size, 1, height, width)`, *opcional*) -- Saída de segmentação semântica.
- **decoder_hidden_states** (`tuple[torch.Tensor]`, *opcional*) -- Tupla de estados ocultos de todas as camadas do decodificador DETR. Cada tensor tem a forma `(batch_size, num_queries, hidden_size)`.
- **decoder_reference_boxes** (`torch.Tensor` de forma `(num_layers, batch_size, num_queries, 4)`, *opcional*) -- Caixas de referência de todas as camadas do decodificador DETR.
- **encoder_hidden_states** (`tuple[torch.Tensor]`, *opcional*) -- Tupla de estados ocultos de todas as camadas do codificador DETR.
- **vision_hidden_states** (`tuple[torch.Tensor]`, *opcional*) -- Tupla de estados ocultos de todas as camadas do codificador de visão (ViT).
- **vision_attentions** (`tuple[torch.Tensor]`, *opcional*) -- Pesos de atenção das camadas do codificador de visão (ViT).
- **detr_encoder_attentions** (`tuple[torch.Tensor]`, *opcional*) -- Pesos de atenção das camadas do codificador DETR.
- **detr_decoder_attentions** (`tuple[torch.Tensor]`, *opcional*) -- Pesos de atenção das camadas do decodificador do DETR (autoatenção e atenção cruzada).
- **mask_decoder_attentions** (`tuple[torch.Tensor]`, *opcional*) -- Pesos de atenção das camadas do decodificador de máscara.

Exemplo:

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

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

**Parâmetros:**

config ([PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo.

Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.).

Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais.

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

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

Um valor simulado para um caminho pontilhado (por exemplo, `torch.float32`): as cadeias de acesso a atributos e as chamadas se comportam como decoradores de passagem, o `repr` é o caminho pontilhado, e o uso como classe base substitui uma base de `type` simples (PEP 560 `__mro_entries__`), de modo que as subclasses reais mantêm um metaclass normal e o `inspect.signature` lê o `__init__` real delas, em vez do de um mock.