Hugging Face's logo

Transformers documentation

SAM3

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

and get access to the augmented documentation experience

to get started

Ce modèle a été contribué à Hugging Face Transformers le 2025-11-19.

SAM3

SDPA FlashAttention

Aperçu

SAM3 (Segment Anything Model 3) a été introduit dans SAM 3: Segment Anything with Concepts.

SAM3 effectue la segmentation de concepts promptables (PCS) sur des images. La PCS prend en entrée du texte et/ou des exemples d’images (par exemple, « bus scolaire jaune ») et prédit des masques d’instance et sémantiques pour chaque objet correspondant au concept.

L'abstract de l'article est le suivant :

Nous présentons Segment Anything Model (SAM) 3, un modèle unifié qui détecte, segmente et suit des objets dans des images et des vidéos à partir de prompts de concepts, que nous définissons comme des phrases nominales courtes (par exemple, « yellow school bus »), des exemplaires d’images, ou une combinaison des deux. La segmentation de concepts promptable (PCS) prend de tels prompts en entrée et renvoie des masques de segmentation et des identités uniques pour toutes les instances d’objets correspondantes. Pour faire progresser la PCS, nous avons construit un moteur de données scalable qui produit un jeu de données de haute qualité avec 4M de libellés de concepts uniques, incluant des négatifs difficiles, sur des images et des vidéos. Notre modèle se compose d’un détecteur au niveau de l’image et d’un suiveur vidéo basé sur la mémoire qui partagent un seul backbone. La reconnaissance et la localisation sont découplées par une tête de présence, ce qui améliore la précision de la détection. SAM 3 double la précision des systèmes existants en PCS sur images et vidéos, et améliore les capacités précédentes de SAM sur les tâches de segmentation visuelle. Nous open source SAM 3 ainsi que notre nouveau benchmark Segment Anything with Concepts (SA-Co) pour la segmentation de concepts promptable.

Ce modèle a été contribué par yonigozlan et ronghanghu.

Exemples d'utilisation avec 🤗 Transformers

Prompts texte uniquement

import requests
import torch
from PIL import Image

from transformers import Sam3Model, Sam3Processor


model = Sam3Model.from_pretrained("facebook/sam3", device_map="auto")
processor = Sam3Processor.from_pretrained("facebook/sam3")

# Load image
image_url = "http://images.cocodataset.org/val2017/000000077595.jpg"
image = Image.open(requests.get(image_url, stream=True).raw).convert("RGB")

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

with torch.no_grad():
    outputs = model(**inputs)

# Post-process results
results = processor.post_process_instance_segmentation(
    outputs,
    threshold=0.5,
    mask_threshold=0.5,
    target_sizes=inputs.get("original_sizes").tolist()
)[0]

print(f"Found {len(results['masks'])} objects")
# Results contain:
# - masks: Binary masks resized to original image size
# - boxes: Bounding boxes in absolute pixel coordinates (xyxy format)
# - scores: Confidence scores

Prompt de boîte englobante unique

Segmenter des objets à l'aide d'une boîte englobante sur le concept visuel :

# Box in xyxy format: [x1, y1, x2, y2] in pixel coordinates
# Example: laptop region
box_xyxy = [100, 150, 500, 450]
input_boxes = [[box_xyxy]]  # [batch, num_boxes, 4]
input_boxes_labels = [[1]]  # 1 = positive box

inputs = processor(
    images=image,
    input_boxes=input_boxes,
    input_boxes_labels=input_boxes_labels,
    return_tensors="pt"
).to(model.device)

with torch.no_grad():
    outputs = model(**inputs)

# Post-process results
results = processor.post_process_instance_segmentation(
    outputs,
    threshold=0.5,
    mask_threshold=0.5,
    target_sizes=inputs.get("original_sizes").tolist()
)[0]

Plusieurs prompts de boîte (positifs et négatifs)

Utilisez plusieurs boîtes avec des étiquettes positives et négatives pour affiner le concept :

# Load kitchen image
kitchen_url = "http://images.cocodataset.org/val2017/000000136466.jpg"
kitchen_image = Image.open(requests.get(kitchen_url, stream=True).raw).convert("RGB")

# Define two positive boxes (e.g., dial and button on oven)
# Boxes are in xyxy format [x1, y1, x2, y2] in pixel coordinates
box1_xyxy = [59, 144, 76, 163]  # Dial box
box2_xyxy = [87, 148, 104, 159]  # Button box
input_boxes = [[box1_xyxy, box2_xyxy]]
input_boxes_labels = [[1, 1]]  # Both positive

inputs = processor(
    images=kitchen_image,
    input_boxes=input_boxes,
    input_boxes_labels=input_boxes_labels,
    return_tensors="pt"
).to(model.device)

with torch.no_grad():
    outputs = model(**inputs)

# Post-process results
results = processor.post_process_instance_segmentation(
    outputs,
    threshold=0.5,
    mask_threshold=0.5,
    target_sizes=inputs.get("original_sizes").tolist()
)[0]

Prompts combinés (Texte + Boîte négative)

Utilisez des invites textuelles avec des invites visuelles négatives pour affiner le concept :

# Segment "handle" but exclude the oven handle using a negative box
text = "handle"
# Negative box covering oven handle area (xyxy): [40, 183, 318, 204]
oven_handle_box = [40, 183, 318, 204]
input_boxes = [[oven_handle_box]]

inputs = processor(
    images=kitchen_image,
    text=text,
    input_boxes=input_boxes,
    input_boxes_labels=[[0]],  # 0 = negative (exclude this region)
    return_tensors="pt"
).to(model.device)

with torch.no_grad():
    outputs = model(**inputs)

# Post-process results
results = processor.post_process_instance_segmentation(
    outputs,
    threshold=0.5,
    mask_threshold=0.5,
    target_sizes=inputs.get("original_sizes").tolist()
)[0]
# This will segment pot handles but exclude the oven handle

Inférence par lots avec des invites de texte

Traiter efficacement plusieurs images avec des prompts de texte différents :

cat_url = "http://images.cocodataset.org/val2017/000000077595.jpg"
kitchen_url = "http://images.cocodataset.org/val2017/000000136466.jpg"
images = [
    Image.open(requests.get(cat_url, stream=True).raw).convert("RGB"),
    Image.open(requests.get(kitchen_url, stream=True).raw).convert("RGB")
]

# Different text prompt for each image
text_prompts = ["ear", "dial"]

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

with torch.no_grad():
    outputs = model(**inputs)

# Post-process results for both images
results = processor.post_process_instance_segmentation(
    outputs,
    threshold=0.5,
    mask_threshold=0.5,
    target_sizes=inputs.get("original_sizes").tolist()
)

print(f"Image 1: {len(results[0]['masks'])} objects found")
print(f"Image 2: {len(results[1]['masks'])} objects found")

Prompts mixtes en lot

Utiliser différents types de prompts pour différentes images dans le même lot :

# Image 1: text prompt "laptop"
# Image 2: visual prompt (dial box)
box2_xyxy = [59, 144, 76, 163]

inputs = processor(
    images=images,
    text=["laptop", None],  # Only first image has text
    input_boxes=[None, [box2_xyxy]],  # Only second image has box
    input_boxes_labels=[None, [1]],  # Positive box for second image
    return_tensors="pt"
).to(model.device)

with torch.no_grad():
    outputs = model(**inputs)

# Post-process results for both images
results = processor.post_process_instance_segmentation(
    outputs,
    threshold=0.5,
    mask_threshold=0.5,
    target_sizes=inputs.get("original_sizes").tolist()
)
# Both images processed in single forward pass

Sortie de segmentation sémantique

SAM3 fournit également une segmentation sémantique en plus des masques d’instances :

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

with torch.no_grad():
    outputs = model(**inputs)

# Instance segmentation masks
instance_masks = torch.sigmoid(outputs.pred_masks)  # [batch, num_queries, H, W]

# Semantic segmentation (single channel)
semantic_seg = outputs.semantic_seg  # [batch, 1, H, W]

print(f"Instance masks: {instance_masks.shape}")
print(f"Semantic segmentation: {semantic_seg.shape}")

Inférence multi-invocations efficace sur une seule image

Lors de l’exécution de plusieurs prompts de texte sur la même image, précalculez les embeddings visuels pour éviter les calculs redondants :

from transformers import Sam3Processor, Sam3Model
import torch
from PIL import Image
import requests


model = Sam3Model.from_pretrained("facebook/sam3", device_map="auto")
processor = Sam3Processor.from_pretrained("facebook/sam3")

# Load image
image_url = "http://images.cocodataset.org/val2017/000000077595.jpg"
image = Image.open(requests.get(image_url, stream=True).raw).convert("RGB")

# Pre-process image and compute vision embeddings once
img_inputs = processor(images=image, return_tensors="pt").to(model.device)
with torch.no_grad():
    vision_embeds = model.get_vision_features(pixel_values=img_inputs.pixel_values)

# Run multiple text prompts efficiently
text_prompts = ["ear", "eye", "nose"]
all_results = []

for prompt in text_prompts:
    text_inputs = processor(text=prompt, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(vision_embeds=vision_embeds, **text_inputs)
...
    results = processor.post_process_instance_segmentation(
        outputs,
        threshold=0.5,
        mask_threshold=0.5,
        target_sizes=img_inputs.get("original_sizes").tolist()
    )[0]
    all_results.append({"prompt": prompt, "results": results})

for item in all_results:
    print(f"Prompt '{item['prompt']}': {len(item['results']['masks'])} objects found")

Inférence efficace avec un seul prompt sur plusieurs images

Lors de l’exécution de la même invite de texte sur plusieurs images, précalculez les embeddings de texte pour éviter les calculs redondants :

from transformers import Sam3Processor, Sam3Model
import torch
from PIL import Image
import requests


model = Sam3Model.from_pretrained("facebook/sam3", device_map="auto")
processor = Sam3Processor.from_pretrained("facebook/sam3")

# Pre-compute text embeddings once
text_prompt = "ear"
text_inputs = processor(text=text_prompt, return_tensors="pt").to(model.device)
with torch.no_grad():
    text_embeds = model.get_text_features(**text_inputs)

# Load multiple images
image_urls = [
    "http://images.cocodataset.org/val2017/000000077595.jpg",
    "http://images.cocodataset.org/val2017/000000039769.jpg",
]
images = [Image.open(requests.get(url, stream=True).raw).convert("RGB") for url in image_urls]

# Run inference on each image reusing text embeddings
# Note: attention_mask must be passed along with text_embeds for proper masking
all_results = []

for image in images:
    img_inputs = processor(images=image, return_tensors="pt").to(model.device)
    with torch.no_grad():
        outputs = model(
            pixel_values=img_inputs.pixel_values,
            text_embeds=text_embeds,
            attention_mask=text_inputs.attention_mask,
        )
...
    results = processor.post_process_instance_segmentation(
        outputs,
        threshold=0.5,
        mask_threshold=0.5,
        target_sizes=img_inputs.get("original_sizes").tolist()
    )[0]
    all_results.append(results)

for i, results in enumerate(all_results):
    print(f"Image {i+1}: {len(results['masks'])} '{text_prompt}' objects found")

Inférence à résolution personnalisée

⚠️ **Note sur les performances** : Les résolutions personnalisées peuvent dégrader la précision. Le modèle est conçu pour être utilisé à une résolution de 1008 px.

Pour une inférence plus rapide ou une consommation mémoire réduite :

config = Sam3Config.from_pretrained("facebook/sam3")
config.image_size = 560
model = Sam3Model.from_pretrained("facebook/sam3", config=config, device_map="auto")
processor = Sam3Processor.from_pretrained("facebook/sam3", size={"height": 560, "width": 560})

Conventions d'étiquetage des prompts

SAM3 utilise les conventions d’étiquetage suivantes :

Pour les points et les boîtes :

  • 1 : invite positive (inclure cette région/objet)
  • 0 : Prompt négatif (exclure cette région/objet)
  • -10 : valeur de bourrage pour les entrées par lot

Formats de coordonnées :

  • Boîtes d'entrée : [x1, y1, x2, y2] (format xyxy) en coordonnées de pixels
  • Boîtes de sortie (brutes) : [x1, y1, x2, y2] (format xyxy), normalisées dans [0, 1]
  • Boîtes de sortie (après post-traitement) : [x1, y1, x2, y2] (format xyxy) en coordonnées de pixels absolues

Sam3Config

classe transformers.Sam3Config

< >

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

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 Sam3GeometryEncoderConfig, facultatif) — Configuration de l'encodeur de géométrie.
  • detr_encoder_config (dict ou Sam3DETREncoderConfig, facultatif) — Configuration de l’encodeur DETR.
  • detr_decoder_config (dict ou Sam3DETRDecoderConfig, facultatif) — Configuration du décodeur DETR.
  • mask_decoder_config (dict ou Sam3MaskDecoderConfig, 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.

Ceci est la classe de configuration destinée à stocker la configuration d'un Sam3Model. Elle est utilisée pour instancier un modèle Sam3 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 facebook/sam3

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 Sam3Config, Sam3Model

>>> # Initializing a SAM3 configuration
>>> configuration = Sam3Config()

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

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

Sam3ViTConfig

classe transformers.Sam3ViTConfig

< >

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

Paramètres

  • hidden_size (int, facultatif, par défaut 1024) — Dimension des représentations cachées.
  • intermediate_size (int, facultatif, valeur par défaut 4736) — Dimension des représentations du MLP.
  • num_hidden_layers (int, facultatif, par défaut 32) — Nombre de couches cachées dans le décodeur Transformer.
  • num_attention_heads (int, facultatif, valeur par défaut 16) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
  • num_channels (int, facultatif, par défaut 3) — Le nombre de canaux d'entrée.
  • image_size (Union[int, list[int], tuple[int, int]], facultatif, par défaut 1008) — La taille (résolution) de chaque image.
  • patch_size (Union[int, list[int], tuple[int, int]], facultatif, par défaut 14) — La taille (résolution) de chaque patch.
  • 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-06) — L'épsilon utilisé par les couches de normalisation de couche.
  • attention_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Le taux de dropout appliqué aux probabilités d'attention.
  • window_size (int, facultatif, valeur par défaut : 24) — Taille de la fenêtre pour l'attention par fenêtres.
  • global_attn_indexes (list[int], facultatif, par défaut [7, 15, 23, 31]) — Indices des couches avec attention globale.
  • layer_scale_init_value (float, facultatif) — Échelle à utiliser dans les couches d'auto-attention. 0,1 pour les modèles de base, 1e-6 pour les grands modèles. Définir 0 pour désactiver l'échelle de couche.
  • pretrain_image_size (int, facultatif, par défaut 336) — Taille d'image du modèle préentraîné pour l'initialisation des embeddings de position.
  • hidden_dropout (float, facultatif, valeur par défaut 0.0) — Probabilité de dropout pour les états cachés.
  • 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.
  • rope_parameters (dict, facultatif) — Dictionnaire contenant les paramètres de configuration des embeddings RoPE. Le dictionnaire doit contenir une valeur pour rope_theta et, le cas échéant, les paramètres utilisés pour le mise à l’échelle si vous souhaitez utiliser RoPE avec des max_position_embeddings plus longs.

Ceci est la classe de configuration destinée à stocker la configuration d'un Sam3Model. Elle est utilisée pour instancier un modèle Sam3 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 facebook/sam3

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.

Sam3VisionConfig

classe transformers.Sam3VisionConfig

< >

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

Paramètres

  • backbone_config (Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — La configuration du modèle backbone.
  • fpn_hidden_size (int, facultatif, par défaut 256) — La dimension cachée du FPN.
  • backbone_feature_sizes (List[List[int]], facultatif, par défaut [[288, 288], [144, 144], [72, 72]]) — Les dimensions spatiales (hauteur, largeur) des cartes de caractéristiques issues du backbone à différentes échelles.
  • scale_factors (list[float], facultatif, par défaut [4.0, 2.0, 1.0, 0.5]) — Facteurs d'échelle pour les caractéristiques multi-échelles de FPN. Liste des facteurs d'échelle pour chaque niveau de FPN.
  • 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-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.

Ceci est la classe de configuration destinée à stocker la configuration d'un Sam3Model. Elle est utilisée pour instancier un modèle Sam3 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 facebook/sam3

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.

Sam3GeometryEncoderConfig

classe transformers.Sam3GeometryEncoderConfig

< >

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

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.

Ceci est la classe de configuration destinée à stocker la configuration d'un Sam3Model. Elle est utilisée pour instancier un modèle Sam3 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 facebook/sam3

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.

Sam3DETREncoderConfig

classe transformers.Sam3DETREncoderConfig

< >

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

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.

Ceci est la classe de configuration destinée à stocker la configuration d'un Sam3Model. Elle est utilisée pour instancier un modèle Sam3 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 facebook/sam3

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.

Sam3DETRDecoderConfig

classe transformers.Sam3DETRDecoderConfig

< >

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

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.

Ceci est la classe de configuration destinée à stocker la configuration d'un Sam3Model. Elle est utilisée pour instancier un modèle Sam3 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 facebook/sam3

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.

Sam3MaskDecoderConfig

classe transformers.Sam3MaskDecoderConfig

< >

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

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.

Ceci est la classe de configuration destinée à stocker la configuration d'un Sam3Model. Elle est utilisée pour instancier un modèle Sam3 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 facebook/sam3

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.

Sam3Processor

classe transformers.Sam3Processor

< >

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

Paramètres

  • image_processor (Sam3ImageProcessor) — Le processeur d’images est une entrée obligatoire.
  • tokenizer (CLIPTokenizer) — Le tokenizer est une entrée obligatoire.
  • target_size (int, facultatif) — La taille cible (target_size, target_size) à laquelle l'image sera redimensionnée.
  • point_pad_value (int, facultatif, valeur par défaut : -10) — La valeur utilisée pour l’ajustement des boîtes d’entrée.

Construit un Sam3Processor qui encapsule un processeur d'image et un tokenizer en un seul processeur.

Sam3Processor propose toutes les fonctionnalités de Sam3ImageProcessor et de CLIPTokenizer. Consultez ~Sam3ImageProcessor et ~CLIPTokenizer pour plus d'informations.

__call__

< >

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

Paramètres

  • images (ImageInput, optional) — The image(s) to process.
  • text (str, list[str], list[list[str]], facultatif) — Le texte à traiter.
  • segmentation_maps (ImageInput, facultatif) — Les cartes de segmentation à traiter.
  • input_boxes (list[list[list[float]]], torch.Tensor, facultatif) — Les boîtes englobantes à traiter.
  • input_boxes_labels (list[list[int]], torch.Tensor, facultatif) — Les étiquettes des boîtes englobantes.
  • original_sizes (list[list[float]], torch.Tensor, facultatif) — Les dimensions d'origine des images.
  • return_tensors (Union[str, ~utils.generic.TensorType], facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptables sont :
    • 'pt' : Renvoie des objets torch.Tensor de PyTorch.
    • 'np' : Renvoie des objets NumPy np.ndarray.

Retourne

Un BatchEncoding avec les champs suivants

  • pixel_values (torch.Tensor) : l’image (ou les images) traitée(s).
  • original_sizes (list[list[float]]) : Les dimensions d’origine des images.
  • labels (torch.Tensor) : les cartes de segmentation traitées (si fournies).
  • input_boxes_labels (torch.Tensor) : Les étiquettes traitées pour les boîtes englobantes.
  • input_boxes (torch.Tensor) : Les boîtes englobantes traitées.

Sam3ImageProcessor

classe transformers.Sam3ImageProcessor

< >

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

Paramètres

  • do_convert_rgb (bool, kwargs, facultatif, par défaut True) — Indique s'il faut convertir l'image en RGB.
  • do_resize (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut redimensionner l'image.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut {'height' -- 1008, 'width': 1008}) : Définit les dimensions d'entrée maximales du modèle.
  • default_to_square (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut utiliser une image carrée par défaut lors du redimensionnement, si la taille est un entier.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application de center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, par défaut 2) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
  • do_rescale (bool, kwargs, facultatif, par défaut True) — Indique s'il faut rééchelonner l'image.
  • rescale_factor (float, kwargs, facultatif, valeur par défaut 0.00392156862745098) — Facteur de remise à l'échelle appliqué à l'image si do_rescale est défini sur True.
  • do_normalize (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut normaliser l'image.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut [0.5, 0.5, 0.5]) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif, valeur par défaut [0.5, 0.5, 0.5]) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • do_pad (bool, kwargs, facultatif, valeur par défaut None) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, par défaut None) — La taille au format {"height": int, "width" int} à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si pad_size n'est pas fourni, les images seront rembourrées à la plus grande hauteur et largeur du lot. Appliqué uniquement lorsque do_pad=True.
  • do_center_crop (bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
    • "channels_first" ou ChannelDimension.FIRST : image au format (num_channels, height, width).
    • "channels_last" ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
    • "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
  • disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.
  • mask_size (dict[str, *kwargs*, int], facultatif) — La taille {"height": int, "width": int} à laquelle redimensionner les cartes de segmentation.

Construit un processeur d’image Sam3ImageProcessor.

prétraiter

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None**kwargs: *<class 'transformers.models.sam3.image_processing_sam3.Sam3ImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature

Paramètres

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Image à prétraiter. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez do_rescale=False.
  • segmentation_maps (ImageInput, facultatif) — Les cartes de segmentation à prétraiter.
  • do_convert_rgb (bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB.
  • do_resize (bool, kwargs, facultatif) — Indique s'il faut redimensionner l'image.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Définit les dimensions maximales des entrées du modèle.
  • default_to_square (bool, kwargs, facultatif) — Indique s'il faut par défaut redimensionner l'image en carré si la taille est un entier.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application de center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
  • do_rescale (bool, kwargs, facultatif) — Indique s'il faut rééchelonner l'image.
  • rescale_factor (float, kwargs, facultatif) — Facteur de remise à l'échelle à appliquer à l'image si do_rescale est défini sur True.
  • do_normalize (bool, kwargs, facultatif) — Indique s'il faut normaliser l'image.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
  • do_pad (bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — La taille au format {"height": int, "width" int} à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsque do_pad=True.
  • do_center_crop (bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
    • "channels_first" ou ChannelDimension.FIRST : image au format (num_channels, height, width).
    • "channels_last" ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
    • "none" ou ChannelDimension.NONE : image au format (hauteur, largeur).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne une liste de tenseurs.
  • disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.
  • mask_size (dict[str, *kwargs*, int], facultatif) — La taille {"height": int, "width": int} à laquelle redimensionner les cartes de segmentation.

Retourne

~image_processing_base.BatchFeature

  • data (dict) — Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode call (« pixel_values », etc.).
  • tensor_type (Union[None, str, TensorType], facultatif) — Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.

Sam3ViTModel

classe transformers.Sam3ViTModel

< >

( config: Sam3ViTConfig )

Paramètres

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

Le modèle Sam3 brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet.

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

< >

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

Paramètres

Retourne

BaseModelOutput ou tuple(torch.FloatTensor)

Un BaseModelOutput ou un tuple de torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (Sam3Config) et des entrées.

La méthode forward du modèle Sam3ViTModel 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.FloatTensor de forme (batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.

  • hidden_states (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Sam3VisionModel

classe transformers.Sam3VisionModel

< >

( config: Sam3VisionConfig )

Paramètres

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

Le modèle de vision de Sam, sans aucune tête ni projection au sommet.

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

< >

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

Sam3Model

classe transformers.Sam3Model

< >

( config: Sam3Config )

forward

< >

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

Paramètres

  • pixel_values (torch.FloatTensor 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 (Sam3VisionEncoderOutput, 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 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. 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.FloatTensor 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.FloatTensor de forme (batch_size, num_boxes, 4), facultatif) — Coordonnées des 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

Sam3ImageSegmentationOutput ou tuple(torch.FloatTensor)

Un Sam3ImageSegmentationOutput ou un tuple de torch.FloatTensor (si return_dict=False est passé ou si config.return_dict=False) comprenant divers éléments en fonction de la configuration (Sam3Config) et des entrées.

La méthode forward de Sam3Model 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.FloatTensor de forme (batch_size, num_queries, height, width)) — Masques de segmentation prédits pour chaque requête.
  • pred_boxes (torch.FloatTensor de forme (batch_size, num_queries, 4)) — Boîtes englobantes prédites au format (x1, y1, x2, y2).
  • pred_logits (torch.FloatTensor 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.FloatTensor 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.FloatTensor de forme (batch_size, 1, height, width), facultatif) — Sortie de segmentation sémantique.
  • decoder_hidden_states (tuple[torch.FloatTensor], 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.FloatTensor 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.FloatTensor], facultatif) — Tuple des états cachés de toutes les couches de l'encodeur DETR.
  • vision_hidden_states (tuple[torch.FloatTensor], facultatif) — Tuple des états cachés de toutes les couches de l'encodeur visuel (ViT).
  • vision_attentions (tuple[torch.FloatTensor], facultatif) — Poids d'attention des couches de l'encodeur visuel (ViT).
  • detr_encoder_attentions (tuple[torch.FloatTensor], facultatif) — Poids d'attention des couches encodeur de DETR.
  • detr_decoder_attentions (tuple[torch.FloatTensor], facultatif) — Poids d'attention des couches décodeur de DETR (auto-attention et attention croisée).
  • mask_decoder_attentions (tuple[torch.FloatTensor], 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")
>>> processor = AutoProcessor.from_pretrained("facebook/sam3")

>>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/sam-car.png"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read())).convert("RGB")
>>> text = "car"
>>> inputs = processor(images=image, text=text, return_tensors="pt")

>>> # Get segmentation output
>>> outputs = model(**inputs)
>>> pred_masks = outputs.pred_masks
>>> pred_boxes = outputs.pred_boxes

get_text_features

< >

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

Paramètres

Retourne

BaseModelOutputWithPooling ou tuple(torch.FloatTensor)

Un BaseModelOutputWithPooling ou un tuple de torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers éléments en fonction de la configuration (Sam3Config) et des entrées.

  • last_hidden_state (torch.FloatTensor de forme (batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.

  • pooler_output (torch.FloatTensor de forme (batch_size, hidden_size)) — État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire à travers les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.

  • hidden_states (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size).

    États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.

  • attentions (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

    Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.

Exemple :

>>> from transformers import Sam3Model, Sam3Processor
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> model = Sam3Model.from_pretrained("facebook/sam3")
>>> processor = Sam3Processor.from_pretrained("facebook/sam3")

>>> # Pre-compute text embeddings
>>> text_inputs = processor(text="cat", return_tensors="pt")
>>> text_embeds = model.get_text_features(**text_inputs).pooler_output

>>> # Reuse text embeddings for multiple images
>>> url = "http://images.cocodataset.org/val2017/000000077595.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))
>>> img_inputs = processor(images=image, return_tensors="pt")
>>> outputs = model(pixel_values=img_inputs.pixel_values, text_embeds=text_embeds)
Update on GitHub

←Qwen3VLMoe SAM3 Vidéo→