Transformers documentation

KOSMOS-2.5

Transformers

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

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Ce modèle a été publié dans HF papers le 2023-09-20 et contribué à Hugging Face Transformers le 2025-08-19.

KOSMOS-2.5

Le modèle Kosmos-2.5 a été proposé dans KOSMOS-2.5: A Multimodal Literate Model par Microsoft.

L'abstract de l'article est le suivant :

Nous présentons Kosmos-2.5, un modèle multimodal lettré pour la lecture machine d'images riches en texte. Pré-entraîné sur de grandes quantités d'images riches en texte, Kosmos-2.5 excelle dans deux tâches de transcription distinctes mais coopératives : (1) la génération de blocs de texte spatialement conscients, où chaque bloc de texte se voit attribuer ses coordonnées spatiales au sein de l'image, et (2) la production d'une sortie de texte structurée qui capture les styles et les structures dans le format markdown. Cette capacité multimodale lettrée unifiée est obtenue grâce à une architecture Transformer partagée, à des prompts spécifiques à la tâche et à des représentations de texte flexibles. Nous évaluons Kosmos-2.5 sur la reconnaissance de texte au niveau du document de bout en bout et la génération de texte image-vers-markdown. De plus, le modèle peut être facilement adapté à toute tâche de compréhension d'images riches en texte avec des prompts différents par le biais d'un fine-tuning supervisé, ce qui en fait un outil polyvalent pour les applications réelles impliquant des images riches en texte. Ce travail pave également la voie à l'échelle future des grands modèles de langage multimodaux.

Overview of tasks that KOSMOS-2.5 can handle. Taken from the original paper.

Les exemples ci-dessous montrent comment générer avec AutoModel, pour les tâches Markdown et OCR.

AutoModel - Tâche Markdown

AutoModel - Tâche OCR

Version Chat

Les auteurs ont également publié Kosmos-2.5 Chat, une version conversationnelle optimisée pour la compréhension de documents. Vous pouvez l'utiliser ainsi :

import requests
import torch
from PIL import Image

from transformers import AutoProcessor, Kosmos2_5ForConditionalGeneration


repo = "microsoft/kosmos-2.5-chat"
dtype = torch.bfloat16

model = Kosmos2_5ForConditionalGeneration.from_pretrained(repo,
                                                          device_map="auto",
                                                          attn_implementation="flash_attention_2")
processor = AutoProcessor.from_pretrained(repo)

# sample image
url = "https://huggingface.co/microsoft/kosmos-2.5/resolve/main/receipt_00008.png"

image = Image.open(requests.get(url, stream=True).raw)

question = "What is the sub total of the receipt?"
template = "<md>A chat between a curious user and an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the user's questions. USER: {} ASSISTANT:"
prompt = template.format(question)
inputs = processor(text=prompt, images=image, return_tensors="pt").to(model.device)

height, width = inputs.pop("height"), inputs.pop("width")
raw_width, raw_height = image.size
scale_height = raw_height / height
scale_width = raw_width / width

inputs = {k: v.to(model.device) if v is not None else None for k, v in inputs.items()}
inputs["flattened_patches"] = inputs["flattened_patches"].to(dtype)
generated_ids = model.generate(
    **inputs,
    max_new_tokens=1024,
)

generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)
print(generated_text[0])

Kosmos2_5Config

classe transformers.Kosmos2_5Config

< 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 = Nonelatent_query_num: int = 2048tie_word_embeddings: bool = True )

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.
latent_query_num (int, facultatif, valeur par défaut 2048) — Le nombre de jetons de requête latents qui représentent les caractéristiques de l'image utilisées dans le composant décodeur de texte.
tie_word_embeddings (bool, facultatif, par défaut True) — Indique s'il faut lier les embeddings de poids selon la correspondance tied_weights_keys du modèle.

Ceci est la classe de configuration destinée à stocker la configuration d'un modèle Kosmos2 5. Elle est utilisée pour instancier un modèle Kosmos2 5 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 microsoft/kosmos-2.5

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.

Kosmos2_5TextConfig

classe transformers.Kosmos2_5TextConfig

< 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 = Nonevocab_size: int = 108481max_position_embeddings: int = 4096embed_dim: int = 1536layers: int = 24ffn_dim: int = 6144attention_heads: int = 16activation_function: str = 'gelu'dropout: float | int = 0.1attention_dropout: float | int = 0.0activation_dropout: float | int = 0.0layerdrop: float | int = 0.0layer_norm_eps: float = 1e-05init_std: float = 0.02scale_embedding: bool = Trueuse_cache: bool = Truetie_word_embeddings: bool = Truepad_token_id: int | None = 1bos_token_id: int | None = 0eos_token_id: int | list[int] | None = 2 )

Paramètres

vocab_size (int, facultatif, par défaut 108481) — Taille du vocabulaire du modèle. Définit le nombre de jetons différents qui peuvent être représentés par input_ids.
max_position_embeddings (int, facultatif, par défaut 4096) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé.
embed_dim (int, facultatif, par défaut 1536) — Dimension des embeddings et des états cachés.
layers (int, facultatif, par défaut 24) — Nombre de couches cachées dans le décodeur Transformer.
ffn_dim (int, facultatif, par défaut 6144) — Dimension des représentations du MLP.
attention_heads (int, facultatif, valeur par défaut 16) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
activation_function (str, facultatif, par défaut gelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple, "gelu", "relu", "silu", etc.
dropout (Union[float, int], facultatif, par défaut 0.1) — Le taux appliqué à toutes les couches de dropout.
attention_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Le taux de dropout appliqué aux probabilités d'attention.
activation_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Le taux de dropout appliqué aux activations à l'intérieur de la couche entièrement connectée.
layerdrop (Union[float, int], facultatif, par défaut 0.0) — La probabilité de LayerDrop. Consultez l'article [LayerDrop](voir https://huggingface.co/papers/1909.11556) pour plus de détails.
layer_norm_eps (float, facultatif, valeur par défaut 1e-05) — L'épsilon utilisé par les couches de normalisation de couche.
init_std (float, facultatif, valeur par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
scale_embedding (bool, facultatif, par défaut True) — Indique s'il faut mettre à l'échelle les embeddings en les divisant par sqrt(d_model).
use_cache (bool, facultatif, valeur par défaut True) — Indique si le modèle doit retourner les dernières attentions clés/valeurs (non utilisé par tous les modèles). N’est pertinent que si config.is_decoder=True ou si le modèle est un modèle génératif uniquement décodeur.
tie_word_embeddings (bool, facultatif, par défaut True) — Indique s'il faut lier les embeddings de poids selon la correspondance tied_weights_keys du modèle.
pad_token_id (int, facultatif, par défaut 1) — Identifiant du jeton utilisé pour le bourrage dans le vocabulaire.
bos_token_id (int, facultatif, par défaut 0) — Identifiant du jeton utilisé pour le début de flux dans le vocabulaire.
eos_token_id (Union[int, list[int]], facultatif, par défaut 2) — Identifiant du jeton utilisé pour la fin de flux dans le vocabulaire.

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.

Kosmos2_5VisionConfig

classe transformers.Kosmos2_5VisionConfig

< 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 = 1536patch_embed_hidden_size: int = 768intermediate_size: int = 3968head_dim: int = 64num_hidden_layers: int = 18num_attention_heads: int = 24dense_act_fn: str = 'gelu_new'layer_norm_eps: float = 1e-06dropout_rate: float | int = 0.0attention_dropout: float | int = 0.0max_num_patches: int = 4096initializer_factor: float = 1.0initializer_range: float = 0.02 )

Paramètres

hidden_size (int, facultatif, par défaut 1536) — Dimension des représentations cachées.
patch_embed_hidden_size (int, facultatif, valeur par défaut 768) — Dimension de la couche d'entrée patch_embedding dans l'encodeur Transformer.
intermediate_size (int, facultatif, par défaut 3968) — Dimension des représentations du MLP.
head_dim (int, facultatif, par défaut 64) — La dimension des têtes d'attention. Si None, elle est par défaut égale à hidden_size // num_attention_heads
num_hidden_layers (int, facultatif, par défaut 18) — Nombre de couches cachées dans le décodeur Transformer.
num_attention_heads (int, facultatif, valeur par défaut 24) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer.
dense_act_fn (str ou function, facultatif, par défaut "gelu_new") — La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans l'encodeur et le pooler. Si c'est une chaîne de caractères, "gelu", "relu", "selu" et "gelu_new" ou "gelu" sont pris en charge.
layer_norm_eps (float, facultatif, valeur par défaut 1e-06) — L'épsilon utilisé par les couches de normalisation de couche.
dropout_rate (Union[float, int], facultatif, par défaut 0.0) — Le taux appliqué à toutes les couches de dropout.
attention_dropout (Union[float, int], facultatif, valeur par défaut 0.0) — Le taux de dropout appliqué aux probabilités d'attention.
max_num_patches (int, facultatif, valeur par défaut 4096) — Longueur maximale de séquence (ici, nombre de patches) prise en charge par le modèle.
initializer_factor (float, facultatif, par défaut 1.0) — Un facteur pour l'initialisation de toutes les matrices de poids (doit être maintenu à 1, utilisé en interne pour les tests d'initialisation).
initializer_range (float, facultatif, par défaut 0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.

Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.

Exemple :

>>> from transformers import Kosmos2_5VisionConfig, Kosmos2_5VisionModel

>>> # Initializing a Kosmos2_5VisionConfig with microsoft/kosmos-2.5 style configuration
>>> configuration = Kosmos2_5VisionConfig()

>>> # Initializing a Kosmos2_5VisionModel (with random weights) from the microsoft/kosmos-2.5 style configuration
>>> model = Kosmos2_5VisionModel(configuration)

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

Kosmos2_5ImageProcessor

classe transformers.Kosmos2_5ImageProcessor

< source >

( **kwargs: *<class 'transformers.models.kosmos2_5.image_processing_kosmos2_5.Kosmos2_5ImageProcessorKwargs'> )

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) — 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) — 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, valeur par défaut None) — Facteur de remise à l'échelle appliqué à l'image si do_rescale est défini sur True.
do_normalize (bool, kwargs, facultatif, valeur par défaut True) — 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 si do_normalize est défini sur True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — É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) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne 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.
patch_size (Dict[str, *kwargs*, int], facultatif, par défaut {"height" -- 16, "width": 16}) : La taille des patches à utiliser pour l'image. Selon le papier et le code de Kosmos2_5, la taille des patches est de 16x16.
max_patches (int, kwargs, facultatif, valeur par défaut 4096) — Le nombre maximal de patches à extraire de l'image, conformément à l'article KOSMOS 2.5.

Construit un processeur d’images image_processor_class.

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.kosmos2_5.image_processing_kosmos2_5.Kosmos2_5ImageProcessorKwargs'> ) → ~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 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) — 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, facultatif) — 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) — É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) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne 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.
patch_size (Dict[str, *kwargs*, int], facultatif, par défaut {"height" -- 16, "width": 16}) : La taille des patches à utiliser pour l'image. Selon le papier et le code de Kosmos2_5, la taille des patches est de 16x16.
max_patches (int, kwargs, facultatif, valeur par défaut 4096) — Le nombre maximal de patches à extraire de l'image, conformément à l'article KOSMOS 2.5.

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.

Kosmos2_5ImageProcessorPil

classe transformers.Kosmos2_5ImageProcessorPil

< source >

( **kwargs: *<class 'transformers.models.kosmos2_5.image_processing_pil_kosmos2_5.Kosmos2_5ImageProcessorKwargs'> )

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) — 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) — 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, valeur par défaut None) — Facteur de remise à l'échelle appliqué à l'image si do_rescale est défini sur True.
do_normalize (bool, kwargs, facultatif, valeur par défaut True) — 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 si do_normalize est défini sur True.
image_std (Union[float, list[float], tuple[float, ...]], kwargs, facultatif) — É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) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne 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.
patch_size (Dict[str, *kwargs*, int], facultatif, par défaut {"height" -- 16, "width": 16}) : La taille des patches à utiliser pour l'image. Selon le papier et le code de Kosmos2_5, la taille des patches est de 16x16.
max_patches (int, kwargs, facultatif, valeur par défaut 4096) — Le nombre maximal de patches à extraire de l'image, conformément à l'article KOSMOS 2.5.

Construit un processeur d’images image_processor_class.

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.kosmos2_5.image_processing_pil_kosmos2_5.Kosmos2_5ImageProcessorKwargs'> ) → ~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 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) — 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, facultatif) — 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) — É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) — Retourne des tenseurs empilés si défini sur 'pt', sinon retourne 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.
patch_size (Dict[str, *kwargs*, int], facultatif, par défaut {"height" -- 16, "width": 16}) : La taille des patches à utiliser pour l'image. Selon le papier et le code de Kosmos2_5, la taille des patches est de 16x16.
max_patches (int, kwargs, facultatif, valeur par défaut 4096) — Le nombre maximal de patches à extraire de l'image, conformément à l'article KOSMOS 2.5.

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.

Kosmos2_5Processor

classe transformers.Kosmos2_5Processor

< source >

( image_processortokenizernum_image_tokens: int = 2048 )

Paramètres

image_processor (image_processor_class) — Le processeur d’images est une entrée obligatoire.
tokenizer (tokenizer_class) — Le tokenizer est une entrée obligatoire.
num_image_tokens (int, facultatif, valeur par défaut 2048) — Nombre de jetons d’image utilisés comme espace réservé.

Construit un Kosmos2_5Processor qui encapsule un processeur d’images et un tokenizer en un seul processeur.

Kosmos2_5Processor offre toutes les fonctionnalités de image_processor_class et de tokenizer_class. Consultez ~image_processor_class et ~tokenizer_class 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] = None**kwargs: *<class 'transformers.models.kosmos2_5.processing_kosmos2_5.Kosmos2_5ProcessorKwargs'> ) → ~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]], 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]], 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éfinissez is_split_into_words=True pour éviter toute ambiguïté avec les entrées en lot.
return_tensors (str ou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :
- 'pt' : Renvoie des objets torch.Tensor de PyTorch.
- 'np' : Renvoie des objets NumPy np.ndarray.
**kwargs (ProcessingKwargs, facultatif) — Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge.

Retourne

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

Kosmos2_5Model

classe transformers.Kosmos2_5Model

< source >

( config: Kosmos2_5Config )

Paramètres

config (Kosmos2_5Config) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Modèle KOSMOS-2.5 pour la génération de texte et de caractéristiques d'image. Le modèle est composé d'un encodeur visuel et d'un modèle de 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.Tensor] = Noneflattened_patches: typing.Optional[torch.Tensor] = Nonewidth: typing.Optional[torch.Tensor] = Noneheight: typing.Optional[torch.Tensor] = Noneimage_embeds_position_mask: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneimage_embeds: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → transformers.models.kosmos2_5.modeling_kosmos2_5.Kosmos2_5ModelOutput or tuple(torch.FloatTensor)

Paramètres

input_ids (torch.LongTensor de forme (batch_size, sequence_length)) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut si vous le fournissez.
Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

Qu'est-ce que les identifiants d'entrée ?
flattened_patches (torch.FloatTensor de forme (batch_size, max_patches, 2 + patch_height * patch_width * image_channels)) — Patches aplatis des images. flattened_patches peut être obtenu à l'aide de AutoImageProcessor. Voir Kosmos2_5ImageProcessor.call() pour plus de détails.
width (torch.FloatTensor de forme (batch_size,)) — La largeur d'origine (avant redimensionnement) de chaque image du lot. Elle peut être obtenue à l'aide de AutoImageProcessor. Consultez Kosmos2_5ImageProcessor.call() pour plus de détails.
height (torch.FloatTensor de forme (batch_size,)) — La hauteur d'origine (avant redimensionnement) de chaque image du lot. Cela peut être obtenu à l'aide de AutoImageProcessor. Voir Kosmos2_5ImageProcessor.call() pour plus de détails.
image_embeds_position_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque indiquant l'emplacement dans une séquence où insérer les caractéristiques de l'image. Les valeurs du masque sont sélectionnées dans [0, 1]:
- 1 pour les emplacements où placer les caractéristiques d'image,
- 0 pour les positions qui ne correspondent pas aux caractéristiques d'image (c'est-à-dire pour les jetons de texte).
attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
Qu'est-ce que les masques d'attention ?
past_key_values (Cache de longueur config.n_layers où chaque tuple contient 4 tenseurs de forme (batch_size, num_heads, sequence_length - 1, embed_size_per_head)) — Contient les états cachés des clés et des valeurs précalculés des blocs d'attention. Peut être utilisé pour accélérer le décodage.
Si past_key_values sont utilisés, l’utilisateur peut éventuellement n’entrer que les derniers decoder_input_ids (ceux dont les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme (batch_size, 1) au lieu de tous les decoder_input_ids de forme (batch_size, sequence_length).
image_embeds — (torch.FloatTensor de forme (batch_size, latent_query_num, hidden_size), facultatif) : Séquence d'états cachés à la sortie de Kosmos2ImageToTextProjection.
inputs_embeds (torch.FloatTensor 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 que la matrice de recherche d’intégration interne du modèle.
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.max_position_embeddings - 1].
Qu'est-ce que les identifiants de position ?
use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).
output_attentions (bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultez attentions sous les tenseurs retournés pour plus de détails.
output_hidden_states (bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voir hidden_states sous les tenseurs retournés pour plus de détails.

Retourne

transformers.models.kosmos2_5.modeling_kosmos2_5.Kosmos2_5ModelOutput ou tuple(torch.FloatTensor)

Un transformers.models.kosmos2_5.modeling_kosmos2_5.Kosmos2_5ModelOutput ou un tuple de torch.FloatTensor (si return_dict=False est passé ou si config.return_dict=False) comprenant divers éléments en fonction de la configuration (<class 'transformers.models.kosmos2_5.configuration_kosmos2_5.Kosmos2_5Config'>) et des entrées.

last_hidden_state (torch.FloatTensor de forme (batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.
hidden_states (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (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.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (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.
width (torch.FloatTensor de forme (batch_size,)) — La largeur d'origine (avant redimensionnement) de chaque image du lot.
height (torch.FloatTensor de forme (batch_size,)) — La hauteur d'origine (avant redimensionnement) de chaque image du lot.
image_embeds (torch.FloatTensor de forme (batch_size, latent_query_num, hidden_size), facultatif) — Séquence d'états cachés à la sortie de Kosmos2ImageToTextProjection.
projection_attentions (tuple(torch.FloatTensor), facultatif) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

Poids d'attention fournis par Kosmos2ImageToTextProjection, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
vision_model_output(BaseModelOutputWithPooling, facultatif) — La sortie du Kosmos2VisionModel.
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. 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ée past_key_values) pour accélérer le décodage séquentiel.

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

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

Exemples :

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

>>> model = Kosmos2_5Model.from_pretrained("microsoft/kosmos2.5")
>>> processor = AutoProcessor.from_pretrained("microsoft/kosmos2.5")

>>> url = "https://huggingface.co/microsoft/kosmos2.5/resolve/main/snowman.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> text = (
...     "<grounding> An image of<phrase> a snowman</phrase><object><patch_index_0044><patch_index_0863>"
...     "</object> warming himself by<phrase> a fire</phrase><object><patch_index_0005><patch_index_0911>"
...     "</object>"
... )

>>> inputs = processor(text=text, images=image, return_tensors="pt", add_eos_token=True)

>>> last_hidden_state = model(
...     pixel_values=inputs["pixel_values"],
...     input_ids=inputs["input_ids"],
...     attention_mask=inputs["attention_mask"],
...     image_embeds_position_mask=inputs["image_embeds_position_mask"],
... ).last_hidden_state
>>> list(last_hidden_state.shape)
[1, 91, 2048]

Kosmos2_5ForConditionalGeneration

classe transformers.Kosmos2_5ForConditionalGeneration

< source >

( config: Kosmos2_5Config )

Paramètres

config (Kosmos2_5Config) — Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode from_pretrained() pour charger les poids du modèle.

Modèle KOSMOS-2.5 pour générer du texte et des boîtes englobantes à partir d'une image. Le modèle est composé d'un encodeur visuel et d'un modèle de langage.

forward

< source >

( input_ids: typing.Optional[torch.Tensor] = Noneflattened_patches: typing.Optional[torch.Tensor] = Nonewidth: typing.Optional[torch.Tensor] = Noneheight: typing.Optional[torch.Tensor] = Noneimage_embeds_position_mask: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneimage_embeds: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → transformers.models.kosmos2_5.modeling_kosmos2_5.Kosmos2_5ForConditionalGenerationModelOutput or tuple(torch.FloatTensor)

Paramètres

input_ids (torch.LongTensor de forme (batch_size, sequence_length)) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut si vous le fournissez.
Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.

Qu'est-ce que les identifiants d'entrée ?
flattened_patches (torch.FloatTensor de forme (batch_size, max_patches, 2 + patch_height * patch_width * image_channels)) — Patches aplatis des images. flattened_patches peut être obtenu à l'aide de AutoImageProcessor. Voir Kosmos2_5ImageProcessor.call() pour plus de détails.
width (torch.FloatTensor de forme (batch_size,)) — La largeur d'origine (avant redimensionnement) de chaque image du lot. Elle peut être obtenue à l'aide de AutoImageProcessor. Consultez Kosmos2_5ImageProcessor.call() pour plus de détails.
height (torch.FloatTensor de forme (batch_size,)) — La hauteur d'origine (avant redimensionnement) de chaque image du lot. Cela peut être obtenu à l'aide de AutoImageProcessor. Voir Kosmos2_5ImageProcessor.call() pour plus de détails.
image_embeds_position_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque indiquant l'emplacement dans une séquence où insérer les caractéristiques de l'image. Les valeurs du masque sont sélectionnées dans [0, 1]:
- 1 pour les emplacements où placer les caractéristiques d'image,
- 0 pour les positions qui ne correspondent pas aux caractéristiques d'image (c'est-à-dire pour les jetons de texte).
attention_mask (torch.Tensor de forme (batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans [0, 1]:
- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
Qu'est-ce que les masques d'attention ?
past_key_values (Cache de longueur config.n_layers où chaque tuple contient 4 tenseurs de forme (batch_size, num_heads, sequence_length - 1, embed_size_per_head)) — Contient les états cachés des clés et des valeurs précalculés des blocs d'attention. Peut être utilisé pour accélérer le décodage.
Si past_key_values sont utilisés, l’utilisateur peut éventuellement n’entrer que les derniers decoder_input_ids (ceux dont les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme (batch_size, 1) au lieu de tous les decoder_input_ids de forme (batch_size, sequence_length).
image_embeds — (torch.FloatTensor de forme (batch_size, latent_query_num, hidden_size), facultatif) : Séquence d'états cachés à la sortie de Kosmos2ImageToTextProjection.
inputs_embeds (torch.FloatTensor 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 que la matrice de recherche d’intégration interne du modèle.
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.max_position_embeddings - 1].
Qu'est-ce que les identifiants de position ?
use_cache (bool, facultatif) — Si défini sur True, les états clé-valeur past_key_values sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir past_key_values).
output_attentions (bool, facultatif) — Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Consultez attentions sous les tenseurs retournés pour plus de détails.
output_hidden_states (bool, facultatif) — Indique s'il faut retourner les états cachés de toutes les couches. Voir hidden_states sous les tenseurs retournés pour plus de détails.
labels (torch.LongTensor de forme (batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation du langage de gauche à droite (prédiction du mot suivant). Les indices doivent être dans [-100, 0, ..., config.vocab_size] (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 dans [0, ..., config.vocab_size]

Retourne

transformers.models.kosmos2_5.modeling_kosmos2_5.Kosmos2_5ForConditionalGenerationModelOutput ou tuple(torch.FloatTensor)

Un transformers.models.kosmos2_5.modeling_kosmos2_5.Kosmos2_5ForConditionalGenerationModelOutput ou un tuple de torch.FloatTensor (si return_dict=False est passé ou si config.return_dict=False) comprenant divers éléments en fonction de la configuration (<class 'transformers.models.kosmos2_5.configuration_kosmos2_5.Kosmos2_5Config'>) et des entrées.

loss (torch.FloatTensor de forme (1,), facultatif, renvoyé lorsque labels est fourni) — Perte de modélisation du langage (pour la prédiction du jeton suivant).
logits (torch.FloatTensor 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).
hidden_states (tuple(torch.FloatTensor), facultatif, renvoyé lorsque output_hidden_states=True est passé ou lorsque config.output_hidden_states=True) — Tuple de torch.FloatTensor (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.FloatTensor), facultatif, renvoyé lorsque output_attentions=True est passé ou lorsque config.output_attentions=True) — Tuple de torch.FloatTensor (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.
width (torch.FloatTensor de forme (batch_size,)) — La largeur d'origine (avant redimensionnement) de chaque image du lot.
height (torch.FloatTensor de forme (batch_size,)) — La hauteur d'origine (avant redimensionnement) de chaque image du lot.
image_embeds (torch.FloatTensor de forme (batch_size, latent_query_num, hidden_size), facultatif) — Séquence d'états cachés à la sortie de Kosmos2ImageToTextProjection.
projection_attentions (tuple(torch.FloatTensor), facultatif) — Tuple de torch.FloatTensor (un par couche) de forme (batch_size, num_heads, sequence_length, sequence_length).

Poids d'attention fournis par Kosmos2ImageToTextProjection, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
vision_model_output(BaseModelOutputWithPooling, facultatif) — La sortie du Kosmos2VisionModel.
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. 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ée past_key_values) pour accélérer le décodage séquentiel.

La méthode forward de Kosmos2_5ForConditionalGeneration surcharge la méthode spéciale __call__.

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

Exemples :

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

>>> repo = "microsoft/kosmos-2.5"
>>> device = "cuda:0"
>>> dtype = torch.bfloat16 # torch.float16
>>> model = Kosmos2_5ForConditionalGeneration.from_pretrained(repo, device_map=device, dtype=dtype)
>>> processor = AutoProcessor.from_pretrained(repo)

>>> url = "https://huggingface.co/microsoft/kosmos-2.5/resolve/main/receipt_00008.png"

>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> prompt = "<ocr>" # <md>

>>> inputs = processor(text=prompt, images=image, return_tensors="pt")
>>> height, width = inputs.pop("height"), inputs.pop("width")
>>> inputs = {k: v.to(device) if v is not None else None for k, v in inputs.items()}
>>> inputs["flattened_patches"] = inputs["flattened_patches"].to(dtype)

>>> generated_ids = model.generate(**inputs,max_new_tokens=1024)
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> generated_text
'<ocr><bbox><x_53><y_573><x_69><y_606></bbox>1\n<bbox><x_79><y_573><x_464><y_612></bbox>[REG] BLACK SAKURA\n<bbox><x_690><y_569><x_810><y_606></bbox>45,455\n<bbox><x_53><y_614><x_69><y_648></bbox>1\n<bbox><x_79><y_614><x_468><y_650></bbox>COOKIE DOH SAUCES\n<bbox><x_788><y_609><x_812><y_644></bbox>0\n<bbox><x_50><y_658><x_69><y_693></bbox>1\n<bbox><x_79><y_658><x_358><y_693></bbox>NATA DE COCO\n<bbox><x_790><y_652><x_814><y_687></bbox>0\n<bbox><x_31><y_742><x_820><y_781></bbox>Sub Total 45,455\n<bbox><x_27><y_781><x_822><y_827></bbox>PB1 (10%) 4,545\n<bbox><x_27><y_826><x_824><y_872></bbox>Rounding 0\n<bbox><x_24><y_872><x_827><y_921></bbox>Total 50,000\n<bbox><x_17><y_1056><x_836><y_1108></bbox>Card Payment 50,000\n'

Update on GitHub

←KOSMOS-2 LayoutLM→