Hugging Face's logo

Transformers documentation

MM Grounding DINO

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

and get access to the augmented documentation experience

to get started

Ce modèle a été publié dans HF papers le 2024-01-04 et contribué à Hugging Face Transformers le 2025-08-01.

MM Grounding DINO

Le modèle MM Grounding DINO a été proposé dans An Open and Comprehensive Pipeline for Unified Object Grounding and Detection par Xiangyu Zhao, Yicheng Chen, Shilin Xu, Xiangtai Li, Xinjiang Wang, Yining Li, Haian Huang.

MM Grounding DINO améliore le Grounding DINO en optimisant la tête de classe contrastive et en supprimant le partage de paramètres dans le décodeur, ce qui améliore les performances de détection zero-shot sur COCO (50,6 (+2,2) AP) et LVIS (31,9 (+11,8) val AP et 41,4 (+12,6) minival AP).

Vous pouvez trouver tous les points de contrôle originaux de MM Grounding DINO dans la collection MM Grounding DINO. Ce modèle prend également en charge l'inférence LLMDet. Vous pouvez trouver les points de contrôle LLMDet dans la collection LLMDet.

Cliquez sur les modèles MM Grounding DINO dans la barre latérale droite pour plus d’exemples sur la façon d’appliquer MM Grounding DINO à différentes tâches MM Grounding DINO.

L'exemple ci-dessous montre comment générer du texte à partir d'une image avec la classe AutoModelForZeroShotObjectDetection.

AutoModel
import torch

from transformers import AutoModelForZeroShotObjectDetection, AutoProcessor
from transformers.image_utils import load_image


# Prepare processor and model
model_id = "openmmlab-community/mm_grounding_dino_tiny_o365v1_goldg_v3det"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForZeroShotObjectDetection.from_pretrained(model_id, device_map="auto")

# Prepare inputs
image_url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = load_image(image_url)
text_labels = [["a cat", "a remote control"]]
inputs = processor(images=image, text=text_labels, return_tensors="pt").to(model.device)

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

# Postprocess outputs
results = processor.post_process_grounded_object_detection(
    outputs,
    threshold=0.4,
    target_sizes=[(image.height, image.width)]
)

# Retrieve the first image result
result = results[0]
for box, score, labels in zip(result["boxes"], result["scores"], result["labels"]):
    box = [round(x, 2) for x in box.tolist()]
    print(f"Detected {labels} with confidence {round(score.item(), 3)} at location {box}")

Notes

MMGroundingDinoConfig

classe transformers.MMGroundingDinoConfig

< >

( 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 = 0id2label: 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 = Noneis_encoder_decoder: bool = Truebackbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonenum_queries: int = 900encoder_layers: int = 6encoder_ffn_dim: int = 2048encoder_attention_heads: int = 8decoder_layers: int = 6decoder_ffn_dim: int = 2048decoder_attention_heads: int = 8activation_function: str = 'relu'd_model: int = 256dropout: float | int = 0.1attention_dropout: float | int = 0.0activation_dropout: float | int = 0.0auxiliary_loss: bool = Falseposition_embedding_type: str = 'sine'num_feature_levels: int = 4encoder_n_points: int = 4decoder_n_points: int = 4two_stage: bool = Trueclass_cost: float = 1.0bbox_cost: float = 5.0giou_cost: float = 2.0bbox_loss_coefficient: float = 5.0giou_loss_coefficient: float = 2.0focal_alpha: float = 0.25disable_custom_kernels: bool = Falsemax_text_len: int = 256text_enhancer_dropout: float | int = 0.0fusion_droppath: float | int = 0.1fusion_dropout: float | int = 0.0embedding_init_target: bool = Truequery_dim: int = 4positional_embedding_temperature: int = 20decoder_bbox_embed_share: bool = Truedecoder_cls_embed_share: bool = Trueinit_std: float = 0.02layer_norm_eps: float = 1e-05tie_word_embeddings: bool = True )

Paramètres

  • is_encoder_decoder (bool, facultatif, valeur par défaut True) — Indique si le modèle est utilisé comme encodeur/décodeur ou non.
  • backbone_config (Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — La configuration du modèle backbone.
  • text_config (Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone de texte.
  • num_queries (int, facultatif, valeur par défaut 900) — Nombre de requêtes d’objets, c’est-à-dire de slots de détection. C’est le nombre maximal d’objets que MMGroundingDinoModel peut détecter dans une image unique.
  • encoder_layers (int, facultatif, valeur par défaut 6) — Nombre de couches cachées dans l'encodeur Transformer. Utilise la même valeur que num_layers si non défini.
  • encoder_ffn_dim (int, facultatif, valeur par défaut 2048) — Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) de l’encodeur.
  • encoder_attention_heads (int, facultatif, valeur par défaut 8) — Nombre de têtes d'attention pour chaque couche d'attention dans l'encodeur Transformer.
  • decoder_layers (int, facultatif, valeur par défaut 6) — Nombre de couches cachées dans le décodeur Transformer. Utilise la même valeur que num_layers si non défini.
  • decoder_ffn_dim (int, facultatif, valeur par défaut 2048) — Dimension de la couche « intermédiaire » (souvent appelée couche feed-forward) du décodeur.
  • decoder_attention_heads (int, facultatif, valeur par défaut 8) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
  • activation_function (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.
  • d_model (int, facultatif, par défaut 256) — Taille des couches encodeur et de la couche pooler.
  • dropout (Union[float, int], facultatif, par défaut 0.1) — Le taux appliqué à toutes les couches de dropout.
  • attention_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Le taux de dropout appliqué aux probabilités d'attention.
  • activation_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Le taux de dropout appliqué aux activations à l'intérieur de la couche entièrement connectée.
  • auxiliary_loss (bool, facultatif, par défaut False) — Indique si les pertes de décodage auxiliaires (perte à chaque couche du décodeur) doivent être utilisées.
  • position_embedding_type (str, facultatif, par défaut "sine") — Type d'embeddings de position à utiliser au-dessus des caractéristiques de l'image. L'un des "sine" ou "learned".
  • num_feature_levels (int, facultatif, valeur par défaut 4) — Le nombre de niveaux de caractéristiques d'entrée.
  • encoder_n_points (int, facultatif, valeur par défaut 4) — Le nombre de clés échantillonnées à chaque niveau de fonction pour chaque tête d'attention dans l'encodeur.
  • decoder_n_points (int, facultatif, valeur par défaut 4) — Le nombre de clés échantillonnées à chaque niveau de fonctionnalités pour chaque tête d’attention du décodeur.
  • two_stage (bool, facultatif, par défaut True) — Indique s'il faut appliquer un DETR déformable en deux étapes, où les propositions de régions sont également générées par une variante de Grounding DINO, puis transmises au décodeur pour un raffinement itératif des boîtes englobantes.
  • class_cost (float, facultatif, par défaut 1.0) — Poids relatif de l'erreur de classification dans le coût d'appariement hongrois.
  • bbox_cost (float, facultatif, valeur par défaut 5.0) — Poids relatif de l'erreur de boîte englobante L1 dans le coût d'appariement hongrois.
  • giou_cost (float, facultatif, par défaut 2.0) — Poids relatif de la perte d'IoU généralisée dans le coût d'appariement hongrois.
  • bbox_loss_coefficient (float, facultatif, valeur par défaut 5.0) — Poids relatif de la perte L1 de la boîte englobante dans la perte de segmentation panoptique.
  • giou_loss_coefficient (float, facultatif, valeur par défaut 2.0) — Poids relatif de la perte d'IoU généralisée dans la perte de segmentation panoptique.
  • focal_alpha (float, facultatif, valeur par défaut 0.25) — Paramètre alpha de la focal loss.
  • disable_custom_kernels (bool, facultatif, valeur par défaut False) — Désactive l'utilisation des noyaux CUDA et CPU personnalisés. Cette option est nécessaire pour l'export ONNX, car les noyaux personnalisés ne sont pas pris en charge par l'export ONNX de PyTorch.
  • max_text_len (int, facultatif, valeur par défaut 256) — La longueur maximale de l'entrée texte.
  • text_enhancer_dropout (float, facultatif, valeur par défaut 0.0) — Le taux de dropout pour l'améliorateur de texte.
  • fusion_droppath (float, facultatif, valeur par défaut 0.1) — Le ratio de droppath pour le module de fusion.
  • fusion_dropout (float, facultatif, valeur par défaut 0.0) — Le taux de dropout pour le module de fusion.
  • embedding_init_target (bool, facultatif, par défaut True) — Indique s'il faut initialiser la cible avec les poids d'Embedding.
  • query_dim (int, facultatif, par défaut 4) — La dimension du vecteur de requête.
  • positional_embedding_temperature (float, facultatif, valeur par défaut 20) — La température pour l’incorporation positionnelle sinusoïdale utilisée avec l’architecture visuelle.
  • decoder_bbox_embed_share (bool, facultatif, valeur par défaut True) — Indique s'il faut partager la tête de régression des boîtes englobantes pour toutes les couches du décodeur.
  • decoder_cls_embed_share (bool, facultatif, valeur par défaut True) — Indique s'il faut partager la tête d'incorporation de classe pour toutes les couches du décodeur.
  • init_std (float, facultatif, valeur par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
  • layer_norm_eps (float, facultatif, valeur par défaut 1e-05) — L'épsilon utilisé par les couches de normalisation de couche.
  • tie_word_embeddings (bool, facultatif, par défaut True) — Indique s'il faut lier les embeddings de poids selon la correspondance tied_weights_keys du modèle.

Ceci est la classe de configuration destinée à stocker la configuration d'un modèle Mm Grounding Dino. Elle est utilisée pour instancier un modèle Mm Grounding Dino 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 openmmlab-community/mm_grounding_dino_tiny_o365v1_goldg_v3det

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.

Exemples :

>>> from transformers import MMGroundingDinoConfig, MMGroundingDinoModel

>>> # Initializing a MM Grounding DINO configuration
>>> configuration = MMGroundingDinoConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = MMGroundingDinoModel(configuration)

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

MMGroundingDinoModel

classe transformers.MMGroundingDinoModel

< >

( config: MMGroundingDinoConfig )

Paramètres

  • config (MMGroundingDinoConfig) — 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 Grounding DINO brut (composé d'un backbone et d'un Transformer encodeur-décodeur) 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: Tensorinput_ids: Tensortoken_type_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonepixel_mask: typing.Optional[torch.Tensor] = Noneencoder_outputs = Noneoutput_attentions = Noneoutput_hidden_states = Nonereturn_dict = None**kwargs ) → MMGroundingDinoModelOutput or tuple(torch.Tensor)

Paramètres

  • pixel_values (torch.Tensor de forme (batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide de GroundingDinoImageProcessor. Voir GroundingDinoImageProcessor.call() pour plus de détails (GroundingDinoProcessor utilise GroundingDinoImageProcessor pour le traitement des images).
  • input_ids (torch.LongTensor de forme (batch_size, text_sequence_length)) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut si vous le fournissez.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez BertTokenizer.call() pour plus de détails.

  • token_type_ids (torch.LongTensor de forme (batch_size, text_sequence_length), facultatif) — Indices de jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont choisis dans [0, 1]: 0 correspond à un jeton de sentence A , 1 correspond à un jeton de sentence B

    Qu'est-ce que les identifiants de type de jeton ?

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

  • pixel_mask (torch.Tensor de forme (batch_size, height, width), facultatif) — Masque pour éviter d'appliquer l'attention aux valeurs de pixels de bourrage. Les valeurs du masque sont comprises dans [0, 1]:
    • 1 pour les pixels réels (c.-à-d. non masqués),
    • 0 pour les pixels qui sont du bourrage (c.-à-d. masqués).

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

  • encoder_outputs (`) -- Tuple consists of (last_hidden_state, *optional*: hidden_states, *optional*: attentions) last_hidden_stateof shape(batch_size, sequence_length, hidden_size)`, optional) is a sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention of the decoder.
  • output_attentions (`) -- Whether or not to return the attentions tensors of all attention layers. See attentions` under returned tensors for more detail.
  • output_hidden_states (`) -- Whether or not to return the hidden states of all layers. See hidden_states` under returned tensors for more detail.
  • return_dict (“) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.

Retourne

MMGroundingDinoModelOutput ou tuple(torch.Tensor)

Un MMGroundingDinoModelOutput 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 (MMGroundingDinoConfig) et des entrées.

La méthode forward du modèle MMGroundingDinoModel surcharge la méthode spéciale __call__.

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

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

  • init_reference_points (torch.Tensor de forme (batch_size, num_queries, 4)) — Points de référence initiaux transmis au décodeur du Transformer.

  • intermediate_hidden_states (torch.Tensor de forme (batch_size, config.decoder_layers, num_queries, hidden_size)) — États cachés intermédiaires empilés (sortie de chaque couche du décodeur).

  • intermediate_reference_points (torch.Tensor de forme (batch_size, config.decoder_layers, num_queries, 4)) — Points de référence intermédiaires empilés (points de référence de chaque couche du décodeur).

  • decoder_hidden_states (tuple[torch.Tensor], facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.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 décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.

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

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

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

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

  • encoder_vision_hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings visuels + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size). États cachés de l'encodeur visuel à la sortie de chaque couche, ainsi que les sorties des embeddings initiaux.

  • encoder_text_hidden_states (tuple(torch.Tensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.Tensor (un pour la sortie des embeddings de texte + un pour la sortie de chaque couche) de forme (batch_size, sequence_length, hidden_size). États cachés de l'encodeur de texte à la sortie de chaque couche, ainsi que les sorties des embeddings initiaux.

  • encoder_attentions (tuple(tuple(torch.Tensor)), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de tuples de torch.Tensor (un pour l'attention de chaque 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'attention texte-vision, vision-texte, texte-enhancer (auto-attention) et attention déformable multi-échelle. attention softmax, used to compute the weighted average in the bi-attention heads.

  • enc_outputs_class (torch.Tensor de forme (batch_size, sequence_length, config.num_labels), facultatif, renvoyé lorsque config.two_stage=True) — Scores des boîtes englobantes prédites, où les config.num_queries boîtes englobantes ayant les scores les plus élevés sont sélectionnées comme propositions de régions à la première étape. Sortie de la classification binaire des boîtes englobantes (c.-à-d. premier plan et arrière-plan).

  • enc_outputs_coord_logits (torch.Tensor de forme (batch_size, sequence_length, 4), facultatif, renvoyé lorsque config.two_stage=True) — Logits des coordonnées des boîtes englobantes prédites à la première étape.

  • encoder_logits (torch.Tensor de forme (batch_size, sequence_length, config.num_labels), facultatif, renvoyé lorsque config.two_stage=True) — Logits des config.num_queries boîtes englobantes les mieux notées à la première étape.

  • encoder_pred_boxes (torch.Tensor de forme (batch_size, sequence_length, 4), facultatif, renvoyé lorsque config.two_stage=True) — Coordonnées des config.num_queries boîtes englobantes ayant le meilleur score à la première étape.

Exemples :

>>> from transformers import AutoProcessor, AutoModel
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))
>>> text = "a cat."

>>> processor = AutoProcessor.from_pretrained("IDEA-Research/grounding-dino-tiny")
>>> model = AutoModel.from_pretrained("IDEA-Research/grounding-dino-tiny")

>>> inputs = processor(images=image, text=text, return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 900, 256]

MMGroundingDinoForObjectDetection

classe transformers.MMGroundingDinoForObjectDetection

< >

( config: MMGroundingDinoConfig )

Paramètres

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

Modèle Grounding DINO (composé d'un backbone et d'un Transformer encodeur-décodeur) avec des têtes de détection d'objets au sommet, pour des tâches telles que la détection COCO.

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: Tensorinput_ids: LongTensortoken_type_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.LongTensor] = Nonepixel_mask: typing.Optional[torch.BoolTensor] = Noneencoder_outputs: transformers.models.mm_grounding_dino.modeling_mm_grounding_dino.MMGroundingDinoEncoderOutput | tuple | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = Nonelabels: list[dict[str, typing.Union[torch.LongTensor, torch.Tensor]]] | None = None**kwargs )

Paramètres

  • pixel_values (torch.Tensor de forme (batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide de GroundingDinoImageProcessor. Voir GroundingDinoImageProcessor.call() pour plus de détails (GroundingDinoProcessor utilise GroundingDinoImageProcessor pour le traitement des images).
  • input_ids (torch.LongTensor de forme (batch_size, text_sequence_length)) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut si vous le fournissez.

    Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez BertTokenizer.call() pour plus de détails.

  • token_type_ids (torch.LongTensor de forme (batch_size, text_sequence_length), facultatif) — Indices de jetons de segment pour indiquer les première et deuxième parties des entrées. Les indices sont choisis dans [0, 1]: 0 correspond à un jeton de sentence A , 1 correspond à un jeton de sentence B

    Qu'est-ce que les identifiants de type de jeton ?

  • attention_mask (torch.LongTensor 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 ?

  • pixel_mask (torch.BoolTensor de forme (batch_size, height, width), facultatif) — Masque pour éviter d'appliquer l'attention aux valeurs de pixels de bourrage. Les valeurs du masque sont comprises dans [0, 1]:
    • 1 pour les pixels réels (c.-à-d. non masqués),
    • 0 pour les pixels qui sont du bourrage (c.-à-d. masqués).

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

  • encoder_outputs (Union[~models.mm_grounding_dino.modeling_mm_grounding_dino.MMGroundingDinoEncoderOutput, tuple], facultatif) — Le tuple est composé de (last_hidden_state, facultatif : hidden_states, facultatif : attentions) last_hidden_state de forme (batch_size, sequence_length, hidden_size), facultatif) est une séquence d'états cachés à la sortie de la dernière couche de l'encodeur. Utilisé dans l'attention croisée du décodeur.
  • output_attentions (bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultez attentions sous les tenseurs retournés pour plus de détails.
  • output_hidden_states (bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voir hidden_states sous les tenseurs retournés pour plus de détails.
  • return_dict (bool, facultatif) — Indique s'il faut retourner un ModelOutput plutôt qu'un simple tuple.
  • labels (list[Dict] de longueur (batch_size,), facultatif) — Étiquettes pour le calcul de la perte de correspondance bipartite. Liste de dictionnaires, chaque dictionnaire contenant au moins les 2 clés suivantes : ‘class_labels’ et ‘boxes’ (les étiquettes de classes et les boîtes englobantes d’une image du lot, respectivement). Les étiquettes de classes elles-mêmes doivent être un torch.LongTensor de longueur (number of bounding boxes in the image,) et les boîtes un torch.Tensor de forme (number of bounding boxes in the image, 4).

La méthode forward de MMGroundingDinoForObjectDetection 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.

Exemples :

>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO

>>> import torch
>>> from PIL import Image
>>> from transformers import AutoProcessor, AutoModelForZeroShotObjectDetection

>>> model_id = "IDEA-Research/grounding-dino-tiny"
>>> device = "cuda"

>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = AutoModelForZeroShotObjectDetection.from_pretrained(model_id).to(device)

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))
>>> # Check for cats and remote controls
>>> text_labels = [["a cat", "a remote control"]]

>>> inputs = processor(images=image, text=text_labels, return_tensors="pt").to(device)
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> results = processor.post_process_grounded_object_detection(
...     outputs,
...     threshold=0.4,
...     text_threshold=0.3,
...     target_sizes=[(image.height, image.width)]
... )
>>> # Retrieve the first image result
>>> result = results[0]
>>> for box, score, text_label in zip(result["boxes"], result["scores"], result["text_labels"]):
...     box = [round(x, 2) for x in box.tolist()]
...     print(f"Detected {text_label} with confidence {round(score.item(), 3)} at location {box}")
Detected a cat with confidence 0.479 at location [344.7, 23.11, 637.18, 374.28]
Detected a cat with confidence 0.438 at location [12.27, 51.91, 316.86, 472.44]
Detected a remote control with confidence 0.478 at location [38.57, 70.0, 176.78, 118.18]
Update on GitHub

←mllama Molmo2→