# MiniCPM-V 4.7

[MiniCPM-V](https://huggingface.co/papers/2509.18154) est une série de grands modèles de langage multimodaux efficaces développés par [OpenBMB](https://github.com/OpenBMB). Tout comme [MiniCPM-V 4.6](./minicpmv4_6), l’architecture de MiniCPM-V 4.7 associe un encodeur visuel [SigLIP](./siglip) doté d’un mécanisme de fusion avec attention par fenêtres à un modèle de langage de base [Qwen3.5](./qwen3_5), et prend en charge les modes de sous-échantillonnage visuel 4x et 16x.

L’ajout principal par rapport à la version 4.6 est le *canvas M-RoPE* : au lieu de numéroter les jetons visuels le long d’une seule séquence 1-D, le modèle dispose chaque image sur un canevas 2-D et attribue à chaque jeton visuel une position `(temporal, height, width)`, de sorte que les tranches d’une même image conservent leur relation spatiale et que les images vidéo conservent leur ordre temporel.

Ce modèle a été contribué par [OpenBMB](https://huggingface.co/openbmb). Le code d’origine est disponible [ici](https://github.com/OpenBMB/MiniCPM-V).

> [!NOTE]
> Passer `use_image_id` à un processeur permet de numéroter plusieurs images dans un prompt afin que le texte puisse s’y référer individuellement. Cela ne s’applique qu’aux images : une vidéo est une séquence temporelle unique de frames plutôt que plusieurs visuels adressables, ce qui correspond à la façon dont le modèle a été entraîné, de sorte que ce paramètre est ignoré pour les entrées vidéo.

## Exemple d'utilisation

### Inférence avec Pipeline

```python
from transformers import pipeline

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "image",
                "image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg",
            },
            {"type": "text", "text": "Describe this image."},
        ],
    },
]

pipe = pipeline("image-text-to-text", model="openbmb/MiniCPM-V-4.7-1B")
outputs = pipe(text=messages, max_new_tokens=50, return_full_text=False)
outputs[0]["generated_text"]
```

### Inférence sur une image unique

```python
from transformers import AutoProcessor, AutoModelForImageTextToText

model_checkpoint = "openbmb/MiniCPM-V-4.7-1B"
processor = AutoProcessor.from_pretrained(model_checkpoint)
model = AutoModelForImageTextToText.from_pretrained(model_checkpoint, device_map="auto")

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
            {"type": "text", "text": "Describe this image."},
        ],
    }
]

inputs = processor.apply_chat_template(
    messages, add_generation_prompt=True, tokenize=True,
    return_dict=True, return_tensors="pt",
).to(model.device, dtype=model.dtype)

output = model.generate(**inputs, max_new_tokens=100)
decoded_output = processor.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True)
print(decoded_output)
```

### Mode de sous-échantillonnage

MiniCPM-V 4.7 prend en charge deux modes de sous-échantillonnage visuel :

- **16x** (par défaut) : sous-échantillonnage plus agressif, moins de jetons visuels, inférence plus rapide.
- **4x** : moins de sous-échantillonnage, plus de jetons visuels, mieux adapté aux tâches riches en détails.

Vous pouvez changer le mode de sous-échantillonnage à l'exécution en passant `downsample_mode` via `processor_kwargs` et à `model.generate` :

```python
inputs = processor.apply_chat_template(
    messages, add_generation_prompt=True, tokenize=True,
    return_dict=True, return_tensors="pt",
    processor_kwargs={"downsample_mode": "4x"},
).to(model.device, dtype=model.dtype)

output = model.generate(**inputs, max_new_tokens=100, downsample_mode="4x")
```

### Mode de réflexion

Le modèle prend en charge un mode de réflexion contrôlé par `enable_thinking` dans le modèle de discussion. Lorsqu'il est activé, le modèle génère un raisonnement interne avant de fournir la réponse finale :

```python
inputs = processor.apply_chat_template(
    messages, add_generation_prompt=True, tokenize=True,
    return_dict=True, return_tensors="pt",
    enable_thinking=True,
).to(model.device, dtype=model.dtype)

output = model.generate(**inputs, max_new_tokens=1024)
```

Pour désactiver la réflexion (par défaut pour l'évaluation) :

```python
inputs = processor.apply_chat_template(
    messages, add_generation_prompt=True, tokenize=True,
    return_dict=True, return_tensors="pt",
    enable_thinking=False,
).to(model.device, dtype=model.dtype)
```

### Inférence vidéo

MiniCPM-V 4.7 prend en charge la compréhension de vidéos.

```python
messages = [
    {
        "role": "user",
        "content": [
            {"type": "video", "video": "path/to/video.mp4"},
            {"type": "text", "text": "Describe what happens in this video."},
        ],
    }
]

inputs = processor.apply_chat_template(
    messages, add_generation_prompt=True, tokenize=True,
    return_dict=True, return_tensors="pt",
).to(model.device, dtype=model.dtype)

output = model.generate(**inputs, max_new_tokens=200)
decoded_output = processor.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True)
print(decoded_output)
```

## MiniCPMV4_7Config[[transformers.MiniCPMV4_7Config]]

#### transformers.MiniCPMV4_7Config[[transformers.MiniCPMV4_7Config]]

```python
transformers.MiniCPMV4_7Config(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, is_encoder_decoder: bool = False, 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, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, insert_layer_id: int = 6, image_size: int = 448, image_token_id: int | None = None, video_token_id: int | None = None, tie_word_embeddings: bool = False, downsample_mode: str = '16x', merge_kernel_size: tuple[int, int] | list[int] = (2, 2), merger_times: int = 1, image_start_id: int | None = None, image_end_id: int | None = None, slice_start_id: int | None = None, slice_end_id: int | None = None, newline_id: int | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_7/configuration_minicpmv4_7.py#L66)

**Paramètres :**

text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone de texte.

vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *facultatif*) : L'objet de configuration ou le dictionnaire du backbone visuel.

insert_layer_id (`int`, *facultatif*, valeur par défaut : 6) : Index de la couche de l'encodeur visuel après laquelle le fusionneur d'attention par fenêtre est appliqué.

image_size (`int`, *facultatif*, valeur par défaut `448`) : La taille (résolution) de chaque image.

image_token_id (`int`, *facultatif*) : L'index du jeton d'image utilisé comme espace réservé pour les images d'entrée.

video_token_id (`int`, *facultatif*) : L'index du jeton vidéo utilisé comme espace réservé pour les vidéos d'entrée.

tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle.

downsample_mode (`str`, *facultatif*, valeur par défaut `"16x"`) : Ratio de sous-échantillonnage des jetons visuels. `"4x"` conserve 4× plus de jetons.

merge_kernel_size (`tuple[int, int]`, *facultatif*, valeur par défaut `(2, 2)`) : Taille du noyau `(h, w)` pour fusionner les patches visuels adjacents dans le Merger.

merger_times (`int`, *facultatif*, valeur par défaut : 1) : Nombre de tours de fusion itératifs dans le Merger.

image_start_id (`int`, *facultatif*) : Identifiant du jeton du marqueur de début d'image (`<image>`). Canvas M-RoPE l'attache à l'halo juste à l'extérieur du coin supérieur gauche de la toile d'image. Résolu par le script de conversion à partir du tokenizer et stocké dans `config.json` ; requis pour les entrées image ou vidéo.

image_end_id (`int`, *facultatif*) : Identifiant du jeton de fin d'image (`</image>`). Canvas M-RoPE l'ancre au coin opposé de la toile d'image. Résolu par le script de conversion à partir du tokenizer et stocké dans `config.json` ; requis pour les entrées image ou vidéo.

slice_start_id (`int`, *facultatif*) : Identifiant du jeton du marqueur de début de tranche (`<slice>`). Canvas M-RoPE l'attache au coin supérieur gauche de la tranche qu'il ouvre. Résolu par le script de conversion à partir du tokenizer et stocké dans `config.json` ; requis pour les entrées image ou vidéo.

slice_end_id (`int`, *facultatif*) : Identifiant du jeton de fin de tranche (`</slice>`). Canvas M-RoPE l'attache au coin inférieur droit de la tranche qu'il ferme. Résolu par le script de conversion à partir du tokenizer et stocké dans `config.json` ; requis pour les entrées image ou vidéo.

newline_id (`int`, *facultatif*) : Identifiant du jeton de saut de ligne (`"\n"`) qui sépare les lignes de la trame. Canvas M-RoPE le fixe juste au-delà du bord droit de la ligne qu'il termine. Résolu par le script de conversion à partir du tokenizer et stocké dans `config.json` ; requis pour les entrées image ou vidéo.

Ceci est la classe de configuration destinée à stocker la configuration d'un MiniCPMV4_7Model. Elle est utilisée pour instancier un modèle Minicpmv4 7 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 [openbmb/MiniCPM-V-4.7-1B](https://huggingface.co/openbmb/MiniCPM-V-4.7-1B)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

## MiniCPMV4_7VisionConfig[[transformers.MiniCPMV4_7VisionConfig]]

#### transformers.MiniCPMV4_7VisionConfig[[transformers.MiniCPMV4_7VisionConfig]]

```python
transformers.MiniCPMV4_7VisionConfig(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, is_encoder_decoder: bool = False, 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, hidden_size: int = 768, intermediate_size: int = 3072, num_hidden_layers: int = 12, num_attention_heads: int = 12, num_channels: int = 3, image_size: int | list[int] | tuple[int, int] = 224, patch_size: int | list[int] | tuple[int, int] = 16, hidden_act: str = 'gelu_pytorch_tanh', layer_norm_eps: float = 1e-06, attention_dropout: float | int = 0.0, insert_layer_id: int = 6, window_kernel_size: tuple[int, int] | list[int] = (2, 2))
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_7/configuration_minicpmv4_7.py#L31)

**Paramètres :**

hidden_size (`int`, *facultatif*, par défaut `768`) : Dimension des représentations cachées.

intermediate_size (`int`, *facultatif*, par défaut `3072`) : Dimension des représentations MLP.

num_hidden_layers (`int`, *facultatif*, par défaut `12`) : Nombre de couches cachées dans le décodeur Transformer.

num_attention_heads (`int`, *facultatif*, valeur par défaut `12`) : Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.

num_channels (`int`, *facultatif*, par défaut `3`) : Le nombre de canaux d'entrée.

image_size (`Union[int, list[int], tuple[int, int]]`, *facultatif*, valeur par défaut `224`) : La taille (résolution) de chaque image.

patch_size (`Union[int, list[int], tuple[int, int]]`, *facultatif*, valeur par défaut `16`) : La taille (résolution) de chaque patch.

hidden_act (`str`, *facultatif*, par défaut `gelu_pytorch_tanh`) : 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*, par défaut `1e-06`) : L'épsilon utilisé par les couches de normalisation par couche.

attention_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention.

insert_layer_id (`int`, *facultatif*, valeur par défaut : 6) : Index de la couche de l'encodeur visuel après laquelle le fusionneur d'attention par fenêtre est appliqué.

window_kernel_size (`tuple[int, int]`, *facultatif*, valeur par défaut `(2, 2)`) : Taille de la fenêtre `(h, w)` pour le fusionneur d'attention par fenêtre intermédiaire.

Ceci est la classe de configuration destinée à stocker la configuration d'un MiniCPMV4_7Model. Elle est utilisée pour instancier un modèle Minicpmv4 7 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 [openbmb/MiniCPM-V-4.7-1B](https://huggingface.co/openbmb/MiniCPM-V-4.7-1B)

Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/v5.23.0/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/v5.23.0/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations.

## MiniCPMV4_7VisionPreTrainedModel.[[transformers.MiniCPMV4_7VisionPreTrainedModel]]

#### transformers.MiniCPMV4_7VisionPreTrainedModel[[transformers.MiniCPMV4_7VisionPreTrainedModel]]

```python
transformers.MiniCPMV4_7VisionPreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_7/modeling_minicpmv4_7.py#L401)

#### forward[[transformers.MiniCPMV4_7VisionPreTrainedModel.forward]]

```python
forward(*args, **kwargs)
```

Une valeur factice pour un chemin pointé (par ex. `torch.float32`) : les chaînes d'accès aux attributs et les appels se comportent comme des décorateurs de pass-through, `repr` est le chemin pointé, et son utilisation comme classe de base substitue une base de `type` ordinaire (PEP 560 `__mro_entries__`), de sorte que les vraies sous-classes conservent un métaclasse normal et que `inspect.signature` lit leur `__init__` réel plutôt que celui d'une valeur factice.

## MiniCPMV4_7VisionModel[[transformers.MiniCPMV4_7VisionModel]]

#### transformers.MiniCPMV4_7VisionModel[[transformers.MiniCPMV4_7VisionModel]]

```python
transformers.MiniCPMV4_7VisionModel(config: MiniCPMV4_7VisionConfig)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_7/modeling_minicpmv4_7.py#L415)

#### forward[[transformers.MiniCPMV4_7VisionModel.forward]]

```python
forward(pixel_values, target_sizes: typing.Optional[torch.IntTensor] = None, use_vit_merger: bool = True, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_7/modeling_minicpmv4_7.py#L447)

**Paramètres :**

pixel_values (`` of shape `(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 [MiniCPMV4_6ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_6#transformers.MiniCPMV4_6ImageProcessor). Consultez [MiniCPMV4_6ImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([MiniCPMV4_7Processor](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Processor) utilise [MiniCPMV4_6ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_6#transformers.MiniCPMV4_6ImageProcessor) pour le traitement des images).

target_sizes (`torch.IntTensor` de forme `(batch_size, 2)`, *facultatif*) : Tailles de la grille de patches `(h, w)` pour le calcul des embeddings de position.

use_vit_merger (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut appliquer le fusionneur d'attention par fenêtre ViT après l'encodeur.

**Retourne :** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 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 ([MiniCPMV4_7Config](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Config)) et les entrées.

La méthode forward du [MiniCPMV4_7VisionModel](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_7#transformers.MiniCPMV4_7VisionModel) redéfinit la méthode spéciale `__call__`.

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

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé 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 modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`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)`.

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

## MiniCPMV4_7Model[[transformers.MiniCPMV4_7Model]]

#### transformers.MiniCPMV4_7Model[[transformers.MiniCPMV4_7Model]]

```python
transformers.MiniCPMV4_7Model(config: MiniCPMV4_7Config)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_7/modeling_minicpmv4_7.py#L598)

**Paramètres :**

config ([MiniCPMV4_7Config](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Config)) : 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/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle MiniCPMV4_7, qui se compose d'un backbone visuel et d'un modèle de langage, sans tête de modélisation du langage.

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/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.MiniCPMV4_7Model.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, target_sizes: typing.Optional[torch.IntTensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, target_sizes_videos: typing.Optional[torch.IntTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: list[torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, downsample_mode: str | None = None, mm_token_type_ids: typing.Optional[torch.IntTensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_7/modeling_minicpmv4_7.py#L668)

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

pixel_values (`torch.Tensor`, *facultatif*) : Patchs de valeurs de pixels pour les images, formatés NaViT.

target_sizes (`torch.IntTensor`, *facultatif*) : Hauteur et largeur (en patches) pour chaque image.

pixel_values_videos (`torch.Tensor`, *facultatif*) : Patchs de valeurs de pixels pour les images vidéo, formatés NaViT.

target_sizes_videos (`torch.IntTensor`, *facultatif*) : Hauteur et largeur (en patches) de chaque image vidéo.

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)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

past_key_values (`list[torch.Tensor]`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`. Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut. Le modèle renverra le même format de cache que celui fourni en entrée. Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux dont les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

downsample_mode (`str`, *facultatif*) : `"4x"` conserve 4 fois plus de jetons visuels ; la valeur par défaut `"16x"` applique la fusion complète.

mm_token_type_ids (`torch.IntTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée correspondant à chaque modalité. Par exemple, texte (0), image (1), vidéo (2). Les identifiants de type de jeton multimodal peuvent être obtenus à l'aide de [AutoProcessor](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoProcessor). Consultez [ProcessorMixin.__call__()](/docs/transformers/v5.23.0/fr/main_classes/processors#transformers.ProcessorMixin.__call__) pour plus de détails.

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *facultatif*) : Dictionnaire dont les clés sont les modalités prises en charge et les valeurs sont les sorties encodées pour cette modalité. Chaque sortie encodée est un tuple composé de (`pooler_output`, *facultatif* : `last_hidden_states`, *facultatif* : `hidden_states`, *facultatif* : `attentions`) `pooler_output` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) est une séquence de fonctionnalités multimodales de l'encodeur fusionnées dans les embeddings de texte.

**Retourne :** [BaseModelOutputWithPast](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou `tuple(torch.Tensor)`

Un [BaseModelOutputWithPast](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) 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 ([MiniCPMV4_7Config](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Config)) et les entrées.

La méthode forward du modèle [MiniCPMV4_7Model](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Model) redéfinit la méthode spéciale `__call__`.

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

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

  Si `past_key_values` est utilisé, seule la dernière hidden-state des séquences de forme `(batch_size, 1, hidden_size)` est renvoyée.
- **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et, le cas échéant, si `config.is_encoder_decoder=True`, dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel.
- **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 modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`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)`.

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

#### get_image_features[[transformers.MiniCPMV4_7Model.get_image_features]]

```python
get_image_features(pixel_values: Tensor, target_sizes: IntTensor, downsample_mode: str | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_7/modeling_minicpmv4_7.py#L608)

**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 [MiniCPMV4_6ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_6#transformers.MiniCPMV4_6ImageProcessor). Voir [MiniCPMV4_6ImageProcessor.__call__()](/docs/transformers/v5.23.0/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails ([MiniCPMV4_7Processor](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Processor) utilise [MiniCPMV4_6ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_6#transformers.MiniCPMV4_6ImageProcessor) pour le traitement des images).

target_sizes (`torch.IntTensor` de forme `(num_images, 2)`) : Hauteur et largeur (en patches) de chaque image.

downsample_mode (`str`, *facultatif*) : lorsqu'il est défini sur `"4x"`, le `vit_merger` intermédiaire est ignoré, de sorte que chaque image conserve `4×` plus de jetons visuels. Le mode par défaut `"16x"` applique le pipeline de fusion complet.

**Retourne :** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 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 ([MiniCPMV4_7Config](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Config)) et les entrées.

Extraction des caractéristiques d'image : encodeur visuel, insert merger, puis MLP merger.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé 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 modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`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)`.

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

#### get_video_features[[transformers.MiniCPMV4_7Model.get_video_features]]

```python
get_video_features(pixel_values_videos: Tensor, target_sizes_videos: IntTensor, downsample_mode: str | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_7/modeling_minicpmv4_7.py#L762)

**Paramètres :**

pixel_values_videos (`torch.Tensor` de forme `(1, channels, patch_size, seq_len)`) : patches de pixels NaViT-packed pour toutes les images de la vidéo. Le processeur vidéo concatène les patches de chaque image le long de la dernière dimension pour former une seule séquence avec dim-0 = 1, identique au format d’empaquetage des images.

target_sizes_videos (`torch.IntTensor` de forme `(num_patches, 2)`) : Hauteur et largeur (en patches) de chaque unité visuelle.

downsample_mode (`str`, *facultatif*) : lorsqu'il est défini sur `"4x"`, le `vit_merger` intermédiaire est ignoré, de sorte que chaque image conserve `4×` plus de jetons visuels. Le mode par défaut `"16x"` applique le pipeline de fusion complet.

**Retourne :** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 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 ([MiniCPMV4_7Config](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Config)) et les entrées.

Extraction des caractéristiques vidéo : réempaqueter les images au format NaViT, puis encodeur visuel + fusionneur.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé 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 modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`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)`.

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

## MiniCPMV4_7ForConditionalGeneration[[transformers.MiniCPMV4_7ForConditionalGeneration]]

#### transformers.MiniCPMV4_7ForConditionalGeneration[[transformers.MiniCPMV4_7ForConditionalGeneration]]

```python
transformers.MiniCPMV4_7ForConditionalGeneration(config: MiniCPMV4_7Config)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_7/modeling_minicpmv4_7.py#L1213)

**Paramètres :**

config ([MiniCPMV4_7Config](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Config)) : 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/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle.

Le modèle Minicpmv4 7 pour la génération de jetons conditionnée sur d'autres modalités (par exemple, la génération texte-image-vers-texte).

Ce modèle hérite de [PreTrainedModel](/docs/transformers/v5.23.0/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.MiniCPMV4_7ForConditionalGeneration.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, target_sizes: typing.Optional[torch.IntTensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, target_sizes_videos: typing.Optional[torch.IntTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: list[torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, downsample_mode: str | None = None, mm_token_type_ids: typing.Optional[torch.IntTensor] = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_7/modeling_minicpmv4_7.py#L1224)

**Paramètres :**

input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/v5.23.0/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids)

pixel_values (`torch.Tensor`, *facultatif*) : Patchs de valeurs de pixels pour les images, formatés NaViT.

target_sizes (`torch.IntTensor`, *facultatif*) : Hauteur et largeur (en patches) pour chaque image.

pixel_values_videos (`torch.Tensor`, *facultatif*) : Patchs de valeurs de pixels pour les images vidéo, formatés NaViT.

target_sizes_videos (`torch.IntTensor`, *facultatif*) : Hauteur et largeur (en patches) de chaque image vidéo.

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)

position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`.  [Que sont les identifiants de position ?](../glossary#position-ids)

past_key_values (`list[torch.Tensor]`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`. Seule une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut. Le modèle renverra le même format de cache que celui fourni en entrée. Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux dont les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`.

inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle.

labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être compris dans `[0, ..., config.vocab_size]` ou égaux à -100 (voir la docstring de `input_ids`). Les jetons dont l'indice est défini sur `-100` sont ignorés (masqués) ; la perte n'est calculée que pour les jetons dont l'étiquette est comprise dans `[0, ..., config.vocab_size]`.

use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`).

downsample_mode (`str`, *facultatif*) : `"4x"` conserve 4 fois plus de jetons visuels ; la valeur par défaut `"16x"` applique la fusion complète.

mm_token_type_ids (`torch.IntTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée correspondant à chaque modalité. Par exemple, texte (0), image (1), vidéo (2). Les identifiants de type de jeton multimodal peuvent être obtenus à l'aide de [AutoProcessor](/docs/transformers/v5.23.0/fr/model_doc/auto#transformers.AutoProcessor). Consultez [ProcessorMixin.__call__()](/docs/transformers/v5.23.0/fr/main_classes/processors#transformers.ProcessorMixin.__call__) pour plus de détails.

logits_to_keep (`Union[int, torch.Tensor]`, *facultatif*, valeur par défaut `0`) : Si c'est un `int`, calcule les logits pour les `logits_to_keep` derniers jetons. Si c'est `0`, calcule les logits pour tous les `input_ids` (cas particulier). Seuls les logits du dernier jeton sont nécessaires pour la génération, et les calculer uniquement pour ce jeton peut faire économiser de la mémoire, ce qui devient assez significatif pour les séquences longues ou les tailles de vocabulaire importantes. Si c'est un `torch.Tensor`, il doit être 1D et correspondre aux indices à conserver dans la dimension de la longueur de la séquence. C'est utile lors de l'utilisation du format de tenseurs empilés (une seule dimension pour le lot et la longueur de la séquence).

mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *facultatif*) : Dictionnaire dont les clés sont les modalités prises en charge et les valeurs sont les sorties encodées pour cette modalité. Chaque sortie encodée est un tuple composé de (`pooler_output`, *facultatif* : `last_hidden_states`, *facultatif* : `hidden_states`, *facultatif* : `attentions`) `pooler_output` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) est une séquence de fonctionnalités multimodales de l'encodeur fusionnées dans les embeddings de texte.

**Retourne :** [CausalLMOutputWithPast](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou `tuple(torch.Tensor)`

Un [CausalLMOutputWithPast](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) 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 ([MiniCPMV4_7Config](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Config)) et les entrées.

La méthode forward de [MiniCPMV4_7ForConditionalGeneration](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_7#transformers.MiniCPMV4_7ForConditionalGeneration) 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.

- **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de modélisation du langage (pour la prédiction du jeton suivant).
- **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.vocab_size)`) -- Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).
- **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/v5.23.0/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache).

  Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel.
- **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 modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`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)`.

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

Exemple :

```python
>>> from PIL import Image
>>> from transformers import AutoProcessor, MiniCPMV4_7ForConditionalGeneration

>>> model = MiniCPMV4_7ForConditionalGeneration.from_pretrained("openbmb/MiniCPM-V-4.7-1B")
>>> processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-V-4.7-1B")

>>> messages = [
...     {
...         "role": "user", "content": [
...             {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
...             {"type": "text", "text": "Where is the cat standing?"},
...         ]
...     },
... ]

>>> inputs = processor.apply_chat_template(
...     messages,
...     tokenize=True,
...     return_dict=True,
...     return_tensors="pt",
...     add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]
```

#### get_image_features[[transformers.MiniCPMV4_7ForConditionalGeneration.get_image_features]]

```python
get_image_features(*args, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_7/modeling_minicpmv4_7.py#L1294)

**Retourne :** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 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 ([MiniCPMV4_7Config](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Config)) et les entrées.

Extraction des caractéristiques d'image : encodeur visuel, insert merger, puis MLP merger.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé 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 modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`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)`.

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

Exemple :

```python
>>> from PIL import Image
>>> from transformers import AutoProcessor, MiniCPMV4_7ForConditionalGeneration

>>> model = MiniCPMV4_7ForConditionalGeneration.from_pretrained("openbmb/MiniCPM-V-4.7-1B")
>>> processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-V-4.7-1B")

>>> messages = [
...     {
...         "role": "user", "content": [
...             {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
...             {"type": "text", "text": "Where is the cat standing?"},
...         ]
...     },
... ]

>>> inputs = processor.apply_chat_template(
...     messages,
...     tokenize=True,
...     return_dict=True,
...     return_tensors="pt",
...     add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]
```

#### get_video_features[[transformers.MiniCPMV4_7ForConditionalGeneration.get_video_features]]

```python
get_video_features(*args, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_7/modeling_minicpmv4_7.py#L1298)

**Retourne :** [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)`

Un [BaseModelOutputWithPooling](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 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 ([MiniCPMV4_7Config](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Config)) et les entrées.

Extraction des caractéristiques vidéo : réempaqueter les images au format NaViT, puis encodeur visuel + fusionneur.

- **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle.
- **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.
- **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé 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 modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
- **attentions** (`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)`.

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

Exemple :

```python
>>> from PIL import Image
>>> from transformers import AutoProcessor, MiniCPMV4_7ForConditionalGeneration

>>> model = MiniCPMV4_7ForConditionalGeneration.from_pretrained("openbmb/MiniCPM-V-4.7-1B")
>>> processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-V-4.7-1B")

>>> messages = [
...     {
...         "role": "user", "content": [
...             {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
...             {"type": "text", "text": "Where is the cat standing?"},
...         ]
...     },
... ]

>>> inputs = processor.apply_chat_template(
...     messages,
...     tokenize=True,
...     return_dict=True,
...     return_tensors="pt",
...     add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]
```

## MiniCPMV4_7Processor[[transformers.MiniCPMV4_7Processor]]

#### transformers.MiniCPMV4_7Processor[[transformers.MiniCPMV4_7Processor]]

```python
transformers.MiniCPMV4_7Processor(image_processor = None, video_processor = None, tokenizer = None, chat_template = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_7/processing_minicpmv4_7.py#L45)

**Paramètres :**

image_processor (`MiniCPMV4_6ImageProcessor`) : le processeur d'images est une entrée obligatoire.

video_processor (`MiniCPMV4_6VideoProcessor`) : le processeur vidéo est une entrée obligatoire.

tokenizer (`TokenizersBackend`) : le tokenizer est une entrée obligatoire.

chat_template (`str`) : Un modèle Jinja pour convertir des listes de messages d'une conversation en une chaîne tokenisable.

Construit un MiniCPMV4_7Processor qui encapsule un processeur d’images, un processeur de vidéos et un tokeniseur en un seul processeur.

[MiniCPMV4_7Processor](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_7#transformers.MiniCPMV4_7Processor) offre toutes les fonctionnalités de [MiniCPMV4_6ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_6#transformers.MiniCPMV4_6ImageProcessor), [MiniCPMV4_6VideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_6#transformers.MiniCPMV4_6VideoProcessor) et [TokenizersBackend](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend). Consultez [~MiniCPMV4_6ImageProcessor](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_6#transformers.MiniCPMV4_6ImageProcessor), [~MiniCPMV4_6VideoProcessor](/docs/transformers/v5.23.0/fr/model_doc/minicpmv4_6#transformers.MiniCPMV4_6VideoProcessor) et [~TokenizersBackend](/docs/transformers/v5.23.0/fr/main_classes/tokenizer#transformers.TokenizersBackend) pour plus d’informations.

#### __appel__[[transformers.MiniCPMV4_7Processor.__call__]]

```python
__call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] | list[list[str]] | None = None, videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, **kwargs: *<class 'transformers.models.minicpmv4_7.processing_minicpmv4_7.MiniCPMV4_7ProcessorKwargs'>)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/minicpmv4_7/processing_minicpmv4_7.py#L82)

**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éfinissez *do_rescale=False*.

text (*Union[str, list[str], list[list[str]]]*, *facultatif*) : La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaîne pré-tokenisée). Si vous passez une entrée pré-tokenisée, définissez *is_split_into_words=True* pour éviter toute ambiguïté avec les entrées en lot.

videos (*Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]*, *optionnel*) : Vidéo à prétraiter. S'attend à une vidéo unique ou à un lot de vidéos dont les valeurs de pixels vont de 0 à 255. Si vous passez des vidéos dont les valeurs de pixels sont comprises entre 0 et 1, définissez *do_rescale=False*.

return_mm_token_type_ids (*bool*, *kwargs*) : Indique s'il faut retourner les identifiants de type de jeton multimodal indiquant les positions des jetons de substitution multimodaux.

return_text_replacement_offsets (*bool*, *kwargs*) : Indique s'il faut retourner les décalages de caractères pour chaque emplacement multimodal et son remplacement.

use_image_id (*bool*, *kwargs*, *facultatif*) : Indique s'il faut préfixer chaque emplacement réservé à une image par une balise d'identifiant d'image (`<image_id>N</image_id>`). Si non défini, la valeur par défaut est *use_image_id* du processeur d'images.

return_tensors (*str* ou [*~utils.TensorType*], *facultatif*) : Si défini, renverra des tenseurs d'un framework particulier. Les valeurs acceptables sont :  - *'pt'* : Renvoie des objets *torch.Tensor* de PyTorch. - *'np'* : Renvoie des objets *np.ndarray* de NumPy.

- ****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.

