Hugging Face's logo

Transformers documentation

SAM3-LiteText

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

and get access to the augmented documentation experience

to get started

Ce modèle a été publié dans les papiers HF le 2026-02-12 et contribué à Hugging Face Transformers le 2026-04-13.

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 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 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 et existe en trois variantes :

VarianteEncodeur de texteParamètres du texteRéduction
SAM3-LiteText-S0-16MobileCLIP-S042.54M~88%
SAM3-LiteText-S1-16MobileCLIP-S163.53M~82%
SAM3-LiteText-L-16MobileCLIP2-L123.80M~65%

Ce modèle a été contribué par nielsr et yonigozlan. Le code d'origine peut être trouvé ici.

Utilisation

SAM3-LiteText est un substitut direct de SAM3 doté d'un encodeur de texte léger. Il utilise le même processeur (Sam3Processor) et prend en charge la même interface de sollicitation. Consultez la documentation de 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.

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

classe transformers.Sam3LiteTextConfig

< >

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

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, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser 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 du yonigozlan/sam3-litetext-s0

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

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

classe transformers.Sam3LiteTextTextConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 49408hidden_size: int = 512intermediate_size: int = 2048projection_dim: int = 512num_hidden_layers: int = 12num_attention_heads: int = 8max_position_embeddings: int = 77hidden_act: str = 'gelu'layer_norm_eps: float = 1e-05attention_dropout: float = 0.0use_repmixer_blocks: bool = Truelayer_scale_init_value: float = 1e-05repmixer_kernel_size: int = 11 )

Paramètres

  • vocab_size (int, facultatif, 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, par défaut 2048) — Dimension des représentations du MLP.
  • projection_dim (int, facultatif, 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, 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) du 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, valeur 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. Lorsque 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 (mélangeur de jetons et chemin de réseau de neurones 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 du yonigozlan/sam3-litetext-s0

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Sam3LiteTextGeometryEncoderConfig

classe transformers.Sam3LiteTextGeometryEncoderConfig

< >

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

Paramètres

  • hidden_size (int, facultatif, par défaut 256) — Dimension des représentations cachées.
  • num_layers (int, facultatif, 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, par défaut 2048) — Dimension des représentations du MLP.
  • dropout (Union[float, int], facultatif, par défaut 0.1) — Le taux appliqué à toutes les couches de dropout.
  • hidden_act (str, facultatif, par défaut relu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • hidden_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l’encodeur et du pooler.
  • layer_norm_eps (float, facultatif, valeur par défaut 1e-06) — L'épsilon utilisé par les couches de normalisation de 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, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser 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 du yonigozlan/sam3-litetext-s0

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Sam3LiteTextDETREncoderConfig

classe transformers.Sam3LiteTextDETREncoderConfig

< >

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

Paramètres

  • hidden_size (int, facultatif, par défaut 256) — Dimension des représentations cachées.
  • num_layers (int, facultatif, 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, par défaut 2048) — Dimension des représentations du MLP.
  • dropout (Union[float, int], facultatif, par défaut 0.1) — Le taux appliqué à toutes les couches de dropout.
  • hidden_act (str, facultatif, par défaut relu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le 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, valeur par défaut 1e-06) — L'épsilon utilisé par les couches de normalisation de couche.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser 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 du yonigozlan/sam3-litetext-s0

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Sam3LiteTextDETRDecoderConfig

classe transformers.Sam3LiteTextDETRDecoderConfig

< >

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

Paramètres

  • hidden_size (int, facultatif, par défaut 256) — Dimension des représentations cachées.
  • num_layers (int, facultatif, 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, par défaut 2048) — Dimension des représentations du MLP.
  • dropout (Union[float, int], facultatif, par défaut 0.1) — Le taux appliqué à toutes les couches de dropout.
  • hidden_act (str, facultatif, par défaut relu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, "gelu", "relu", "silu", etc.
  • hidden_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Probabilité de dropout pour toutes les couches entièrement connectées des embeddings, de l’encodeur et du pooler.
  • layer_norm_eps (float, facultatif, valeur par défaut 1e-06) — L'épsilon utilisé par les couches de normalisation de couche.
  • initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser 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 du yonigozlan/sam3-litetext-s0

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Sam3LiteTextMaskDecoderConfig

classe transformers.Sam3LiteTextMaskDecoderConfig

< >

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

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 remonte en résolution dans le décodeur de pixels (FPN).
  • layer_norm_eps (float, facultatif, valeur par défaut 1e-06) — L'épsilon utilisé par les couches de normalisation de couche.
  • dropout (Union[float, int], facultatif, par défaut 0.0) — Le taux appliqué à 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, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser 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 du yonigozlan/sam3-litetext-s0

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Sam3LiteTextTextModel

classe transformers.Sam3LiteTextTextModel

< >

( config: Sam3LiteTextTextConfig )

Paramètres

  • config (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() 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. 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

< >

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

Paramètres

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 en fonction de la configuration (Sam3LiteTextConfig) et des entrées.

La méthode forward du modèle 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

classe transformers.Sam3LiteTextModel

< >

( config: Sam3LiteTextConfig )

forward

< >

( pixel_values: typing.Optional[torch.Tensor] = Nonevision_embeds: transformers.models.sam3_lite_text.modeling_sam3_lite_text.Sam3LiteTextVisionEncoderOutput | None = Noneinput_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetext_embeds: typing.Optional[torch.Tensor] = Noneinput_boxes: typing.Optional[torch.Tensor] = Noneinput_boxes_labels: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Sam3LiteTextImageSegmentationOutput or tuple(torch.Tensor)

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 de pixels peuvent être obtenues à l'aide de Sam3ImageProcessor. Voir Sam3ImageProcessor.call() pour plus de détails (Sam3Processor utilise Sam3ImageProcessor pour le traitement des images).
  • vision_embeds (Sam3LiteTextVisionEncoderOutput, facultatif) — Embeddings visuels précalculés. Peut être utilisé pour réutiliser facilement des embeddings visuels. S'il est fourni, pixel_values ne doit pas être passé. 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

    Qu'est-ce que les identifiants d'entrée ?

  • 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 masqués.

    Qu'est-ce que les masques d'attention ?

  • text_embeds (torch.Tensor de forme (batch_size, sequence_length, hidden_size), facultatif) — Embeddings de texte précalculés. Peut être utilisé pour réutiliser facilement des embeddings de texte. S’il est 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 en fonction de la configuration (Sam3LiteTextConfig) et des entrées.

La méthode forward du modèle 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 des é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 issues 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 :

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

classe transformers.Sam3LiteTextPreTrainedModel

< >

( config: PreTrainedConfig*inputs**kwargs )

Paramètres

  • config (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() pour charger les poids du modèle.

Ce modèle hérite de 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, la taille des têtes, etc.)

Ce modèle est également une sous-classe de 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

( *args**kwargs )

Valeur factice pour un chemin pointé (par exemple 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 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.

Update on GitHub

←SAM3 Vidéo ShieldGemma2→