Transformers documentation
MiniCPM-V
Ce modèle a été publié dans HF papers le 2025-09-16 et contribué à Hugging Face Transformers le 2026-04-28.
MiniCPM-V
MiniCPM-V est une série de grands modèles de langage multimodaux efficaces développés par OpenBMB. L’architecture de MiniCPM-V 4.6 utilise un encodeur visuel SigLIP avec un mécanisme de fusion par attention sur fenêtre et un modèle de langage de base Qwen3.5, prenant en charge les modes de sous-échantillonnage visuel 4x et 16x.
Ce modèle a été contribué par OpenBMB. Le code d'origine peut être trouvé ici.
Exemple d'utilisation
Inférence avec Pipeline
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_6")
outputs = pipe(text=messages, max_new_tokens=50, return_full_text=False)
outputs[0]["generated_text"]Inférence sur une image unique
Le modèle a été entraîné avec un format de prompt spécifique pour le chat. Utilisez
processor.apply_chat_template(my_conversation_dict)pour formater correctement vos prompts.
from transformers import AutoProcessor, AutoModelForImageTextToText
model_checkpoint = "openbmb/MiniCPM-V-4_6"
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.6 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 :
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 :
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) :
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)Backend de traitement d'images
MiniCPM-V 4.6 fournit deux backends de traitement d'images :
- torchvision (par défaut) : utilise
torchvision.transformspour le redimensionnement des images. - pil : Utilise
PIL.Image.resize, conformément à l'implémentation d'origine.
Pour utiliser le backend PIL :
from transformers import AutoProcessor, AutoImageProcessor
processor = AutoProcessor.from_pretrained(model_checkpoint)
processor.image_processor = AutoImageProcessor.from_pretrained(model_checkpoint, backend="pil")Inférence vidéo
MiniCPM-V 4.6 prend en charge la compréhension de vidéos.
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)Si vous disposez déjà de la chaîne de prompt rendue, vous pouvez appeler directement processor(text=..., videos=[...]) à la place.
MiniCPMV4_6Config
classe transformers.MiniCPMV4_6Config
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneinsert_layer_id: int = 6image_size: int = 448drop_vision_last_layer: bool = Falseimage_token_id: int | None = Nonevideo_token_id: int | None = Nonetie_word_embeddings: bool = Falsedownsample_mode: str = '16x'merge_kernel_size: tuple[int, int] | list[int] = (2, 2)merger_times: int = 1 )
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, par défaut 448) — Résolution de base pour le prétraitement des images. - drop_vision_last_layer (
bool, facultatif, valeur par défautFalse) — Indique s'il faut supprimer la dernière couche de l'encodeur visuel. - image_token_id (
int, facultatif) — Identifiant du jeton utilisé comme espace réservé pour l'image. - video_token_id (
int, facultatif) — Identifiant de jeton utilisé comme espace réservé pour la vidéo. - tie_word_embeddings (
bool, facultatif, valeur par défautFalse) — Indique s'il faut lier les embeddings de poids selon la correspondancetied_weights_keysdu modèle. - downsample_mode (
str, facultatif, 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, par défaut 1) — Nombre de tours de fusion itératifs dans le Merger.
Ceci est la classe de configuration destinée à stocker la configuration d'un MiniCPMV4_6Model. Elle est utilisée pour instancier un modèle Minicpmv4 6 en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de openbmb/MiniCPM-V-4.6
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
MiniCPMV4_6VisionConfig
classe transformers.MiniCPMV4_6VisionConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 768intermediate_size: int = 3072num_hidden_layers: int = 12num_attention_heads: int = 12num_channels: int = 3image_size: int | list[int] | tuple[int, int] = 224patch_size: int | list[int] | tuple[int, int] = 16hidden_act: str = 'gelu_pytorch_tanh'layer_norm_eps: float = 1e-06attention_dropout: float | int = 0.0insert_layer_id: int = 6window_kernel_size: tuple[int, int] | list[int] = (2, 2) )
Paramètres
- hidden_size (
int, facultatif, par défaut768) — Dimension des représentations cachées. - intermediate_size (
int, facultatif, par défaut3072) — Dimension des représentations du MLP. - num_hidden_layers (
int, facultatif, par défaut12) — Nombre de couches cachées dans le décodeur Transformer. - num_attention_heads (
int, facultatif, valeur par défaut12) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - num_channels (
int, facultatif, par défaut3) — Le nombre de canaux d'entrée. - image_size (
Union[int, list[int], tuple[int, int]], facultatif, par défaut224) — La taille (résolution) de chaque image. - patch_size (
Union[int, list[int], tuple[int, int]], facultatif, par défaut16) — La taille (résolution) de chaque patch. - hidden_act (
str, facultatif, par défautgelu_pytorch_tanh) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - layer_norm_eps (
float, facultatif, valeur par défaut1e-06) — L'épsilon utilisé par les couches de normalisation de couche. - attention_dropout (
Union[float, int], facultatif, valeur par défaut0.0) — Le taux de dropout appliqué aux probabilités d'attention. - 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, par défaut(2, 2)) — Taille de la fenêtre(h, w)pour le fusionneur d'attention par fenêtres intermédiaire.
Ceci est la classe de configuration destinée à stocker la configuration d'un MiniCPMV4_6Model. Elle est utilisée pour instancier un modèle Minicpmv4 6 en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de openbmb/MiniCPM-V-4.6
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
MiniCPMV4_6Model
classe transformers.MiniCPMV4_6Model
< source >( config: MiniCPMV4_6Config )
Paramètres
- config (MiniCPMV4_6Config) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le modèle MiniCPMV4_6, 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. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Nonetarget_sizes: typing.Optional[torch.IntTensor] = Nonepixel_values_videos: typing.Optional[torch.Tensor] = Nonetarget_sizes_videos: typing.Optional[torch.IntTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: list[torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Nonedownsample_mode: str | None = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- pixel_values (
torch.Tensor, facultatif) — Patches 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) — Patches de valeurs de pixels pour les images vidéo, formatés NaViT. - target_sizes_videos (
torch.IntTensor, facultatif) — Hauteur et largeur (en patches) pour chaque image vidéo. - attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- position_ids (
torch.LongTensorde 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]. - past_key_values (
list[torch.Tensor], facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_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 indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values). - downsample_mode (
str, facultatif) —"4x"conserve 4 fois plus de jetons visuels ; la valeur par défaut"16x"applique une fusion complète. - 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_outputde forme(batch_size, sequence_length, hidden_size), facultatif) est une séquence de fonctions multimodales de l'encodeur fusionnées dans les embeddings de texte.
Retourne
BaseModelOutputWithPast ou tuple(torch.Tensor)
Un BaseModelOutputWithPast ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (MiniCPMV4_6Config) et des entrées.
La méthode forward du modèle MiniCPMV4_6Model redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
last_hidden_state (
torch.Tensorde 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_valuesest 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é lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de Cache. Pour plus de détails, consultez notre guide sur le cache kv.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éepast_key_values) pour accélérer le décodage séquentiel.hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
get_image_features
< source >( pixel_values: Tensortarget_sizes: IntTensordownsample_mode: str | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Paramètres
- pixel_values (
torch.Tensorde forme(batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide de MiniCPMV4_6ImageProcessor. Voir MiniCPMV4_6ImageProcessor.call() pour plus de détails (MiniCPMV4_6Processor utilise MiniCPMV4_6ImageProcessor pour le traitement des images). - target_sizes (
torch.IntTensorde forme(num_images, 2)) — Hauteur et largeur (en patches) de chaque image. - downsample_mode (
str, facultatif) — Lorsqu’il est défini sur"4x", levit_mergerintermédiaire est ignoré, de sorte que chaque image conserve4×plus de jetons visuels. Le mode par défaut"16x"applique le pipeline de fusion complet.
Retourne
BaseModelOutputWithPooling ou tuple(torch.Tensor)
Un BaseModelOutputWithPooling ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (MiniCPMV4_6Config) et des entrées.
Extraction des caractéristiques d'image : encodeur visuel, insert merger, puis MLP merger.
last_hidden_state (
torch.Tensorde 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.Tensorde forme(batch_size, hidden_size)) — État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
MiniCPMV4_6ForConditionalGeneration
classe transformers.MiniCPMV4_6ForConditionalGeneration
< source >( config: MiniCPMV4_6Config )
Paramètres
- config (MiniCPMV4_6Config) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.
Le modèle Minicpmv4 6 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. Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, la taille des têtes, etc.)
Ce modèle est également une sous-classe de torch.nn.Module de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l'utilisation et le comportement généraux.
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Nonetarget_sizes: typing.Optional[torch.IntTensor] = Nonepixel_values_videos: typing.Optional[torch.Tensor] = Nonetarget_sizes_videos: typing.Optional[torch.IntTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: list[torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonedownsample_mode: str | None = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutputWithPast or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde 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. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- pixel_values (
torch.Tensor, facultatif) — Patches 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) — Patches de valeurs de pixels pour les images vidéo, formatés NaViT. - target_sizes_videos (
torch.IntTensor, facultatif) — Hauteur et largeur (en patches) pour chaque image vidéo. - attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- position_ids (
torch.LongTensorde 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]. - past_key_values (
list[torch.Tensor], facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_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 indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - labels (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans[0, ..., config.vocab_size]ou -100 (voir la docstring deinput_ids). Les jetons dont l'indice est défini sur-100sont ignorés (masqués), la perte n'est calculée que pour les jetons dont l'étiquette est dans[0, ..., config.vocab_size]. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values). - downsample_mode (
str, facultatif) —"4x"conserve 4 fois plus de jetons visuels ; la valeur par défaut"16x"applique une fusion complète. - 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_outputde forme(batch_size, sequence_length, hidden_size), facultatif) est une séquence de fonctions multimodales de l'encodeur fusionnées dans les embeddings de texte.
Retourne
CausalLMOutputWithPast ou tuple(torch.Tensor)
Un CausalLMOutputWithPast ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (MiniCPMV4_6Config) et des entrées.
La méthode forward de MiniCPMV4_6ForConditionalGeneration redéfinit la méthode spéciale __call__.
Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance
Moduleplutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement.
loss (
torch.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de modélisation du langage (pour la prédiction du jeton suivant).logits (
torch.Tensorde 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é lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de Cache. Pour plus de détails, consultez notre guide sur le cache kv.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é lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemple :
>>> from PIL import Image
>>> from transformers import AutoProcessor, MiniCPMV4_6ForConditionalGeneration
>>> model = MiniCPMV4_6ForConditionalGeneration.from_pretrained("openbmb/MiniCPM-V-4.6")
>>> processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-V-4.6")
>>> 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
< source >( *args**kwargs ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Retourne
BaseModelOutputWithPooling ou tuple(torch.Tensor)
Un BaseModelOutputWithPooling ou un tuple de
torch.Tensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (MiniCPMV4_6Config) et des entrées.
Extraction des caractéristiques d'image : encodeur visuel, insert merger, puis MLP merger.
last_hidden_state (
torch.Tensorde 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.Tensorde forme(batch_size, hidden_size)) — État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.Tensor(un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme(batch_size, sequence_length, hidden_size).États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives.
attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemple :
>>> from PIL import Image
>>> from transformers import AutoProcessor, MiniCPMV4_6ForConditionalGeneration
>>> model = MiniCPMV4_6ForConditionalGeneration.from_pretrained("openbmb/MiniCPM-V-4.6")
>>> processor = AutoProcessor.from_pretrained("openbmb/MiniCPM-V-4.6")
>>> 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_6Processor
classe transformers.MiniCPMV4_6Processor
< source >( image_processor = Nonevideo_processor = Nonetokenizer = Nonechat_template = None**kwargs )
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_6Processor qui encapsule un processeur d’images, un processeur de vidéos et un tokeniseur en un seul processeur.
MiniCPMV4_6Processor offre toutes les fonctionnalités de MiniCPMV4_6ImageProcessor, MiniCPMV4_6VideoProcessor et TokenizersBackend. Consultez ~MiniCPMV4_6ImageProcessor, ~MiniCPMV4_6VideoProcessor et ~TokenizersBackend pour plus d’informations.
__call__
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonetext: str | list[str] | list[list[str]] | None = Nonevideos: 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.processing_utils.ProcessingKwargs'> )
Paramètres
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], facultatif) — Image à prétraiter. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissezdo_rescale=False. - 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înes pré-tokenisées). Si vous passez une entrée pré-tokenisée, définissezis_split_into_words=Truepour é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]]], facultatif) — 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éfinissezdo_rescale=False. - return_tensors (
strou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :'pt': Renvoie des objetstorch.Tensorde PyTorch.'np': Renvoie des objets NumPynp.ndarray.
- **kwargs (ProcessingKwargs, facultatif) — Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge.
MiniCPMV4_6ImageProcessor
classe transformers.MiniCPMV4_6ImageProcessor
< source >( **kwargs: *<class 'transformers.models.minicpmv4_6.image_processing_minicpmv4_6.MiniCPMV4_6ImageProcessorKwargs'> )
Paramètres
- do_convert_rgb (bool, kwargs, facultatif, par défaut True) — Indique s'il faut convertir l'image en RGB.
- do_resize (bool, kwargs, facultatif, par défaut True) — Indique s'il faut redimensionner l'image.
- size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — Définit les dimensions maximales des entrées du modèle.
- default_to_square (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut utiliser une image carrée par défaut lors du redimensionnement, si la taille est un entier.
- crop_size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application de center_crop.
- resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, par défaut 3) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
- do_rescale (bool, kwargs, facultatif, par défaut True) — Indique s'il faut rééchelonner l'image.
- rescale_factor (float, kwargs, facultatif, valeur par défaut 0.00392156862745098) — Facteur de remise à l'échelle appliqué à l'image si do_rescale est défini sur True.
- do_normalize (bool, kwargs, facultatif, par défaut True) — Indique s'il faut normaliser l'image.
- image_mean (Union[float, list[float], tuple[float, …]], kwargs, facultatif, valeur par défaut [0.5, 0.5, 0.5]) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
- image_std (Union[float, list[float], tuple[float, …]], kwargs, facultatif, par défaut [0.5, 0.5, 0.5]) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
- do_pad (bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
- pad_size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — La taille au format {“height”: int, “width” int} à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsque do_pad=True.
- do_center_crop (bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image.
- data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
- input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) —
Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
- “channels_first” ou ChannelDimension.FIRST : image au format (num_channels, height, width).
- “channels_last” ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
- “none” ou ChannelDimension.NONE : image au format (hauteur, largeur).
- device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
- return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Renvoie des tenseurs empilés si défini sur ‘pt’, sinon renvoie une liste de tenseurs.
- disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
- image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.
- max_slice_nums (int, kwargs, facultatif, valeur par défaut 9) — Nombre maximal de tranches lors de la division d'une image haute résolution.
- scale_resolution (int, kwargs, facultatif, valeur par défaut 448) — Résolution cible pour les tranches individuelles.
- patch_size (int, kwargs, facultatif, valeur par défaut 14) — Taille spatiale des patches de l'encodeur visuel.
- slice_mode (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut diviser les images en plusieurs tranches pour une résolution plus élevée.
- downsample_mode (str, kwargs, facultatif, par défaut “16x”) — Mode de sous-échantillonnage des jetons visuels. “16x” applique une fusion complète ; “4x” conserve 4 fois plus de jetons.
- use_image_id (bool, kwargs, facultatif, valeur par défaut True) —
Indique s'il faut préfixer un tag image-id (
<image_id>N</image_id>) avant chaque emplacement réservé pour une image. Utilisé par le Processor pour la génération des emplacements réservés, et non par le pipeline de traitement des images lui-même.
Construit un processeur d’images MiniCPMV4_6ImageProcessor.
prétraiter
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]**kwargs: *<class 'transformers.models.minicpmv4_6.image_processing_minicpmv4_6.MiniCPMV4_6ImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature
Paramètres
- images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — 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.
- do_convert_rgb (bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB.
- do_resize (bool, kwargs, facultatif) — Indique s'il faut redimensionner l'image.
- size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — Définit les dimensions maximales des entrées du modèle.
- default_to_square (bool, kwargs, facultatif) — Indique s'il faut par défaut redimensionner l'image en carré si size est un entier.
- crop_size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application de center_crop.
- resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
- do_rescale (bool, kwargs, facultatif) — Indique s'il faut rééchelonner l'image.
- rescale_factor (float, kwargs, facultatif) — Facteur de remise à l'échelle à appliquer à l'image si do_rescale est défini sur True.
- do_normalize (bool, kwargs, facultatif) — Indique s'il faut normaliser l'image.
- image_mean (Union[float, list[float], tuple[float, …]], kwargs, optionnel) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
- image_std (Union[float, list[float], tuple[float, …]], kwargs, optionnel) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
- do_pad (bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
- pad_size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — La taille au format {“height”: int, “width” int} à laquelle les images doivent être remplies. Elle doit être supérieure à la taille de n'importe quelle image fournie pour la prétraitement. Si pad_size n'est pas fourni, les images seront remplies jusqu'à la hauteur et la largeur maximales du lot. Appliqué uniquement lorsque do_pad=True.
- do_center_crop (bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image.
- data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
- input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) —
Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
- “channels_first” ou ChannelDimension.FIRST : image au format (num_channels, height, width).
- “channels_last” ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
- “none” ou ChannelDimension.NONE : image au format (hauteur, largeur).
- device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
- return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Renvoie des tenseurs empilés si défini sur ‘pt’, sinon renvoie une liste de tenseurs.
- disable_grouping (bool, kwargs, facultatif) — Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle est définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157
- image_seq_length (int, kwargs, facultatif) — Le nombre de jetons d’image à utiliser pour chaque image de l’entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles.
- max_slice_nums (int, kwargs, facultatif, valeur par défaut 9) — Nombre maximal de tranches lors de la division d'une image haute résolution.
- scale_resolution (int, kwargs, facultatif, valeur par défaut 448) — Résolution cible pour les tranches individuelles.
- patch_size (int, kwargs, facultatif, valeur par défaut 14) — Taille spatiale des patches de l'encodeur visuel.
- slice_mode (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut diviser les images en plusieurs tranches pour une résolution plus élevée.
- downsample_mode (str, kwargs, facultatif, par défaut “16x”) — Mode de sous-échantillonnage des jetons visuels. “16x” applique une fusion complète ; “4x” conserve 4 fois plus de jetons.
- use_image_id (bool, kwargs, facultatif, valeur par défaut True) —
Indique s'il faut préfixer un tag image-id (
<image_id>N</image_id>) avant chaque emplacement réservé pour une image. Utilisé par le Processor pour la génération des emplacements réservés, et non par le pipeline de traitement des images lui-même.
Retourne
~image_processing_base.BatchFeature
- data (dict) — Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode call (‘pixel_values’, etc.).
- tensor_type (Union[None, str, TensorType], facultatif) — Vous pouvez indiquer un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.
MiniCPMV4_6ImageProcessorPil
classe transformers.MiniCPMV4_6ImageProcessorPil
< source >( **kwargs: *<class 'transformers.models.minicpmv4_6.image_processing_pil_minicpmv4_6.MiniCPMV4_6ImageProcessorPilKwargs'> )
Construit un processeur d’images MiniCPMV4_6ImageProcessor.
prétraiter
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]**kwargs: *<class 'transformers.models.minicpmv4_6.image_processing_pil_minicpmv4_6.MiniCPMV4_6ImageProcessorPilKwargs'> ) → ~image_processing_base.BatchFeature
Paramètres
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — Image à prétraiter. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissezdo_rescale=False. - return_tensors (
strou TensorType, facultatif) — Retourne des tenseurs empilés si défini sur'pt', sinon retourne une liste de tenseurs. - **kwargs (
MiniCPMV4_6ImageProcessorPilKwargs, facultatif) — Options supplémentaires de prétraitement des images. Les kwargs spécifiques au modèle sont listés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge.
Retourne
~image_processing_base.BatchFeature
- data (
dict) — Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode call (« pixel_values », etc.). - tensor_type (
Union[None, str, TensorType], facultatif) — Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.
MiniCPMV4_6VideoProcessor
classe transformers.MiniCPMV4_6VideoProcessor
< source >( **kwargs: *<class 'transformers.models.minicpmv4_6.video_processing_minicpmv4_6.MiniCPMV4_6VideoProcessorKwargs'> )
Paramètres
- do_convert_rgb (bool, kwargs, facultatif, par défaut True) — Indique s'il faut convertir l'image en RGB.
- do_resize (bool, kwargs, facultatif, par défaut True) — Indique s'il faut redimensionner l'image.
- size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — Définit les dimensions maximales des entrées du modèle.
- default_to_square (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut utiliser une image carrée par défaut lors du redimensionnement, si la taille est un entier.
- resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, par défaut 3) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enum PILImageResampling. N’a un effet que si do_resize est défini sur True.
- do_rescale (bool, kwargs, facultatif, par défaut True) — Indique s'il faut rééchelonner l'image.
- rescale_factor (float, kwargs, facultatif, valeur par défaut 0.00392156862745098) — Facteur de remise à l'échelle appliqué à l'image si do_rescale est défini sur True.
- do_normalize (bool, kwargs, facultatif, par défaut True) — Indique s'il faut normaliser l'image.
- image_mean (Union[float, list[float], tuple[float, …]], kwargs, facultatif, valeur par défaut [0.5, 0.5, 0.5]) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
- image_std (Union[float, list[float], tuple[float, …]], kwargs, facultatif, par défaut [0.5, 0.5, 0.5]) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si do_normalize est défini sur True.
- do_center_crop (bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image.
- do_pad (bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle.
- crop_size (Annotated[int | list[int] | tuple[int, …] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application de center_crop.
- data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Seul ChannelDimension.FIRST est pris en charge. Ajouté pour la compatibilité avec les processeurs lents.
- input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) —
Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :
- “channels_first” ou ChannelDimension.FIRST : image au format (num_channels, height, width).
- “channels_last” ou ChannelDimension.LAST : image au format (hauteur, largeur, nombre de canaux).
- “none” ou ChannelDimension.NONE : image au format (hauteur, largeur).
- device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée.
- do_sample_frames (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut échantillonner des images de la vidéo avant le traitement ou traiter la vidéo entière.
- video_metadata (Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None], kwargs) — Métadonnées de la vidéo contenant des informations sur la durée totale, le fps et le nombre total d’images. Elles seront utilisées pour échantillonner des images de la vidéo ou calculer des horodatages. Ne passez aucune métadonnée à moins de chercher à décoder la vidéo manuellement avant le traitement
- fps (Annotated[int | float | None, None], kwargs) — Nombre de cibles d'images à échantillonner par seconde lorsque do_sample_frames=True.
- num_frames (Annotated[int | None, None], kwargs) — Nombre maximal de frames à échantillonner lorsque do_sample_frames=True.
- return_metadata (bool, kwargs, facultatif, par défaut False) — Indique s'il faut renvoyer les métadonnées de la vidéo ou non. Les métadonnées vidéo sont un objet contenant des informations sur la durée de la vidéo, le fps, le backend de décodage, etc.
- return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) —
Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptables sont :
- ‘pt’ : Renvoie des objets torch.Tensor de PyTorch.
- ‘np’ : Renvoie des objets NumPy np.ndarray.
- max_num_frames (int, kwargs, facultatif, valeur par défaut 128) — Nombre maximal de frames principales à échantillonner par vidéo.
- stack_frames (int, kwargs, facultatif, valeur par défaut 1) —
Sous-images par seconde à empiler.
1désactive l'empilement. - max_slice_nums (int, kwargs, facultatif, valeur par défaut 9) — Nombre maximal de tranches lors de la division d'une image haute résolution.
- scale_resolution (int, kwargs, facultatif, valeur par défaut 448) — Résolution cible pour les tranches individuelles.
- patch_size (int, kwargs, facultatif, valeur par défaut 14) — Taille spatiale des patches de l'encodeur visuel.
- slice_mode (bool, kwargs, facultatif, valeur par défaut True) — Indique s'il faut diviser les images en plusieurs tranches pour une résolution plus élevée.
- downsample_mode (str, kwargs, facultatif, par défaut “16x”) — Mode de sous-échantillonnage des jetons visuels. “16x” applique une fusion complète ; “4x” conserve 4 fois plus de jetons.
- use_image_id (bool, kwargs, facultatif, valeur par défaut True) —
Indique s'il faut préfixer un tag image-id (
<image_id>N</image_id>) avant chaque emplacement réservé pour une image. Utilisé par le Processor pour la génération des emplacements réservés, et non par le pipeline de traitement des images lui-même. - **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.
Construit un processeur vidéo MiniCPMV4_6VideoProcessor.
prétraiter
< source >( 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]]]**kwargs: *<class 'transformers.processing_utils.VideosKwargs'> ) → ~image_processing_base.BatchFeature
Paramètres
- 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]]]) — 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éfinissezdo_rescale=False. - do_convert_rgb (
bool, kwargs, facultatif) — Indique s'il faut convertir l'image en RGB. - do_resize (
bool, kwargs, facultatif) — Indique s'il faut redimensionner l'image. - size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Définit les dimensions maximales des entrées du modèle. - default_to_square (
bool, kwargs, facultatif) — Indique s'il faut par défaut redimensionner l'image en carré si la taille est un entier. - resample (
Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — Filtre de rééchantillonnage à utiliser lors du redimensionnement de l’image. Il peut s’agir de l’une des valeurs de l’enumPILImageResampling. N’a un effet que sido_resizeest défini surTrue. - do_rescale (
bool, kwargs, facultatif) — Indique s'il faut rééchelonner l'image. - rescale_factor (
float, kwargs, facultatif) — Facteur de remise à l'échelle à appliquer à l'image sido_rescaleest défini surTrue. - do_normalize (
bool, kwargs, facultatif) — Indique s'il faut normaliser l'image. - image_mean (
Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Moyenne de l'image à utiliser pour la normalisation. N'a un effet que sido_normalizeest défini surTrue. - image_std (
Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — Écart-type de l'image à utiliser pour la normalisation. N'a un effet que sido_normalizeest défini surTrue. - do_center_crop (
bool, kwargs, facultatif) — Indique s'il faut effectuer un recadrage centré de l'image. - do_pad (
bool, kwargs, facultatif) — Indique s'il faut effectuer un bourrage (padding) de l'image. Le bourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de bourrage exacte dépend du modèle. - crop_size (
Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Taille de l'image de sortie après application decenter_crop. - data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — SeulChannelDimension.FIRSTest pris en charge. Ajouté pour la compatibilité avec les processeurs lents. - input_data_format (
Union[str, ~image_utils.ChannelDimension], kwargs, facultatif) — Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants :"channels_first"ouChannelDimension.FIRST: image au format (num_channels, height, width)."channels_last"ouChannelDimension.LAST: image au format (hauteur, largeur, nombre de canaux)."none"ouChannelDimension.NONE: image au format (hauteur, largeur).
- device (
Annotated[Union[str, torch.device, NoneType], None], kwargs) — L’appareil sur lequel traiter les vidéos. Si non défini, l’appareil est déduit des vidéos d’entrée. - do_sample_frames (
bool, kwargs, facultatif) — Indique s'il faut échantillonner des images de la vidéo avant le traitement ou traiter la vidéo entière. - video_metadata (
Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None], kwargs) — Métadonnées de la vidéo contenant des informations sur la durée totale, le fps et le nombre total d’images. Elles seront utilisées pour échantillonner des images de la vidéo ou calculer des horodatages. Ne passez aucune métadonnée à moins de chercher à décoder la vidéo manuellement avant le traitement - fps (
Annotated[int | float | None, None], kwargs) — Nombre de cibles d'images à échantillonner par seconde lorsquedo_sample_frames=True. - num_frames (
Annotated[int | None, None], kwargs) — Nombre maximal de frames à échantillonner lorsquedo_sample_frames=True. - return_metadata (
bool, kwargs, facultatif) — Indique s'il faut renvoyer les métadonnées de la vidéo ou non. Les métadonnées vidéo sont un objet contenant des informations sur la durée de la vidéo, le fps, le backend de décodage, etc. - return_tensors (
Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retourne des tenseurs empilés si défini sur'pt', sinon retourne une liste de tenseurs.
Retourne
~image_processing_base.BatchFeature
- data (
dict) — Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode call (« pixel_values », etc.). - tensor_type (
Union[None, str, TensorType], facultatif) — Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation.