Transformers documentation
EdgeTAM
Ce modèle a été publié dans HF papers le 2025-01-13 et ajouté à Hugging Face Transformers le 2025-09-29.
EdgeTAM
Aperçu
Le modèle EdgeTAM a été proposé dans EdgeTAM: On-Device Track Anything Model Chong Zhou, Chenchen Zhu, Yunyang Xiong, Saksham Suri, Fanyi Xiao, Lemeng Wu, Raghuraman Krishnamoorthi, Bo Dai, Chen Change Loy, Vikas Chandra, Bilge Soran.
EdgeTAM est une adaptation efficace de SAM 2 qui introduit une architecture 2D Spatial Perceiver afin d'optimiser les mécanismes d'attention mémoire pour la segmentation vidéo en temps réel sur des appareils mobiles.
L'abstract de l'article est le suivant :
Au-delà de Segment Anything Model (SAM), SAM 2 étend davantage sa capacité des images aux entrées vidéo grâce à un mécanisme de mémoire et obtient des performances remarquables par rapport aux méthodes précédentes, ce qui en fait un modèle de base pour la tâche de segmentation vidéo. Dans cet article, nous visons à rendre SAM 2 beaucoup plus efficace afin qu'il puisse même s'exécuter sur des appareils mobiles tout en maintenant des performances comparables. Malgré plusieurs travaux optimisant SAM pour une meilleure efficacité, nous constatons qu'ils ne sont pas suffisants pour SAM 2, car ils se concentrent tous sur la compression de l'encodeur d'image, alors que notre référence montre que les nouveaux blocs d'attention mémoire introduits constituent également le goulot d'étranglement de latence. Compte tenu de cette observation, nous proposons EdgeTAM, qui exploite un nouveau 2D Spatial Perceiver pour réduire le coût de calcul. En particulier, le 2D Spatial Perceiver proposé encode les mémoires de niveau image stockées de manière dense avec un Transformer léger contenant un ensemble fixe de requêtes apprenables. Étant donné que la segmentation vidéo est une tâche de prédiction dense, nous constatons qu'il est essentiel de préserver la structure spatiale des mémoires, de sorte que les requêtes sont divisées en groupes de niveau global et de niveau patch. Nous proposons également un pipeline de distillation qui améliore davantage les performances sans surcharge d'inférence. En conséquence, EdgeTAM atteint 87,7, 70,0, 72,3 et 71,7 J&F sur DAVIS 2017, MOSE, SA-V val et SA-V test, tout en fonctionnant à 16 FPS sur iPhone 15 Pro Max.
Ce modèle a été contribué par yonigozlan. Le code d'origine peut être trouvé ici.
Exemple d'utilisation
Génération automatique de masques avec Pipeline
EdgeTAM peut être utilisé pour la génération automatique de masques afin de segmenter tous les objets d'une image à l'aide du pipeline mask-generation :
from transformers import pipeline
generator = pipeline("mask-generation", model="yonigozlan/edgetam-1", device=0)
image_url = "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/truck.jpg"
outputs = generator(image_url, points_per_batch=64)
len(outputs["masks"]) # Number of masks generated
39Segmentation d’images de base
Clic en un seul point
Vous pouvez segmenter des objets en effectuant un simple clic sur l'objet que vous souhaitez segmenter :
from transformers import Sam2Processor, EdgeTamModel
import torch
from PIL import Image
import requests
model = EdgeTamModel.from_pretrained("yonigozlan/edgetam-1", device_map="auto")
processor = Sam2Processor.from_pretrained("yonigozlan/edgetam-1")
image_url = "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/truck.jpg"
raw_image = Image.open(requests.get(image_url, stream=True).raw).convert("RGB")
input_points = [[[[500, 375]]]] # Single point click, 4 dimensions (image_dim, object_dim, point_per_object_dim, coordinates)
input_labels = [[[1]]] # 1 for positive click, 0 for negative click, 3 dimensions (image_dim, object_dim, point_label)
inputs = processor(images=raw_image, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)
with torch.no_grad():
outputs = model(**inputs)
masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])[0]
# The model outputs multiple mask predictions ranked by quality score
print(f"Generated {masks.shape[1]} masks with shape {masks.shape}")
Generated 3 masks with shape torch.Size([1, 3, 1200, 1800])
print(f"IoU scores: {outputs.iou_scores.squeeze()}")
IoU scores: tensor([0.0463, 0.4859, 0.7616], device='cuda:0')Plusieurs points à affiner
Vous pouvez fournir plusieurs points pour affiner la segmentation :
# Add both positive and negative points to refine the mask
input_points = [[[[500, 375], [1125, 625]]]] # Multiple points for refinement
input_labels = [[[1, 1]]] # Both positive clicks
inputs = processor(images=raw_image, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)
with torch.no_grad():
outputs = model(**inputs)
masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])[0]
print(f"IoU scores: {outputs.iou_scores.squeeze()}")
IoU scores: tensor([0.8362, 0.6900, 0.2120], device='cuda:0')Entrée de boîte englobante
EdgeTAM prend également en charge les entrées de boîtes englobantes pour la segmentation :
# Define bounding box as [x_min, y_min, x_max, y_max]
input_boxes = [[[75, 275, 1725, 850]]]
inputs = processor(images=raw_image, input_boxes=input_boxes, return_tensors="pt").to(model.device)
with torch.no_grad():
outputs = model(**inputs)
masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])[0]
print(f"IoU scores: {outputs.iou_scores.squeeze()}")
IoU scores: tensor([0.9301, 0.9348, 0.6605], device='cuda:0')Segmentation de plusieurs objets
Vous pouvez segmenter plusieurs objets simultanément :
# Define points for two different objects
input_points = [[[[500, 375]], [[650, 750]]]] # Points for two objects in same image
input_labels = [[[1], [1]]] # Positive clicks for both objects
inputs = processor(images=raw_image, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)
with torch.no_grad():
outputs = model(**inputs, multimask_output=False)
# Each object gets its own mask
masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])[0]
print(f"Generated masks for {masks.shape[0]} objects")
Generated masks for 2 objects
print(f"IoU scores: {outputs.iou_scores.squeeze()}")
IoU scores: tensor([0.7616, 0.9465], device='cuda:0')Inférence par lots
Images par lots
Traitez plusieurs images simultanément pour une efficacité accrue :
from transformers import Sam2Processor, EdgeTamModel
import torch
from PIL import Image
import requests
model = EdgeTamModel.from_pretrained("yonigozlan/edgetam-1", device_map="auto")
processor = Sam2Processor.from_pretrained("yonigozlan/edgetam-1")
# Load multiple images
image_urls = [
"https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/truck.jpg",
"https://huggingface.co/datasets/hf-internal-testing/transformers-synthetic-assets/resolve/main/images/dog_sam.png"
]
raw_images = [Image.open(requests.get(url, stream=True).raw).convert("RGB") for url in image_urls]
# Single point per image
input_points = [[[[500, 375]]], [[[770, 200]]]] # One point for each image
input_labels = [[[1]], [[1]]] # Positive clicks for both images
inputs = processor(images=raw_images, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)
with torch.no_grad():
outputs = model(**inputs, multimask_output=False)
# Post-process masks for each image
all_masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])
print(f"Processed {len(all_masks)} images, each with {all_masks[0].shape[0]} objects")
Processed 2 images, each with 1 objects
print(f"IoU scores: {outputs.iou_scores.squeeze()}")
IoU scores: tensor([0.7618, 0.7999], device='cuda:0')Objets par lot par image
Segmenter plusieurs objets dans chaque image à l'aide d'une inférence par lot :
# Multiple objects per image - different numbers of objects per image
input_points = [
[[[500, 375]], [[650, 750]]], # Truck image: 2 objects
[[[770, 200]]] # Dog image: 1 object
]
input_labels = [
[[1], [1]], # Truck image: positive clicks for both objects
[[1]] # Dog image: positive click for the object
]
inputs = processor(images=raw_images, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)
with torch.no_grad():
outputs = model(**inputs, multimask_output=False)
all_masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])Images par lots avec des objets par lots et plusieurs points
Gérer des scénarios de lot complexes avec plusieurs points par objet :
# Add groceries image for more complex example
groceries_url = "https://huggingface.co/datasets/hf-internal-testing/sam2-fixtures/resolve/main/groceries.jpg"
groceries_image = Image.open(requests.get(groceries_url, stream=True).raw).convert("RGB")
raw_images = [raw_images[0], groceries_image] # Use truck and groceries images
# Complex batching: multiple images, multiple objects, multiple points per object
input_points = [
[[[500, 375]], [[650, 750]]], # Truck image: 2 objects with 1 point each
[[[400, 300]], [[630, 300], [550, 300]]] # Groceries image: obj1 has 1 point, obj2 has 2 points
]
input_labels = [
[[1], [1]], # Truck image: positive clicks
[[1], [1, 1]] # Groceries image: positive clicks for refinement
]
inputs = processor(images=raw_images, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)
with torch.no_grad():
outputs = model(**inputs, multimask_output=False)
all_masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])Boîtes englobantes par lots
Traiter plusieurs images avec des entrées de boîtes englobantes :
# Multiple bounding boxes per image (using truck and groceries images)
input_boxes = [
[[75, 275, 1725, 850], [425, 600, 700, 875], [1375, 550, 1650, 800], [1240, 675, 1400, 750]], # Truck image: 4 boxes
[[450, 170, 520, 350], [350, 190, 450, 350], [500, 170, 580, 350], [580, 170, 640, 350]] # Groceries image: 4 boxes
]
# Update images for this example
raw_images = [raw_images[0], groceries_image] # truck and groceries
inputs = processor(images=raw_images, input_boxes=input_boxes, return_tensors="pt").to(model.device)
with torch.no_grad():
outputs = model(**inputs, multimask_output=False)
all_masks = processor.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"])
print(f"Processed {len(input_boxes)} images with {len(input_boxes[0])} and {len(input_boxes[1])} boxes respectively")
Processed 2 images with 4 and 4 boxes respectively
print(f"IoU scores: {outputs.iou_scores.squeeze()}")
IoU scores: tensor([0.9301, 0.9348, 0.6605, 0.9465], device='cuda:0')Utilisation des masques précédents en tant qu'entrée
EdgeTAM peut utiliser les masques des prédictions précédentes comme entrée pour affiner la segmentation :
# Get initial segmentation
input_points = [[[[500, 375]]]]
input_labels = [[[1]]]
inputs = processor(images=raw_image, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(model.device)
with torch.no_grad():
outputs = model(**inputs)
# Use the best mask as input for refinement
mask_input = outputs.pred_masks[:, :, torch.argmax(outputs.iou_scores.squeeze())]
# Add additional points with the mask input
new_input_points = [[[[500, 375], [450, 300]]]]
new_input_labels = [[[1, 1]]]
inputs = processor(
input_points=new_input_points,
input_labels=new_input_labels,
original_sizes=inputs["original_sizes"],
return_tensors="pt",
).to(model.device)
with torch.no_grad():
refined_outputs = model(
**inputs,
input_masks=mask_input,
image_embeddings=outputs.image_embeddings,
multimask_output=False,
)EdgeTamConfig
classe transformers.EdgeTamConfig
< source >( 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 = Noneprompt_encoder_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. - prompt_encoder_config (Union[
dict,EdgeTamPromptEncoderConfig], facultatif) — Dictionnaire des options de configuration utilisées pour initialiser EdgeTamPromptEncoderConfig. - mask_decoder_config (Union[
dict,EdgeTamMaskDecoderConfig], facultatif) — Dictionnaire des options de configuration utilisées pour initialiser EdgeTamMaskDecoderConfig. - initializer_range (
float, facultatif, par défaut0.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 EdgeTamModel. Elle est utilisée pour instancier un modèle Edgetam en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de yonigozlan/EdgeTAM-hf
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 (
... EdgeTamVisionConfig,
... EdgeTamPromptEncoderConfig,
... EdgeTamMaskDecoderConfig,
... EdgeTamModel,
... )
>>> # Initializing a EdgeTamConfig with `"facebook/edgetam.1_hiera_tiny"` style configuration
>>> configuration = EdgeTamConfig()
>>> # Initializing a EdgeTamModel (with random weights) from the `"facebook/edgetam.1_hiera_tiny"` style configuration
>>> model = EdgeTamModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config
>>> # We can also initialize a EdgeTamConfig from a EdgeTamVisionConfig, EdgeTamPromptEncoderConfig, and EdgeTamMaskDecoderConfig
>>> # Initializing EDGETAM vision encoder, memory attention, and memory encoder configurations
>>> vision_config = EdgeTamVisionConfig()
>>> prompt_encoder_config = EdgeTamPromptEncoderConfig()
>>> mask_decoder_config = EdgeTamMaskDecoderConfig()
>>> config = EdgeTamConfig(vision_config, prompt_encoder_config, mask_decoder_config)EdgeTamVisionConfig
classe transformers.EdgeTamVisionConfig
< source >( 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 = Nonebackbone_channel_list: list[int] | None = Nonebackbone_feature_sizes: list | None = Nonefpn_hidden_size: int = 256fpn_kernel_size: int = 1fpn_stride: int = 1fpn_padding: int = 0fpn_top_down_levels: list[int] | None = Nonenum_feature_levels: int = 3hidden_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. - backbone_channel_list (
List[int], facultatif, par défaut[384, 192, 96, 48]) — La liste des dimensions de canaux pour le backbone. - backbone_feature_sizes (
List[List[int]], facultatif, par défaut[[256, 256], [128, 128], [64, 64]]) — Les tailles spatiales des cartes de caractéristiques issues du backbone. - fpn_hidden_size (
int, facultatif, par défaut 256) — La dimension cachée du FPN. - fpn_kernel_size (
int, facultatif, valeur par défaut 1) — La taille du noyau pour les convolutions dans le cou. - fpn_stride (
int, facultatif, valeur par défaut 1) — Le pas des convolutions dans le cou. - fpn_padding (
int, facultatif, valeur par défaut 0) — Le padding des convolutions dans le cou (neck). - fpn_top_down_levels (
List[int], facultatif, par défaut[2, 3]) — Les niveaux pour les connexions FPN de haut en bas. - num_feature_levels (
int, facultatif, valeur par défaut 3) — Le nombre de niveaux de caractéristiques de la FPN à utiliser. - hidden_act (
str, facultatif, par défautgelu) — 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éfaut1e-06) — L'épsilon utilisé par les couches de normalisation de couche. - initializer_range (
float, facultatif, par défaut0.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 EdgeTamModel. Elle est utilisée pour instancier un modèle Edgetam en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de yonigozlan/EdgeTAM-hf
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.
EdgeTamMaskDecoderConfig
classe transformers.EdgeTamMaskDecoderConfig
< source >( 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 = 256hidden_act: str = 'gelu'mlp_dim: int = 2048num_hidden_layers: int = 2num_attention_heads: int = 8attention_downsample_rate: int = 2num_multimask_outputs: int = 3iou_head_depth: int = 3iou_head_hidden_dim: int = 256dynamic_multimask_via_stability: bool = Truedynamic_multimask_stability_delta: float = 0.05dynamic_multimask_stability_thresh: float = 0.98 )
Paramètres
- hidden_size (
int, facultatif, par défaut256) — Dimension des représentations cachées. - hidden_act (
str, facultatif, par défautgelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - mlp_dim (
int, facultatif, valeur par défaut 2048) — La dimension du MLP dans le transformateur bidirectionnel. - num_hidden_layers (
int, facultatif, par défaut2) — Nombre de couches cachées dans le décodeur Transformer. - num_attention_heads (
int, facultatif, valeur par défaut8) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - attention_downsample_rate (
int, facultatif, valeur par défaut 2) — Le taux de sous-échantillonnage pour les couches d'attention. - num_multimask_outputs (
int, facultatif, valeur par défaut 3) — Le nombre de sorties multimask. - iou_head_depth (
int, facultatif, valeur par défaut 3) — La profondeur de la tête IoU. - iou_head_hidden_dim (
int, facultatif, valeur par défaut 256) — La dimension cachée de la tête IoU. - dynamic_multimask_via_stability (
bool, facultatif, valeur par défautTrue) — Indique s'il faut utiliser le multimask dynamique via la stabilité. - dynamic_multimask_stability_delta (
float, facultatif, valeur par défaut 0.05) — La stabilité delta pour le multimask dynamique. - dynamic_multimask_stability_thresh (
float, facultatif, valeur par défaut 0.98) — Seuil de stabilité pour le multimask dynamique.
Ceci est la classe de configuration destinée à stocker la configuration d'un EdgeTamModel. Elle est utilisée pour instancier un modèle Edgetam en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de yonigozlan/EdgeTAM-hf
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.
EdgeTamPromptEncoderConfig
classe transformers.EdgeTamPromptEncoderConfig
< source >( 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 = 256image_size: int | list[int] | tuple[int, int] = 1024patch_size: int | list[int] | tuple[int, int] = 16mask_input_channels: int = 16num_point_embeddings: int = 4hidden_act: str = 'gelu'layer_norm_eps: float = 1e-06scale: int = 1 )
Paramètres
- hidden_size (
int, facultatif, par défaut256) — Dimension des représentations cachées. - image_size (
Union[int, list[int], tuple[int, int]], facultatif, par défaut1024) — La taille (résolution) de chaque image. - patch_size (
Union[int, list[int], tuple[int, int]], facultatif, par défaut16) — La taille (résolution) de chaque patch. - mask_input_channels (
int, facultatif, valeur par défaut 16) — Le nombre de canaux à transmettre au moduleMaskDecoder. - num_point_embeddings (
int, facultatif, par défaut 4) — Le nombre d'embeddings de points à utiliser. - hidden_act (
str, facultatif, par défautgelu) — 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éfaut1e-06) — L'épsilon utilisé par les couches de normalisation de couche. - scale (
float, facultatif, valeur par défaut 1) — Le facteur d'échelle pour l'encodeur de prompt.
Ceci est la classe de configuration destinée à stocker la configuration d'un EdgeTamModel. Elle est utilisée pour instancier un modèle Edgetam en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de yonigozlan/EdgeTAM-hf
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.
EdgeTamVisionModel
classe transformers.EdgeTamVisionModel
< source >( config: EdgeTamVisionConfig )
Paramètres
- config (EdgeTamVisionConfig) — 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 d'EdgeTAM, 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
< source >( pixel_values: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )
EdgeTamModel
classe transformers.EdgeTamModel
< source >( config: EdgeTamConfig )
Paramètres
- config (EdgeTamConfig) — 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.
Segment Anything Model 2 (SAM 2) pour générer des masques de segmentation, à partir d'une image d'entrée et de points et étiquettes, boîtes ou masques d'entrée.
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
< source >( pixel_values: typing.Optional[torch.Tensor] = Noneinput_points: typing.Optional[torch.Tensor] = Noneinput_labels: typing.Optional[torch.LongTensor] = Noneinput_boxes: typing.Optional[torch.Tensor] = Noneinput_masks: typing.Optional[torch.LongTensor] = Noneimage_embeddings: typing.Optional[torch.Tensor] = Nonemultimask_output: bool = Trueattention_similarity: typing.Optional[torch.Tensor] = Nonetarget_embedding: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → EdgeTamImageSegmentationOutput or tuple(torch.Tensor)
Paramètres
- pixel_values (
torch.Tensorde 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 Sam2ImageProcessor. Voir Sam2ImageProcessor.call() pour plus de détails (Sam2Processor utilise Sam2ImageProcessor pour le traitement des images). - input_points (
torch.Tensorde forme(batch_size, num_points, 2)) — Points spatiaux 2D en entrée, utilisés par l’encodeur de prompt pour encoder le prompt. Produit généralement des résultats nettement meilleurs. Les points peuvent être obtenus en transmettant une liste de listes de listes au processeur, qui créera les tenseurstorchcorrespondants de dimension 4. La première dimension correspond à la taille du lot d’images, la deuxième à la taille du lot de points (c’est-à-dire le nombre de masques de segmentation que le modèle doit prédire par point d’entrée), la troisième au nombre de points par masque de segmentation (il est possible de transmettre plusieurs points pour un seul masque), et la dernière aux coordonnées x (verticale) et y (horizontale) du point. Si un nombre différent de points est transmis pour chaque image ou pour chaque masque, le processeur créera des points « PAD » correspondant à la coordonnée (0, 0), et le calcul de l’embedding sera ignoré pour ces points à l’aide des étiquettes. - input_labels (
torch.LongTensorde forme(batch_size, point_batch_size, num_points)) — Étiquettes d'entrée pour les points, utilisées par l'encodeur de prompt pour encoder le prompt. Selon l'implémentation officielle, il existe 3 types d'étiquettes1: le point est un point qui contient l'objet d'intérêt0: le point est un point qui ne contient pas l'objet d'intérêt-1: le point correspond à l'arrière-plan
Nous avons ajouté l'étiquette :
-10: le point est un point de bourrage, il doit donc être ignoré par l'encodeur de prompt
Les étiquettes de bourrage doivent être effectuées automatiquement par le processeur.
- input_boxes (
torch.Tensorde forme(batch_size, num_boxes, 4)) — Boîtes d'entrée pour les points, utilisées par l'encodeur de prompt pour encoder le prompt. Elles produisent généralement des masques générés bien meilleurs. Les boîtes peuvent être obtenues en passant une liste de listes de listes au processeur, qui génère untorchtenseur, où chaque dimension correspond respectivement à la taille du lot d'images, au nombre de boîtes par image et aux coordonnées du point en haut à gauche et du point en bas à droite de la boîte. Dans l'ordre (x1,y1,x2,y2):x1: la coordonnée x du point en haut à gauche de la boîte d'entréey1: la coordonnée y du point en haut à gauche de la boîte d'entréex2: la coordonnée x du point en bas à droite de la boîte d'entréey2: la coordonnée y du point en bas à droite de la boîte d'entrée
- input_masks (
torch.Tensorde forme(batch_size, image_size, image_size)) — Le modèle SAM accepte également des masques de segmentation en entrée. Le masque sera intégré par l’encodeur de prompt pour générer un embedding correspondant, qui sera ensuite transmis au décodeur de masque. Ces masques doivent être fournis manuellement par l’utilisateur et doivent être de forme (batch_size,image_size,image_size). - image_embeddings (
torch.Tensorde forme(batch_size, output_channels, window_size, window_size)) — Embeddings d’image, utilisés par le décodeur de masque pour générer les masques et les scores iou. Pour un calcul plus efficace en mémoire, les utilisateurs peuvent d’abord récupérer les embeddings d’image à l’aide de la méthodeget_image_embeddings, puis les transmettre à la méthodeforwardau lieu de transmettre lespixel_values. - multimask_output (
bool, facultatif) — Dans l’implémentation et l’article originaux, le modèle produit toujours 3 masques par image (ou par point / par boîte englobante le cas échéant). Il est toutefois possible de n’afficher qu’un seul masque, correspondant au meilleur masque, en spécifiantmultimask_output=False. - attention_similarity (
torch.Tensor, facultatif) — Tenseur de similarité d’attention, à fournir au décodeur de masque pour une attention guidée par la cible lorsque le modèle est utilisé pour la personnalisation, comme introduit dans PerSAM. - target_embedding (
torch.Tensor, facultatif) — Embedding du concept cible, à fournir au décodeur de masque pour le prompting sémantique de la cible dans le cas où le modèle est utilisé pour la personnalisation, comme introduit dans PerSAM.
Retourne
EdgeTamImageSegmentationOutput ou tuple(torch.Tensor)
Un EdgeTamImageSegmentationOutput 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 (EdgeTamConfig) et des entrées.
La méthode forward du modèle EdgeTamModel 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
Moduleplutô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.
- iou_scores (
torch.Tensorde forme(batch_size, point_batch_size, num_masks)) — Les scores d'Intersection sur Union (IoU) des masques prédits. - pred_masks (
torch.Tensorde forme(batch_size, point_batch_size, num_masks, height, width)) — Les masques basse résolution prédits. C'est un alias delow_res_masks. Ces masques doivent être post-traités par le processeur pour être ramenés à la taille de l'image d'origine. - object_score_logits (
torch.Tensorde forme(batch_size, point_batch_size, 1)) — Logits du score d'objet, indiquant si un objet est présent. - image_embeddings (
tuple(torch.Tensor)) — Les caractéristiques issues du FPN, utilisées par le décodeur de masque. Il s’agit d’un tuple detorch.Tensoroù chaque tenseur a la forme(batch_size, channels, height, width). - vision_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie de chaque étape) de forme(batch_size, height, width, hidden_size). États cachés du modèle de vision à la sortie de chaque étape. - vision_attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length). Poids d'attention du modèle de vision. - mask_decoder_attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length). Poids d'attention 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("danelcsb/edgetam.1_hiera_tiny")
>>> processor = AutoProcessor.from_pretrained("danelcsb/edgetam.1_hiera_tiny")
>>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/sam-car.png"
>>> with httpx.stream("GET", url) as response:
... raw_image = Image.open(BytesIO(response.read())).convert("RGB")
>>> input_points = [[[400, 650]]] # 2D location of a window on the car
>>> inputs = processor(images=raw_image, input_points=input_points, return_tensors="pt")
>>> # Get segmentation mask
>>> outputs = model(**inputs)
>>> # Postprocess masks
>>> masks = processor.post_process_masks(
... outputs.pred_masks, inputs["original_sizes"]
... )get_image_features
< source >( pixel_values: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → EdgeTamVisionEncoderOutput or tuple(torch.Tensor)
Paramètres
- pixel_values (
torch.Tensor) — Valeurs de pixels d'entrée de forme(batch_size, num_channels, height, width).
Retourne
EdgeTamVisionEncoderOutput ou tuple(torch.Tensor)
Un EdgeTamVisionEncoderOutput 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 (EdgeTamConfig) et des entrées.
last_hidden_state (
torch.Tensorde forme(batch_size, height, width, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.pooler_output (
torch.Tensorde 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 par 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.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(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.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(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.
fpn_hidden_states (
tuple(torch.Tensor)) — Tuple detorch.Tensor(un pour chaque niveau de caractéristique, de la résolution la plus haute à la plus basse) de forme(batch_size, hidden_size, height, width). Cartes de caractéristiques issues du cou Feature Pyramid Network.fpn_position_encoding (
tuple(torch.Tensor)) — Tuple detorch.Tensor(un pour chaque niveau de caractéristiques, de la résolution la plus haute à la plus basse) de forme(batch_size, hidden_size, height, width). Encodages positionnels correspondant auxfpn_hidden_states.