# MM Grounding DINO Le modèle [MM Grounding DINO](https://huggingface.co/papers/2401.02361) a été proposé dans [An Open and Comprehensive Pipeline for Unified Object Grounding and Detection](https://huggingface.co/papers/2401.02361) par Xiangyu Zhao, Yicheng Chen, Shilin Xu, Xiangtai Li, Xinjiang Wang, Yining Li, Haian Huang. MM Grounding DINO améliore le [Grounding DINO](./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](https://huggingface.co/collections/openmmlab-community/mm-grounding-dino-688cbde05b814c4e2832f9df). Ce modèle prend également en charge l'inférence LLMDet. Vous pouvez trouver les points de contrôle LLMDet dans la collection [LLMDet](https://huggingface.co/collections/iSEE-Laboratory/llmdet-688475906dc235d5f1dc678e). > [!TIP] > 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](/docs/transformers/main/fr/model_doc/auto#transformers.AutoModelForZeroShotObjectDetection). ```python 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 - Voici un tableau des modèles et de leurs résultats de performance en détection d'objets sur COCO (résultats issus du [dépôt officiel](https://github.com/open-mmlab/mmdetection/blob/main/configs/mm_grounding_dino/README.md)) : | Modèle | Backbone | Données de pré-entraînement | Style | COCO mAP | | ------------------------------------------------------------------------------------------------------------------------------ | -------- | ------------------------ | --------- | ---------- | | [mm_grounding_dino_tiny_o365v1_goldg](https://huggingface.co/openmmlab-community/mm_grounding_dino_tiny_o365v1_goldg) | Swin-T | O365,GoldG | Zéro-shot | 50.4(+2.3) | | [mm_grounding_dino_tiny_o365v1_goldg_grit](https://huggingface.co/openmmlab-community/mm_grounding_dino_tiny_o365v1_goldg_grit) | Swin-T | O365,GoldG,GRIT | Zéro-shot | 50.5(+2.1) | | [mm_grounding_dino_tiny_o365v1_goldg_v3det](https://huggingface.co/openmmlab-community/mm_grounding_dino_tiny_o365v1_goldg_v3det) | Swin-T | O365,GoldG,V3Det | Zéro-shot | 50.6(+2.2) | | [mm_grounding_dino_tiny_o365v1_goldg_grit_v3det](https://huggingface.co/openmmlab-community/mm_grounding_dino_tiny_o365v1_goldg_grit_v3det) | Swin-T | O365,GoldG,GRIT,V3Det | Zéro-shot | 50.4(+2.0) | | [mm_grounding_dino_base_o365v1_goldg_v3det](https://huggingface.co/openmmlab-community/mm_grounding_dino_base_o365v1_goldg_v3det) | Swin-B | O365,GoldG,V3Det | Zéro-shot | 52.5 | | [mm_grounding_dino_base_all](https://huggingface.co/openmmlab-community/mm_grounding_dino_base_all) | Swin-B | O365,ALL | - | 59.5 | | [mm_grounding_dino_large_o365v2_oiv6_goldg](https://huggingface.co/openmmlab-community/mm_grounding_dino_large_o365v2_oiv6_goldg) | Swin-L | O365V2,OpenImageV6,GoldG | Zéro-shot | 53.0 | | [mm_grounding_dino_large_all](https://huggingface.co/openmmlab-community/mm_grounding_dino_large_all) | Swin-L | O365V2,OpenImageV6,ALL | - | 60.3 | - Voici un tableau des modèles MM Grounding DINO tiny et leurs performances de détection d'objets sur LVIS (résultats issus du [dépôt officiel](https://github.com/open-mmlab/mmdetection/blob/main/configs/mm_grounding_dino/README.md)) : | Modèle | Données de pré-entraînement | MiniVal APr | MiniVal APc | MiniVal APf | MiniVal AP | Val1.0 APr | Val1.0 APc | Val1.0 APf | Val1.0 AP | | ------------------------------------------------------------------------------------------------------------------------------ | --------------------- | ----------- | ----------- | ----------- | ----------- | ---------- | ---------- | ---------- | ----------- | | [mm_grounding_dino_tiny_o365v1_goldg](https://huggingface.co/openmmlab-community/mm_grounding_dino_tiny_o365v1_goldg) | O365,GoldG | 28.1 | 30.2 | 42.0 | 35.7(+6.9) | 17.1 | 22.4 | 36.5 | 27.0(+6.9) | | [mm_grounding_dino_tiny_o365v1_goldg_grit](https://huggingface.co/openmmlab-community/mm_grounding_dino_tiny_o365v1_goldg_grit) | O365,GoldG,GRIT | 26.6 | 32.4 | 41.8 | 36.5(+7.7) | 17.3 | 22.6 | 36.4 | 27.1(+7.0) | | [mm_grounding_dino_tiny_o365v1_goldg_v3det](https://huggingface.co/openmmlab-community/mm_grounding_dino_tiny_o365v1_goldg_v3det) | O365,GoldG,V3Det | 33.0 | 36.0 | 45.9 | 40.5(+11.7) | 21.5 | 25.5 | 40.2 | 30.6(+10.5) | | [mm_grounding_dino_tiny_o365v1_goldg_grit_v3det](https://huggingface.co/openmmlab-community/mm_grounding_dino_tiny_o365v1_goldg_grit_v3det) | O365,GoldG,GRIT,V3Det | 34.2 | 37.4 | 46.2 | 41.4(+12.6) | 23.6 | 27.6 | 40.5 | 31.9(+11.8) | - Cette prise en charge permet également l'inférence pour [LLMDet](https://github.com/iSEE-Laboratory/LLMDet). Voici un tableau des modèles LLMDet et de leurs performances sur LVIS (résultats issus du [dépôt officiel](https://github.com/iSEE-Laboratory/LLMDet)) : | Modèle | Données de pré-entraînement | MiniVal APr | MiniVal APc | MiniVal APf | MiniVal AP | Val1.0 APr | Val1.0 APc | Val1.0 APf | Val1.0 AP | | --------------------------------------------------------- | -------------------------------------------- | ------------ | ----------- | ----------- | ----------- | ---------- | ---------- | ---------- | ----------- | | [llmdet_tiny](https://huggingface.co/iSEE-Laboratory/llmdet_tiny) | (O365,GoldG,GRIT,V3Det) + GroundingCap-1M | 44.7 | 37.3 | 39.5 | 50.7 | 34.9 | 26.0 | 30.1 | 44.3 | | [llmdet_base](https://huggingface.co/iSEE-Laboratory/llmdet_base) | (O365,GoldG,V3Det) + GroundingCap-1M | 48.3 | 40.8 | 43.1 | 54.3 | 38.5 | 28.2 | 34.3 | 47.8 | | [llmdet_large](https://huggingface.co/iSEE-Laboratory/llmdet_large) | (O365V2,OpenImageV6,GoldG) + GroundingCap-1M | 51.1 | 45.1 | 46.1 | 56.6 | 42.0 | 31.6 | 38.8 | 50.2 | ## MMGroundingDinoConfig[[transformers.MMGroundingDinoConfig]] #### transformers.MMGroundingDinoConfig[[transformers.MMGroundingDinoConfig]] ```python transformers.MMGroundingDinoConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, is_encoder_decoder: bool = True, backbone_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, num_queries: int = 900, encoder_layers: int = 6, encoder_ffn_dim: int = 2048, encoder_attention_heads: int = 8, decoder_layers: int = 6, decoder_ffn_dim: int = 2048, decoder_attention_heads: int = 8, activation_function: str = 'relu', d_model: int = 256, dropout: float | int = 0.1, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, auxiliary_loss: bool = False, position_embedding_type: str = 'sine', num_feature_levels: int = 4, encoder_n_points: int = 4, decoder_n_points: int = 4, two_stage: bool = True, class_cost: float = 1.0, bbox_cost: float = 5.0, giou_cost: float = 2.0, bbox_loss_coefficient: float = 5.0, giou_loss_coefficient: float = 2.0, focal_alpha: float = 0.25, disable_custom_kernels: bool = False, max_text_len: int = 256, text_enhancer_dropout: float | int = 0.0, fusion_droppath: float | int = 0.1, fusion_dropout: float | int = 0.0, embedding_init_target: bool = True, query_dim: int = 4, positional_embedding_temperature: int = 20, decoder_bbox_embed_share: bool = True, decoder_cls_embed_share: bool = True, init_std: float = 0.02, layer_norm_eps: float = 1e-05, tie_word_embeddings: bool = True) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mm_grounding_dino/configuration_mm_grounding_dino.py#L29) **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 de base. 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](/docs/transformers/main/fr/model_doc/mm-grounding-dino#transformers.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) dans 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`) : Fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc. d_model (`int`, *facultatif*, par défaut `256`) : Taille des couches d'encodeur et de la couche pooler. dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Le ratio pour 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 pour les 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 sur les caractéristiques de l'image. Soit `"sine"` ou `"learned"`. num_feature_levels (`int`, *facultatif*, 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 caractéristique 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 fonction pour chaque tête d'attention dans le décodeur. two_stage (`bool`, *facultatif*, valeur 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*, valeur 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*, valeur 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 de boîte englobante L1 dans la perte de segmentation panoptique. giou_loss_coefficient (`float`, *facultatif*, valeur par défaut `2.0`) : Poids relatif de la perte 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 de 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*, valeur par défaut `True`) : Indique s'il faut initialiser la cible avec des 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 des Sine Positional Embedding utilisée avec le vision backbone. 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 (bbox) pour toutes les couches du décodeur. decoder_cls_embed_share (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut partager la tête d'embedding 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 l'initialisation de 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*, valeur 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, 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 [openmmlab-community/mm_grounding_dino_tiny_o365v1_goldg_v3det](https://huggingface.co/openmmlab-community/mm_grounding_dino_tiny_o365v1_goldg_v3det) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. Exemples : ```python >>> 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[[transformers.MMGroundingDinoModel]] #### transformers.MMGroundingDinoModel[[transformers.MMGroundingDinoModel]] ```python transformers.MMGroundingDinoModel(config: MMGroundingDinoConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mm_grounding_dino/modeling_mm_grounding_dino.py#L1787) **Paramètres :** config ([MMGroundingDinoConfig](/docs/transformers/main/fr/model_doc/mm-grounding-dino#transformers.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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.MMGroundingDinoModel.forward]] ```python forward(pixel_values: Tensor, input_ids: Tensor, token_type_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, pixel_mask: typing.Optional[torch.Tensor] = None, encoder_outputs = None, output_attentions = None, output_hidden_states = None, return_dict = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mm_grounding_dino/modeling_mm_grounding_dino.py#L1912) **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 des pixels peuvent être obtenues à l'aide de [GroundingDinoImageProcessor](/docs/transformers/main/fr/model_doc/grounding-dino#transformers.GroundingDinoImageProcessor). Voir [GroundingDinoImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([GroundingDinoProcessor](/docs/transformers/main/fr/model_doc/grounding-dino#transformers.GroundingDinoProcessor) utilise [GroundingDinoImageProcessor](/docs/transformers/main/fr/model_doc/grounding-dino#transformers.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 sera ignoré par défaut si vous le fournissez. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Voir [BertTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__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 sélectionnés dans `[0, 1]` : 0 correspond à un jeton de `sentence A`, 1 correspond à un jeton de `sentence B` [Que sont les identifiants de type de jeton ?](../glossary#token-type-ids) 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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) 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 de bourrage (c.-à-d. **masqués**). [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) encoder_outputs (``) : Tuple consists of (`last_hidden_state`, *optional*: `hidden_states`, *optional*: `attentions`) `last_hidden_state` of 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](/docs/transformers/main/fr/main_classes/output#transformers.utils.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 selon la configuration ([MMGroundingDinoConfig](/docs/transformers/main/fr/model_doc/mm-grounding-dino#transformers.MMGroundingDinoConfig)) et les entrées. La méthode forward du modèle [MMGroundingDinoModel](/docs/transformers/main/fr/model_doc/mm-grounding-dino#transformers.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. softmax d'attention, utilisé pour calculer la moyenne pondérée dans les têtes d'attention binaire. - **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 dans 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 les mieux notées de la première étape. Exemples : ```python >>> 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[[transformers.MMGroundingDinoForObjectDetection]] #### transformers.MMGroundingDinoForObjectDetection[[transformers.MMGroundingDinoForObjectDetection]] ```python transformers.MMGroundingDinoForObjectDetection(config: MMGroundingDinoConfig) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mm_grounding_dino/modeling_mm_grounding_dino.py#L2363) **Paramètres :** config ([MMGroundingDinoConfig](/docs/transformers/main/fr/model_doc/mm-grounding-dino#transformers.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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/fr/main_classes/model#transformers.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, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#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[[transformers.MMGroundingDinoForObjectDetection.forward]] ```python forward(pixel_values: Tensor, input_ids: LongTensor, token_type_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.LongTensor] = None, pixel_mask: typing.Optional[torch.BoolTensor] = None, encoder_outputs: transformers.models.mm_grounding_dino.modeling_mm_grounding_dino.MMGroundingDinoEncoderOutput | tuple | None = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, labels: list[dict[str, typing.Union[torch.LongTensor, torch.Tensor]]] | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mm_grounding_dino/modeling_mm_grounding_dino.py#L2404) **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 des pixels peuvent être obtenues à l'aide de [GroundingDinoImageProcessor](/docs/transformers/main/fr/model_doc/grounding-dino#transformers.GroundingDinoImageProcessor). Voir [GroundingDinoImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([GroundingDinoProcessor](/docs/transformers/main/fr/model_doc/grounding-dino#transformers.GroundingDinoProcessor) utilise [GroundingDinoImageProcessor](/docs/transformers/main/fr/model_doc/grounding-dino#transformers.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 sera ignoré par défaut si vous le fournissez. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Voir [BertTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__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 sélectionnés dans `[0, 1]` : 0 correspond à un jeton de `sentence A`, 1 correspond à un jeton de `sentence B` [Que sont les identifiants de type de jeton ?](../glossary#token-type-ids) 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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) 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'est-à-dire **non masqués**), - 0 pour les pixels de bourrage (c'est-à-dire **masqués**). [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) 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. Voir `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` dans les tenseurs retournés pour plus de détails. return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.utils.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](/docs/transformers/main/fr/model_doc/mm-grounding-dino#transformers.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 : ```python >>> 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] ```