Transformers documentation
SAM-HQ
Ce modèle a été publié dans les papiers HF le 2023-06-02 et ajouté à Hugging Face Transformers le 2025-04-28.
SAM-HQ
Aperçu
SAM-HQ (High-Quality Segment Anything Model) a été proposé dans Segment Anything in High Quality par Lei Ke, Mingqiao Ye, Martin Danelljan, Yifan Liu, Yu-Wing Tai, Chi-Keung Tang, Fisher Yu.
Le modèle est une amélioration du modèle SAM d’origine, qui génère des masques de segmentation de qualité nettement supérieure tout en conservant la conception promptable, l’efficacité et la généralisation zéro-shot d’origine de SAM.
SAM-HQ introduit plusieurs améliorations clés par rapport au modèle SAM original :
- Jeton de sortie de haute qualité : un jeton apprenable injecté dans le décodeur de masque de SAM pour une prédiction de masque de meilleure qualité
- Fusion de caractéristiques globales et locales : combine les caractéristiques issues de différentes étapes du modèle pour améliorer les détails du masque
- Données d'entraînement : Utilise un jeu de données soigneusement sélectionné de 44K masques de haute qualité au lieu de SA-1B
- Efficacité : n'ajoute que 0,5 % de paramètres supplémentaires tout en améliorant considérablement la qualité du masque
- Capacité en zéro-shot : Maintient les excellentes performances en zéro-shot de SAM tout en améliorant la précision
L'abstract de l'article est le suivant :
Le récent Segment Anything Model (SAM) représente un grand pas en avant dans le passage à l’échelle des modèles de segmentation, offrant de puissantes capacités en zéro tirage et un promptage flexible. Bien qu’il ait été entraîné sur 1,1 milliard de masques, la qualité de prédiction des masques de SAM reste insuffisante dans de nombreux cas, en particulier lorsqu’il s’agit d’objets aux structures complexes. Nous proposons HQ-SAM, qui dote SAM de la capacité à segmenter précisément n’importe quel objet, tout en conservant la conception promptable, l’efficacité et la généralisabilité en zéro tirage d’origine de SAM. Notre conception soignée réutilise et préserve les poids du modèle pré-entraîné de SAM, n’ajoutant que des paramètres et des calculs minimaux. Nous concevons un jeton de sortie de haute qualité apprenable, injecté dans le décodeur de masques de SAM et chargé de prédire le masque de haute qualité. Plutôt que de l’appliquer uniquement aux caractéristiques du décodeur de masques, nous les fusionnons d’abord avec les caractéristiques précoces et finales du ViT pour améliorer les détails du masque. Pour entraîner les paramètres apprenables introduits, nous composons un jeu de données de 44 000 masques fins à partir de plusieurs sources. HQ-SAM n’est entraîné que sur le jeu de données de 44 000 masques introduit, ce qui ne prend que 4 heures sur 8 GPU.
Astuces :
- SAM-HQ génère des masques de meilleure qualité que le modèle SAM original, en particulier pour les objets aux structures complexes et aux détails fins
- Le modèle prédit des masques binaires avec des contours plus précis et un meilleur traitement des structures fines
- Comme SAM, le modèle obtient de meilleurs résultats avec des points 2D en entrée et/ou des boîtes englobantes en entrée
- Vous pouvez indiquer plusieurs points pour la même image et prédire un seul masque de haute qualité
- Le modèle conserve les capacités de généralisation en zéro tir de SAM
- SAM-HQ n'ajoute que ~0,5 % de paramètres supplémentaires par rapport à SAM
- Le fine-tuning du modèle n'est pas encore pris en charge
Ce modèle a été contribué par sushmanth. Le code d'origine peut être trouvé ici.
Voici un exemple montrant comment exécuter la génération de masques à partir d'une image et d'un point 2D :
import requests
import torch
from PIL import Image
from transformers import SamHQModel, SamHQProcessor
model = SamHQModel.from_pretrained("syscv-community/sam-hq-vit-base", device_map="auto")
processor = SamHQProcessor.from_pretrained("syscv-community/sam-hq-vit-base")
img_url = "https://huggingface.co/ybelkada/segment-anything/resolve/main/assets/car.png"
raw_image = Image.open(requests.get(img_url, stream=True).raw).convert("RGB")
input_points = [[[450, 600]]] # 2D location of a window in the image
inputs = processor(raw_image, input_points=input_points, return_tensors="pt").to(model.device)
with torch.no_grad():
outputs = model(**inputs)
masks = processor.image_processor.post_process_masks(
outputs.pred_masks.cpu(), inputs["original_sizes"].cpu(), inputs["reshaped_input_sizes"].cpu()
)
scores = outputs.iou_scoresVous pouvez également traiter vos propres masques en parallèle des images d’entrée dans le processeur, afin de les transmettre au modèle :
import requests
import torch
from PIL import Image
from transformers import SamHQModel, SamHQProcessor
model = SamHQModel.from_pretrained("syscv-community/sam-hq-vit-base", device_map="auto")
processor = SamHQProcessor.from_pretrained("syscv-community/sam-hq-vit-base")
img_url = "https://huggingface.co/ybelkada/segment-anything/resolve/main/assets/car.png"
raw_image = Image.open(requests.get(img_url, stream=True).raw).convert("RGB")
mask_url = "https://huggingface.co/ybelkada/segment-anything/resolve/main/assets/car.png"
segmentation_map = Image.open(requests.get(mask_url, stream=True).raw).convert("1")
input_points = [[[450, 600]]] # 2D location of a window in the image
inputs = processor(raw_image, input_points=input_points, segmentation_maps=segmentation_map, return_tensors="pt").to(model.device)
with torch.no_grad():
outputs = model(**inputs)
masks = processor.image_processor.post_process_masks(
outputs.pred_masks.cpu(), inputs["original_sizes"].cpu(), inputs["reshaped_input_sizes"].cpu()
)
scores = outputs.iou_scoresRessources
Une liste de ressources officielles Hugging Face et de la communauté (indiquées par 🌎) pour vous aider à démarrer avec SAM-HQ :
- Cahier de démonstration pour l'utilisation du modèle (bientôt disponible)
- Implémentation de l'article et code : Dépôt GitHub SAM-HQ
SamHQConfig
classe transformers.SamHQConfig
< 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.02tie_word_embeddings: bool = True )
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,SamHQPromptEncoderConfig], facultatif) — Dictionnaire des options de configuration utilisées pour initialiser SamHQPromptEncoderConfig. - mask_decoder_config (Union[
dict,SamHQMaskDecoderConfig], facultatif) — Dictionnaire des options de configuration utilisées pour initialiser SamHQMaskDecoderConfig. - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - tie_word_embeddings (
bool, facultatif, par défautTrue) — Indique s'il faut lier les embeddings de poids selon la correspondancetied_weights_keysdu modèle.
Ceci est la classe de configuration destinée à stocker la configuration d'un SamHQModel. Elle est utilisée pour instancier un modèle Sam Hq 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 syscv-community/sam-hq-vit-base
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.
SamHQVisionConfig
classe transformers.SamHQVisionConfig
< 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 = 768output_channels: int = 256num_hidden_layers: int = 12num_attention_heads: int = 12num_channels: int = 3image_size: int | list[int] | tuple[int, int] = 1024patch_size: int | list[int] | tuple[int, int] = 16hidden_act: str = 'gelu'layer_norm_eps: float = 1e-06attention_dropout: float | int = 0.0initializer_range: float = 1e-10qkv_bias: bool = Truemlp_ratio: float = 4.0use_abs_pos: bool = Trueuse_rel_pos: bool = Truewindow_size: int = 14global_attn_indexes: list[int] | tuple[int, ...] = (2, 5, 8, 11)num_pos_feats: int = 128mlp_dim: int | None = None )
Paramètres
- hidden_size (
int, facultatif, par défaut768) — Dimension des représentations cachées. - output_channels (
int, facultatif, par défaut 256) — Dimensionnalité des canaux de sortie dans le Patch Encoder. - num_hidden_layers (
int, facultatif, par défaut12) — Nombre de couches cachées dans le décodeur Transformer. - num_attention_heads (
int, facultatif, valeur par défaut12) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - num_channels (
int, facultatif, par défaut3) — Le nombre de canaux d'entrée. - 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. - 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. - attention_dropout (
Union[float, int], facultatif, valeur par défaut0.0) — Le taux de dropout appliqué aux probabilités d'attention. - initializer_range (
float, facultatif, par défaut1e-10) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids. - qkv_bias (
bool, facultatif, par défautTrue) — Indique s'il faut ajouter un biais aux requêtes, clés et valeurs. - mlp_ratio (
float, facultatif, par défaut4.0) — Ratio de la dimension cachée du MLP par rapport à la dimension d'embedding. - use_abs_pos (
bool, facultatif, par défautTrue) — Indique s'il faut utiliser des embeddings de position absolue. - use_rel_pos (
bool, facultatif, par défautTrue) — Indique s'il faut utiliser l'incorporation de position relative. - window_size (
int, facultatif, valeur par défaut 14) — Taille de la fenêtre pour la position relative. - global_attn_indexes (
list[int], facultatif, par défaut[2, 5, 8, 11]) — Les index des couches d'attention globale. - num_pos_feats (
int, facultatif, valeur par défaut : 128) — La dimension de l’incorporation de position. - mlp_dim (
int, facultatif) — La dimension de la couche MLP dans l'encodeur Transformer. SiNone, la valeur par défaut estmlp_ratio * hidden_size.
Ceci est la classe de configuration destinée à stocker la configuration d'un SamHQModel. Elle est utilisée pour instancier un modèle Sam Hq 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 syscv-community/sam-hq-vit-base
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 (
... SamHQVisionConfig,
... SamHQVisionModel,
... )
>>> # Initializing a SamHQVisionConfig with `"facebook/sam_hq-vit-huge"` style configuration
>>> configuration = SamHQVisionConfig()
>>> # Initializing a SamHQVisionModel (with random weights) from the `"facebook/sam_hq-vit-huge"` style configuration
>>> model = SamHQVisionModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configSamHQMaskDecoderConfig
classe transformers.SamHQMaskDecoderConfig
< 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 = 'relu'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 = 256layer_norm_eps: float = 1e-06vit_dim: int = 768 )
Paramètres
- hidden_size (
int, facultatif, par défaut256) — Dimension des représentations cachées. - hidden_act (
str, facultatif, par défautrelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple,"gelu","relu","silu", etc. - mlp_dim (
int, facultatif, valeur par défaut 2048) — Dimension de la couche « intermédiaire » (c.-à-d. à propagation avant) de l’encodeur Transformer. - 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) — Taux de sous-échantillonnage de la couche d'attention. - num_multimask_outputs (
int, facultatif, valeur par défaut 3) — Le nombre de sorties du moduleSamMaskDecoder. Dans l’article Segment Anything, cette valeur est fixée à 3. - iou_head_depth (
int, facultatif, valeur par défaut : 3) — Le nombre de couches du module de tête IoU. - iou_head_hidden_dim (
int, facultatif, valeur par défaut 256) — La dimension des états cachés dans le module de tête IoU. - layer_norm_eps (
float, facultatif, valeur par défaut1e-06) — L'épsilon utilisé par les couches de normalisation de couche. - vit_dim (
int, facultatif, par défaut 768) — Dimensionnalité du Vision Transformer (ViT) utilisé dans le moduleSamHQMaskDecoder.
Ceci est la classe de configuration destinée à stocker la configuration d'un SamHQModel. Elle est utilisée pour instancier un modèle Sam Hq 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 syscv-community/sam-hq-vit-base
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.
SamHQPromptEncoderConfig
classe transformers.SamHQPromptEncoderConfig
< 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-06 )
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.
Ceci est la classe de configuration destinée à stocker la configuration d'un SamHQModel. Elle est utilisée pour instancier un modèle Sam Hq 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 syscv-community/sam-hq-vit-base
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.
SamHQProcessor
classe transformers.SamHQProcessor
< source >( image_processor )
Construit un SamHQProcessor qui encapsule un processeur d'image dans un processeur unique.
SamHQProcessor propose toutes les fonctionnalités de SamImageProcessor. Consultez ~SamImageProcessor pour plus d’informations.
__call__
< source >( images: 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.sam_hq.processing_sam_hq.SamHQProcessorKwargs'> ) → ~feature_extraction_utils.BatchFeature
Paramètres
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], facultatif) — 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éfinissezdo_rescale=False. - segmentation_maps (
ImageInput, kwargs, facultatif) — Cartes de segmentation de référence à traiter avec les images d'entrée. Ces cartes sont utilisées à des fins d'entraînement ou d'évaluation et sont redimensionnées et normalisées pour correspondre aux dimensions des images traitées. - input_points (
NestedList, kwargs, facultatif) — Points d'entrée pour la segmentation basée sur des prompts. Doit être une liste imbriquée avec la structure[image_level, object_level, point_level, [x, y]]où chaque point est spécifié par des coordonnées[x, y]dans l'espace de l'image d'origine. Les points sont normalisés à la taille de l'image cible avant d'être transmis au modèle. - input_labels (
NestedList, kwargs, facultatif) — Étiquettes des points d'entrée, indiquant si chaque point est un point au premier plan (1) ou en arrière-plan (0). Doit être une liste imbriquée avec la structure[image_level, object_level, point_level]. Doit avoir la même structure queinput_points(à l'exception de la dimension des coordonnées). - input_boxes (
NestedList, kwargs, facultatif) — Boîtes englobantes pour la segmentation basée sur des invites. Doit être une liste imbriquée de structure[image_level, box_level, [x1, y1, x2, y2]]où chaque boîte est spécifiée par les coordonnées[x1, y1, x2, y2]dans l'espace de l'image d'origine. Les boîtes sont normalisées à la taille de l'image cible avant d'être transmises au modèle. - point_pad_value (
int, kwargs, facultatif, valeur par défautNone) — La valeur utilisée pour rembourdir les points d'entrée lors du groupement de séquences de longueurs différentes. Cette valeur marque les positions rembourdies et est conservée lors de la normalisation des coordonnées afin de distinguer les points réels du rembourdissage. SiNone, la valeur de rembourdissage par défaut de la configuration du processeur est utilisée. - mask_size (
dict[str, *kwargs*, int], facultatif) — Dictionnaire spécifiant la taille cible du masque, avec les clés"height"et"width". Cela détermine la résolution des masques de segmentation de sortie générés par le modèle. - mask_pad_size (
dict[str, *kwargs*, int], facultatif) — Dictionnaire spécifiant la taille du bourrage pour les masques, avec les clés"height"et"width". Il est utilisé lors du groupement de masques de tailles différentes afin de garantir des dimensions cohérentes. - return_tensors (
strou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :'pt': Renvoie des objetstorch.Tensorde PyTorch.'np': Renvoie des objets NumPynp.ndarray.
- **kwargs (ProcessingKwargs, facultatif) — Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge.
Retourne
~feature_extraction_utils.BatchFeature
- data (
dict, facultatif) — Dictionnaire de listes/tableaux/tenseurs renvoyé par les méthodes call/pad (« input_values », « attention_mask », 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. - skip_tensor_conversion (
list[str]ouset[str], facultatif) — Liste ou ensemble de clés qui ne doivent PAS être converties en tenseurs, même sitensor_typeest spécifié.
SamHQVisionModel
classe transformers.SamHQVisionModel
< source >( config: SamHQVisionConfig )
Paramètres
- config (SamHQVisionConfig) — 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 SamHQ, sans aucune tête ni projection au-dessus.
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'> ) → SamHQVisionEncoderOutput 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 SamImageProcessor. Voir SamImageProcessor.call() pour plus de détails (SamHQProcessor utilise SamImageProcessor pour le traitement des images).
Retourne
SamHQVisionEncoderOutput ou tuple(torch.Tensor)
Un SamHQVisionEncoderOutput 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 (SamHQConfig) et des entrées.
La méthode forward du modèle SamHQVisionModel 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.
image_embeds (
torch.Tensorde forme(batch_size, output_dim)facultatif renvoyé lorsque le modèle est initialisé avecwith_projection=True) — Les embeddings d’image obtenus en appliquant la couche de projection au pooler_output.last_hidden_state (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche du modèle.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.
intermediate_embeddings (
list(torch.Tensor), facultatif) — Une liste d'embeddings intermédiaires collectés à partir de certains blocs du modèle, généralement ceux sans attention fenêtrée. Chaque élément de la liste a la forme(batch_size, sequence_length, hidden_size). Ceci est spécifique à SAM-HQ et n'est pas présent dans SAM de base.
SamHQModel
classe transformers.SamHQModel
< source >( config: SamHQConfig )
Paramètres
- config (SamHQConfig) — 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 HQ (SAM-HQ) pour générer des masques, à partir d'une image d'entrée et de localisations 2D et de boîtes englobantes facultatives.
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 = Truehq_token_only: bool = Falseattention_similarity: typing.Optional[torch.Tensor] = Nonetarget_embedding: typing.Optional[torch.Tensor] = Noneintermediate_embeddings: list[torch.Tensor] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )
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 SamImageProcessor. Voir SamImageProcessor.call() pour plus de détails (SamHQProcessor utilise SamImageProcessor 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_HQ 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. - hq_token_only (
bool, facultatif, valeur par défautFalse) — Indique s'il faut utiliser uniquement le chemin du jeton HQ pour la génération du masque. Si la valeur est False, les chemins standard et HQ sont combinés. Ceci est spécifique à l'architecture de SAM-HQ. - 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. - intermediate_embeddings (
List[torch.Tensor], facultatif) — Embeddings intermédiaires issus des blocs non fenêtrés de l’encodeur visuel, utilisés par SAM-HQ pour améliorer la qualité des masques. Obligatoire lors de la fourniture d’image_embeddings précalculées à la place de pixel_values.
La méthode forward de SamHQModel 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.
Exemple :
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import AutoModel, AutoProcessor
>>> model = AutoModel.from_pretrained("sushmanth/sam_hq_vit_b")
>>> processor = AutoProcessor.from_pretrained("sushmanth/sam_hq_vit_b")
>>> 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")
>>> input_points = [[[400, 650]]] # 2D location of a window on the car
>>> inputs = processor(images=image, input_points=input_points, return_tensors="pt")
>>> # Get high-quality segmentation mask
>>> outputs = model(**inputs)
>>> # For high-quality mask only
>>> outputs = model(**inputs, hq_token_only=True)
>>> # Postprocess masks
>>> masks = processor.post_process_masks(
... outputs.pred_masks, inputs["original_sizes"], inputs["reshaped_input_sizes"]
... )