# SAM3-LiteText

## Aperçu

SAM3-LiteText a été proposé dans [SAM3-LiteText: An Anatomical Study of the SAM3 Text Encoder for Efficient Vision-Language Segmentation](https://huggingface.co/papers/2602.12173) par Chengxi Zeng, Yuxuan Jiang, Ge Gao, Shuai Wang, Duolikun Danier, Bin Zhu, Stevan Rudinac, David Bull et Fan Zhang.

SAM3-LiteText est une variante allégée de [SAM3](sam3) qui remplace l’encodeur de texte lourd de SAM3 (353 M de paramètres) par un encodeur de texte compact basé sur MobileCLIP, optimisé par distillation de connaissances. L’encodeur d’images ViT-H de SAM3 est conservé tel quel. Cette approche réduit le nombre de paramètres de l’encodeur de texte de jusqu’à 88 % tout en maintenant des performances de segmentation comparables à celles du modèle d’origine.

L'abstract de l'article est le suivant :

*Les modèles de segmentation vision-langage tels que SAM3 permettent un ancrage visuel flexible et piloté par des invites, mais ils héritent de grands encodeurs de texte généralistes initialement conçus pour la compréhension du langage ouvert. En pratique, les invites de segmentation sont courtes, structurées et sémantiquement contraintes, ce qui entraîne un surdimensionnement important de la capacité de l'encodeur de texte ainsi qu'un surcoût computationnel et mémoire persistant. Dans cet article, nous réalisons une analyse anatomique à grande échelle du promptage textuel dans la segmentation vision-langage, couvrant 404 796 invites réelles sur plusieurs benchmarks. Notre analyse révèle une redondance sévère : la plupart des fenêtres de contexte sont sous-exploitées, l'utilisation du vocabulaire est très creuse et les embeddings de texte se situent sur une variété de faible dimension malgré des représentations de haute dimension. Motivés par ces constats, nous proposons SAM3-LiteText, un cadre d'encodage textuel léger qui remplace l'encodeur de texte original de SAM3 par un élève MobileCLIP compact optimisé par distillation de connaissances. Des expériences exhaustives sur des benchmarks de segmentation d'images et de vidéos montrent que SAM3-LiteText réduit le nombre de paramètres de l'encodeur de texte de jusqu'à 88 %, réduisant considérablement l'empreinte mémoire statique, tout en maintenant des performances de segmentation comparables à celles du modèle original.*

L'architecture de l'encodeur de texte est basée sur [MobileCLIP](https://huggingface.co/papers/2311.17049) et existe en trois variantes :

| Variante | Encodeur de texte | Paramètres du texte | Réduction |
|---|---|---|---|
| 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% |

Ce modèle a été contribué par [nielsr](https://huggingface.co/nielsr) et [yonigozlan](https://huggingface.co/yonigozlan). Le code d'origine peut être trouvé [ici](https://github.com/SimonZeng7108/efficientsam3/tree/sam3_litetext).

## Utilisation

SAM3-LiteText est un substitut direct de SAM3 doté d'un encodeur de texte léger. Il utilise le même processeur ([Sam3Processor](/docs/transformers/v5.23.0/fr/model_doc/sam3#transformers.Sam3Processor)) et prend en charge la même interface de sollicitation. Consultez la [documentation de SAM3](sam3) pour des exemples d'utilisation détaillés, notamment les sollicitations par texte, les sollicitations par boîte, l'inférence par lots, et plus encore.

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

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

**Paramètres :**

vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone visuel.

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone de texte.

geometry_encoder_config (`dict` ou `Sam3LiteTextGeometryEncoderConfig`, *facultatif*) : Configuration de l'encodeur de géométrie.

detr_encoder_config (`dict` ou `Sam3LiteTextDETREncoderConfig`, *facultatif*) : Configuration de l'encodeur DETR.

detr_decoder_config (`dict` ou `Sam3LiteTextDETRDecoderConfig`, *facultatif*) : Configuration du décodeur DETR.

mask_decoder_config (`dict` ou `Sam3LiteTextMaskDecoderConfig`, *facultatif*) : Configuration du décodeur de masque.

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un Sam3LiteTextModel. Elle est utilisée pour instancier un modèle Sam3 Lite Text en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [yonigozlan/sam3-litetext-s0](https://huggingface.co/yonigozlan/sam3-litetext-s0)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

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

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

**Paramètres :**

vocab_size (`int`, *facultatif*, valeur par défaut `49408`) : Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par `input_ids`.

hidden_size (`int`, *facultatif*, par défaut `512`) : Dimension des représentations cachées.

intermediate_size (`int`, *facultatif*, valeur par défaut `2048`) : Dimension des représentations MLP.

projection_dim (`int`, *facultatif*, valeur par défaut `512`) : Dimension des couches de projection du texte et de la vision.

num_hidden_layers (`int`, *facultatif*, par défaut `12`) : Nombre de couches cachées dans le décodeur Transformer.

num_attention_heads (`int`, *facultatif*, valeur par défaut `8`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

max_position_embeddings (`int`, *facultatif*, valeur par défaut `77`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.

hidden_act (`str`, *facultatif*, par défaut `gelu`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

layer_norm_eps (`float`, *facultatif*, valeur par défaut `1e-05`) : L'épsilon utilisé par les couches de normalisation de couche.

attention_dropout (`float`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention.

use_repmixer_blocks (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut utiliser des blocs RepMixer (de type MobileCLIP) pour les premières et dernières couches de l'encodeur. Si la valeur est `False`, toutes les couches sont des couches d'encodeur Transformer standard.

layer_scale_init_value (`float`, *facultatif*, valeur par défaut `1e-5`) : Valeur initiale des paramètres d'échelle de couche apprenables dans les blocs RepMixer (branches résiduelles).

repmixer_kernel_size (`int`, *facultatif*, valeur par défaut `11`) : Taille du noyau pour les convolutions en profondeur dans les blocs RepMixer (chemin de mélange de jetons et chemin de réseau de propagation avant convolutif).

Il s'agit de la classe de configuration destinée à stocker la configuration d'un Sam3LiteTextModel. Elle est utilisée pour instancier un modèle Sam3 Lite Text en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [yonigozlan/sam3-litetext-s0](https://huggingface.co/yonigozlan/sam3-litetext-s0)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

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

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

**Paramètres :**

hidden_size (`int`, *facultatif*, par défaut `256`) : Dimension des représentations cachées.

num_layers (`int`, *facultatif*, valeur par défaut `3`) : Nombre de couches cachées dans le décodeur Transformer.

num_attention_heads (`int`, *facultatif*, valeur par défaut `8`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

intermediate_size (`int`, *facultatif*, valeur par défaut `2048`) : Dimension des représentations MLP.

dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Le ratio pour toutes les couches de dropout.

hidden_act (`str`, *facultatif*, par défaut `relu`) : Fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

hidden_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : La probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l'encodeur et du pooler.

layer_norm_eps (`float`, *facultatif*, par défaut `1e-06`) : L'épsilon utilisé par les couches de normalisation par couche.

roi_size (`int`, *facultatif*, valeur par défaut : 7) : taille de la ROI pour les opérations de box pooling.

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un Sam3LiteTextModel. Elle est utilisée pour instancier un modèle Sam3 Lite Text en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [yonigozlan/sam3-litetext-s0](https://huggingface.co/yonigozlan/sam3-litetext-s0)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

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

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

**Paramètres :**

hidden_size (`int`, *facultatif*, par défaut `256`) : Dimension des représentations cachées.

num_layers (`int`, *facultatif*, valeur par défaut `6`) : Nombre de couches cachées dans le décodeur Transformer.

num_attention_heads (`int`, *facultatif*, valeur par défaut `8`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

intermediate_size (`int`, *facultatif*, valeur par défaut `2048`) : Dimension des représentations MLP.

dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Le ratio pour toutes les couches de dropout.

hidden_act (`str`, *facultatif*, par défaut `relu`) : Fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

hidden_dropout (`float`, *facultatif*, valeur par défaut 0.0) : Probabilité de dropout pour les états cachés.

layer_norm_eps (`float`, *facultatif*, par défaut `1e-06`) : L'épsilon utilisé par les couches de normalisation par couche.

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un Sam3LiteTextModel. Elle est utilisée pour instancier un modèle Sam3 Lite Text en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [yonigozlan/sam3-litetext-s0](https://huggingface.co/yonigozlan/sam3-litetext-s0)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

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

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

**Paramètres :**

hidden_size (`int`, *facultatif*, par défaut `256`) : Dimension des représentations cachées.

num_layers (`int`, *facultatif*, valeur par défaut `6`) : Nombre de couches cachées dans le décodeur Transformer.

num_queries (`int`, *facultatif*, valeur par défaut 200) : Nombre de requêtes d'objets.

num_attention_heads (`int`, *facultatif*, valeur par défaut `8`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

intermediate_size (`int`, *facultatif*, valeur par défaut `2048`) : Dimension des représentations MLP.

dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Le ratio pour toutes les couches de dropout.

hidden_act (`str`, *facultatif*, par défaut `relu`) : Fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc.

hidden_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : La probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l'encodeur et du pooler.

layer_norm_eps (`float`, *facultatif*, par défaut `1e-06`) : L'épsilon utilisé par les couches de normalisation par couche.

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un Sam3LiteTextModel. Elle est utilisée pour instancier un modèle Sam3 Lite Text en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [yonigozlan/sam3-litetext-s0](https://huggingface.co/yonigozlan/sam3-litetext-s0)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

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

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

**Paramètres :**

hidden_size (`int`, *facultatif*, par défaut `256`) : Dimension des représentations cachées.

num_upsampling_stages (`int`, *facultatif*, valeur par défaut : 3) : Nombre d'étapes de suréchantillonnage dans le décodeur de pixels (FPN).

layer_norm_eps (`float`, *facultatif*, par défaut `1e-06`) : L'épsilon utilisé par les couches de normalisation par couche.

dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le ratio pour toutes les couches de dropout.

num_attention_heads (`int`, *facultatif*, valeur par défaut `8`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids.

Il s'agit de la classe de configuration destinée à stocker la configuration d'un Sam3LiteTextModel. Elle est utilisée pour instancier un modèle Sam3 Lite Text en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [yonigozlan/sam3-litetext-s0](https://huggingface.co/yonigozlan/sam3-litetext-s0)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

## Sam3LiteTextTextModel[[transformers.Sam3LiteTextTextModel]]

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

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

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

**Paramètres :**

config ([Sam3LiteTextTextConfig](/docs/transformers/v5.23.0/fr/model_doc/sam3_lite_text#transformers.Sam3LiteTextTextConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Encodeur de texte MobileCLIP MCT utilisé dans EfficientSAM3 LiteText.

Lorsque `config.use_repmixer_blocks` est `True`, la première et la dernière couche sont des modules `Sam3LiteTextRepMixerBlock` ; les autres sont des couches standard `Sam3LiteTextTextEncoderLayer`.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

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

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

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

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

Un `Sam3LiteTextTextEncoderOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([Sam3LiteTextConfig](/docs/transformers/v5.23.0/fr/model_doc/sam3_lite_text#transformers.Sam3LiteTextConfig)) et les entrées.

La méthode forward du modèle [Sam3LiteTextTextModel](/docs/transformers/v5.23.0/fr/model_doc/sam3_lite_text#transformers.Sam3LiteTextTextModel) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence complète des états cachés provenant de l'encodeur de texte.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, projection_dim)`) -- Sortie agrégée par EOT projetée sur `projection_dim` via la projection interne de type CLIP.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*) -- Tuple des états cachés à chaque couche, renvoyé lorsque `output_hidden_states=True`.
- **attentions** (`tuple(torch.Tensor)`, *facultatif*) -- Tuple des poids d'attention à chaque couche du transformeur, renvoyé lorsque `output_attentions=True`.

## Sam3LiteTextModel[[transformers.Sam3LiteTextModel]]

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

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

[Source](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'>)
```

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

**Paramètres :**

pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`, *facultatif*) : Les tenseurs correspondant aux images d’entrée. Les valeurs des pixels peuvent être obtenues à l’aide de [Sam3ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/sam3#transformers.Sam3ImageProcessor). Voir [Sam3ImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([Sam3Processor](/docs/transformers/v5.23.0/fr/model_doc/sam3#transformers.Sam3Processor) utilise [Sam3ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/sam3#transformers.Sam3ImageProcessor) pour le traitement des images).

vision_embeds (`Sam3LiteTextVisionEncoderOutput`, *facultatif*) : Incrustations visuelles précalculées. Peut être utilisé pour réutiliser facilement les incrustations visuelles. S'il est fourni, `pixel_values` ne doit pas être transmis. Mutuellement exclusif avec `pixel_values`.

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask)

text_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Incrustations de texte précalculées. Peut être utilisé pour réutiliser facilement des incrustations de texte. Si fourni, `input_ids` ne doit pas être passé. Mutuellement exclusif avec `input_ids`.

input_boxes (`torch.Tensor` de forme `(batch_size, num_boxes, 4)`, *facultatif*) : Coordonnées de boîtes normalisées dans l'intervalle [0, 1], au format (cx, cy, w, h).

input_boxes_labels (`torch.LongTensor` de forme `(batch_size, num_boxes)`, *facultatif*) : Étiquettes des boîtes : 1 (positif), 0 (négatif).

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

Un `Sam3LiteTextImageSegmentationOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([Sam3LiteTextConfig](/docs/transformers/v5.23.0/fr/model_doc/sam3_lite_text#transformers.Sam3LiteTextConfig)) et les entrées.

La méthode forward du modèle [Sam3LiteTextModel](/docs/transformers/v5.23.0/fr/model_doc/sam3_lite_text#transformers.Sam3LiteTextModel) redéfinit la méthode spéciale `__call__`.

Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.

- **pred_masks** (`torch.Tensor` de forme `(batch_size, num_queries, height, width)`) -- Masques de segmentation prédits pour chaque requête.
- **pred_boxes** (`torch.Tensor` de forme `(batch_size, num_queries, 4)`) -- Boîtes englobantes prédites au format (x1, y1, x2, y2).
- **pred_logits** (`torch.Tensor` de forme `(batch_size, num_queries)`, *facultatif*) -- Scores de confiance de classification pour chaque requête, calculés par produit scalaire entre les caractéristiques des requêtes du décodeur et les caractéristiques du texte.
- **presence_logits** (`torch.Tensor` de forme `(batch_size, 1)`, *facultatif*) -- Logits de présence issus du jeton de présence du décodeur DETR (dernière couche uniquement). Ils indiquent si des objets sont présents dans la scène. Ils peuvent être utilisés pour calculer les scores finaux en les multipliant par pred_logits : `final_scores = pred_logits.sigmoid() * presence_logits.sigmoid()`.
- **semantic_seg** (`torch.Tensor` de forme `(batch_size, 1, height, width)`, *facultatif*) -- Sortie de segmentation sémantique.
- **decoder_hidden_states** (`tuple[torch.Tensor]`, *facultatif*) -- Tuple d'états cachés de toutes les couches du décodeur DETR. Chaque tenseur a la forme `(batch_size, num_queries, hidden_size)`.
- **decoder_reference_boxes** (`torch.Tensor` de forme `(num_layers, batch_size, num_queries, 4)`, *facultatif*) -- Boîtes de référence de toutes les couches du décodeur DETR.
- **encoder_hidden_states** (`tuple[torch.Tensor]`, *facultatif*) -- Tuple des états cachés de toutes les couches de l'encodeur DETR.
- **vision_hidden_states** (`tuple[torch.Tensor]`, *facultatif*) -- Tuple des états cachés de toutes les couches de l'encodeur visuel (ViT).
- **vision_attentions** (`tuple[torch.Tensor]`, *facultatif*) -- Poids d'attention des couches de l'encodeur visuel (ViT).
- **detr_encoder_attentions** (`tuple[torch.Tensor]`, *facultatif*) -- Poids d'attention des couches encodeur de DETR.
- **detr_decoder_attentions** (`tuple[torch.Tensor]`, *facultatif*) -- Poids d'attention des couches décodeur de DETR (auto-attention et attention croisée).
- **mask_decoder_attentions** (`tuple[torch.Tensor]`, *facultatif*) -- Poids d'attention des couches du décodeur de masque.

Exemple :

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

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

**Paramètres :**

config ([PreTrainedConfig](/docs/transformers/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.).

Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux.

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

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

Une valeur factice pour un chemin pointé (par ex. `torch.float32`) : les chaînes d'accès aux attributs et les appels se comportent comme des décorateurs de pass-through, `repr` est le chemin pointé, et son utilisation comme classe de base substitue une base de `type` ordinaire (PEP 560 `__mro_entries__`), de sorte que les vraies sous-classes conservent un métaclasse normal et que `inspect.signature` lit leur `__init__` réel plutôt que celui d'une valeur factice.