# KOSMOS-2.5 Le modèle Kosmos-2.5 a été proposé dans [KOSMOS-2.5: A Multimodal Literate Model](https://huggingface.co/papers/2309.11419/) 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.* drawing drawing Aperçu des tâches que KOSMOS-2.5 peut traiter. Extrait de l'article original. Les exemples ci-dessous montrent comment générer avec [AutoModel](/docs/transformers/main/fr/model_doc/auto#transformers.AutoModel), pour les tâches Markdown et OCR. ```python import requests from PIL import Image from transformers import AutoProcessor, Kosmos2_5ForConditionalGeneration repo = "microsoft/kosmos-2.5" model = Kosmos2_5ForConditionalGeneration.from_pretrained(repo, device_map="auto") 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) prompt = "" 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]) ``` ```python import re import requests from PIL import Image, ImageDraw from transformers import AutoProcessor, Kosmos2_5ForConditionalGeneration repo = "microsoft/kosmos-2.5" model = Kosmos2_5ForConditionalGeneration.from_pretrained(repo, device_map="auto") 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) # bs = 1 prompt = "" 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 # bs > 1, batch generation # inputs = processor(text=[prompt, prompt], images=[image,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[0] # scale_width = raw_width / width[0] 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) def post_process(y, scale_height, scale_width): y = y.replace(prompt, "") if "" in prompt: return y pattern = r"" bboxs_raw = re.findall(pattern, y) lines = re.split(pattern, y)[1:] bboxs = [re.findall(r"\d+", i) for i in bboxs_raw] bboxs = [[int(j) for j in i] for i in bboxs] info = "" for i in range(len(lines)): box = bboxs[i] x0, y0, x1, y1 = box if not (x0 >= x1 or y0 >= y1): x0 = int(x0 * scale_width) y0 = int(y0 * scale_height) x1 = int(x1 * scale_width) y1 = int(y1 * scale_height) info += f"{x0},{y0},{x1},{y0},{x1},{y1},{x0},{y1},{lines[i]}" return info output_text = post_process(generated_text[0], scale_height, scale_width) print(output_text) draw = ImageDraw.Draw(image) lines = output_text.split("\n") for line in lines: # draw the bounding box line = list(line.split(",")) if len(line) < 8: continue line = list(map(int, line[:8])) draw.polygon(line, outline="red") image.save("output.png") ``` ## 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 : ```python 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 = "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[[transformers.Kosmos2_5Config]] #### transformers.Kosmos2_5Config[[transformers.Kosmos2_5Config]] ```python transformers.Kosmos2_5Config(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, latent_query_num: int = 2048, tie_word_embeddings: bool = True) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/kosmos2_5/configuration_kosmos2_5.py#L105) **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*, valeur par défaut `True`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle. Ceci est la classe de configuration destinée à stocker la configuration d'un modèle Kosmos2 5. Elle est utilisée pour instancier un modèle Kosmos2 5 en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [microsoft/kosmos-2.5](https://huggingface.co/microsoft/kosmos-2.5) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. ## Kosmos2_5TextConfig[[transformers.Kosmos2_5TextConfig]] #### transformers.Kosmos2_5TextConfig[[transformers.Kosmos2_5TextConfig]] ```python transformers.Kosmos2_5TextConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 108481, max_position_embeddings: int = 4096, embed_dim: int = 1536, layers: int = 24, ffn_dim: int = 6144, attention_heads: int = 16, activation_function: str = 'gelu', dropout: float | int = 0.1, attention_dropout: float | int = 0.0, activation_dropout: float | int = 0.0, layerdrop: float | int = 0.0, layer_norm_eps: float = 1e-05, init_std: float = 0.02, scale_embedding: bool = True, use_cache: bool = True, tie_word_embeddings: bool = True, pad_token_id: int | None = 1, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 2) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/kosmos2_5/configuration_kosmos2_5.py#L27) **Paramètres :** vocab_size (`int`, *facultatif*, valeur 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*, valeur par défaut `4096`) : La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. embed_dim (`int`, *facultatif*, valeur par défaut `1536`) : Dimension des embeddings et des états cachés. layers (`int`, *facultatif*, valeur par défaut `24`) : Nombre de couches cachées dans le décodeur Transformer. ffn_dim (`int`, *facultatif*, valeur par défaut `6144`) : Dimension des représentations 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) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc. dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.1`) : Le ratio pour toutes les couches de dropout. attention_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention. activation_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout pour les activations à l'intérieur de la couche entièrement connectée. layerdrop (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : La probabilité de LayerDrop. Consultez l'article [LayerDrop](see 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 l'initialisation de toutes les matrices de poids. scale_embedding (`bool`, *facultatif*, valeur 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). Pertinent uniquement si `config.is_decoder=True` ou si le modèle est un modèle génératif de type décodeur uniquement. tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut lier les embeddings de poids selon la correspondance `tied_weights_keys` du modèle. pad_token_id (`int`, *facultatif*, valeur par défaut `1`) : Identifiant du jeton utilisé pour le bourrage dans le vocabulaire. bos_token_id (`int`, *facultatif*, valeur 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*, valeur par défaut `2`) : Identifiant de jeton utilisé pour la fin de flux dans le vocabulaire. 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, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [microsoft/kosmos-2.5](https://huggingface.co/microsoft/kosmos-2.5) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. ## Kosmos2_5VisionConfig[[transformers.Kosmos2_5VisionConfig]] #### transformers.Kosmos2_5VisionConfig[[transformers.Kosmos2_5VisionConfig]] ```python transformers.Kosmos2_5VisionConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 1536, patch_embed_hidden_size: int = 768, intermediate_size: int = 3968, head_dim: int = 64, num_hidden_layers: int = 18, num_attention_heads: int = 24, dense_act_fn: str = 'gelu_new', layer_norm_eps: float = 1e-06, dropout_rate: float | int = 0.0, attention_dropout: float | int = 0.0, max_num_patches: int = 4096, initializer_factor: float = 1.0, initializer_range: float = 0.02) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/kosmos2_5/configuration_kosmos2_5.py#L60) **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) : Dimensionnalité de la couche d'entrée patch_embedding dans l'encodeur Transformer. intermediate_size (`int`, *facultatif*, valeur par défaut `3968`) : Dimension des représentations 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*, valeur 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"`) : 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*, par défaut `1e-06`) : L'épsilon utilisé par les couches de normalisation par couche. dropout_rate (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le ratio pour toutes les couches de dropout. attention_dropout (`Union[float, int]`, *facultatif*, valeur par défaut `0.0`) : Le taux de dropout appliqué aux probabilités d'attention. max_num_patches (`int`, *facultatif*, valeur par défaut 4096) : Longueur de séquence maximale (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*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids. 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, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [microsoft/kosmos-2.5](https://huggingface.co/microsoft/kosmos-2.5) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. Exemple : ```python >>> 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[[transformers.Kosmos2_5ImageProcessor]] #### transformers.Kosmos2_5ImageProcessor[[transformers.Kosmos2_5ImageProcessor]] ```python transformers.Kosmos2_5ImageProcessor(**kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/kosmos2_5/image_processing_kosmos2_5.py#L67) **Paramètres :** do_convert_rgb (`bool`, *kwargs*, *facultatif*, valeur 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écrit les dimensions d'entrée maximales du modèle. default_to_square (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut par défaut redimensionner l'image en un 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 d'une des valeurs de l'énumération `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 à appliquer à 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 ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage 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 rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à 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 assurer 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 (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). 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 la valeur est `'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 sera 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) : Nombre maximal de patches à extraire de l'image, conformément à l'[article KOSMOS 2.5](https://huggingface.co/papers/2309.11419). Construit un processeur d’images image_processor_class. #### prétraiter[[transformers.Kosmos2_5ImageProcessor.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/kosmos2_5/image_processing_kosmos2_5.py#L78) **Paramètres :** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Image à prétraiter. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez 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écrit les dimensions d'entrée maximales du modèle. default_to_square (`bool`, *kwargs*, *facultatif*) : Indique s'il faut par défaut redimensionner l'image en un carré lorsque 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 d'une des valeurs de l'énumération `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 redimensionnement à 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 ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage 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 rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à 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 assurer 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 (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). 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 la valeur est `'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 sera 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) : Nombre maximal de patches à extraire de l'image, conformément à l'[article KOSMOS 2.5](https://huggingface.co/papers/2309.11419). **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[[transformers.Kosmos2_5ImageProcessorPil]] #### transformers.Kosmos2_5ImageProcessorPil[[transformers.Kosmos2_5ImageProcessorPil]] ```python transformers.Kosmos2_5ImageProcessorPil(**kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/kosmos2_5/image_processing_pil_kosmos2_5.py#L74) **Paramètres :** do_convert_rgb (`bool`, *kwargs*, *facultatif*, valeur 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écrit les dimensions d'entrée maximales du modèle. default_to_square (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut par défaut redimensionner l'image en un 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 d'une des valeurs de l'énumération `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 à appliquer à 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 ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage 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 rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à 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 assurer 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 (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). 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 la valeur est `'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 sera 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) : Nombre maximal de patches à extraire de l'image, conformément à l'[article KOSMOS 2.5](https://huggingface.co/papers/2309.11419). Construit un processeur d’images image_processor_class. #### prétraiter[[transformers.Kosmos2_5ImageProcessorPil.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/kosmos2_5/image_processing_pil_kosmos2_5.py#L85) **Paramètres :** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Image à prétraiter. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez 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écrit les dimensions d'entrée maximales du modèle. default_to_square (`bool`, *kwargs*, *facultatif*) : Indique s'il faut par défaut redimensionner l'image en un carré lorsque 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 d'une des valeurs de l'énumération `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 redimensionnement à 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 ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage 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 rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à 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 assurer 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 (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). 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 la valeur est `'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 sera 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) : Nombre maximal de patches à extraire de l'image, conformément à l'[article KOSMOS 2.5](https://huggingface.co/papers/2309.11419). **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[[transformers.Kosmos2_5Processor]] #### transformers.Kosmos2_5Processor[[transformers.Kosmos2_5Processor]] ```python transformers.Kosmos2_5Processor(image_processor, tokenizer, num_image_tokens: int = 2048) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/kosmos2_5/processing_kosmos2_5.py#L45) **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](/docs/transformers/main/fr/model_doc/kosmos2_5#transformers.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. #### __appel__[[transformers.Kosmos2_5Processor.__call__]] ```python __call__(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, text: str | list[str] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/kosmos2_5/processing_kosmos2_5.py#L57) **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. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez 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îne pré-tokenisée). Si vous transmettez 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](/docs/transformers/main/fr/internal/file_utils#transformers.TensorType), *facultatif*) : Si défini, renverra des tenseurs d'un framework particulier. Les valeurs acceptables sont : - `'pt'` : Renvoie des objets `torch.Tensor` de PyTorch. - `'np'` : Renvoie des objets `np.ndarray` de NumPy. - ****kwargs** ([ProcessingKwargs](/docs/transformers/main/fr/main_classes/processors#transformers.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[[transformers.Kosmos2_5Model]] #### transformers.Kosmos2_5Model[[transformers.Kosmos2_5Model]] ```python transformers.Kosmos2_5Model(config: Kosmos2_5Config) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/kosmos2_5/modeling_kosmos2_5.py#L1149) **Paramètres :** config ([Kosmos2_5Config](/docs/transformers/main/fr/model_doc/kosmos2_5#transformers.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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux. #### forward[[transformers.Kosmos2_5Model.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, flattened_patches: typing.Optional[torch.Tensor] = None, width: typing.Optional[torch.Tensor] = None, height: typing.Optional[torch.Tensor] = None, image_embeds_position_mask: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, image_embeds: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/kosmos2_5/modeling_kosmos2_5.py#L1167) **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](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) flattened_patches (`torch.Tensor` 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](/docs/transformers/main/fr/model_doc/auto#transformers.AutoImageProcessor). Voir [Kosmos2_5ImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails. width (`torch.Tensor` de forme `(batch_size,)`) : La largeur d'origine (avant redimensionnement) de chaque image du lot. Cela peut être obtenu à l'aide de [AutoImageProcessor](/docs/transformers/main/fr/model_doc/auto#transformers.AutoImageProcessor). Voir [Kosmos2_5ImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails. height (`torch.Tensor` de forme `(batch_size,)`) : La hauteur d'origine (avant redimensionnement) de chaque image du lot. Cela peut être obtenu à l'aide de [AutoImageProcessor](/docs/transformers/main/fr/model_doc/auto#transformers.AutoImageProcessor). Voir [Kosmos2_5ImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__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 d'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 emplacements qui ne sont pas destinés aux caractéristiques d'image (c.-à-d. 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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) 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és 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.Tensor` de forme `(batch_size, latent_query_num, hidden_size)`, *facultatif*): Séquence d'états cachés à la sortie de `Kosmos2ImageToTextProjection`. inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. 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]`. [Que sont les position IDs ?](../glossary#position-ids) use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`). output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails. output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails. **Retourne :** `transformers.models.kosmos2_5.modeling_kosmos2_5.Kosmos2_5ModelOutput` ou `tuple(torch.Tensor)` Un `transformers.models.kosmos2_5.modeling_kosmos2_5.Kosmos2_5ModelOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou si `config.return_dict=False`) comprenant divers éléments selon la configuration (``) et les entrées. - **last_hidden_state** (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. - **width** (`torch.Tensor` de forme `(batch_size,)`) -- La largeur d'origine (avant redimensionnement) de chaque image du lot. - **height** (`torch.Tensor` de forme `(batch_size,)`) -- La hauteur d'origine (avant redimensionnement) de chaque image du lot. - **image_embeds** (`torch.Tensor` de forme `(batch_size, latent_query_num, hidden_size)`, *facultatif*) -- Séquence d'états cachés à la sortie de `Kosmos2ImageToTextProjection`. - **projection_attentions** (`tuple(torch.Tensor)`, *facultatif*) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations d'attention fournies par `Kosmos2ImageToTextProjection`, après le softmax d'attention, utilisées 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](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et, le cas échéant, si `config.is_encoder_decoder=True`, dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel. La méthode forward du modèle [Kosmos2_5Model](/docs/transformers/main/fr/model_doc/kosmos2_5#transformers.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 : ```python >>> 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 = ( ... " An image of a snowman" ... " warming himself by a fire" ... "" ... ) >>> 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[[transformers.Kosmos2_5ForConditionalGeneration]] #### transformers.Kosmos2_5ForConditionalGeneration[[transformers.Kosmos2_5ForConditionalGeneration]] ```python transformers.Kosmos2_5ForConditionalGeneration(config: Kosmos2_5Config) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/kosmos2_5/modeling_kosmos2_5.py#L1409) **Paramètres :** config ([Kosmos2_5Config](/docs/transformers/main/fr/model_doc/kosmos2_5#transformers.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()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.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. Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux. #### forward[[transformers.Kosmos2_5ForConditionalGeneration.forward]] ```python forward(input_ids: typing.Optional[torch.Tensor] = None, flattened_patches: typing.Optional[torch.Tensor] = None, width: typing.Optional[torch.Tensor] = None, height: typing.Optional[torch.Tensor] = None, image_embeds_position_mask: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, image_embeds: typing.Optional[torch.Tensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/kosmos2_5/modeling_kosmos2_5.py#L1432) **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](/docs/transformers/main/fr/model_doc/auto#transformers.AutoTokenizer). Consultez [PreTrainedTokenizer.encode()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) et [PreTrainedTokenizer.__call__()](/docs/transformers/main/fr/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) pour plus de détails. [Que sont les identifiants d'entrée ?](../glossary#input-ids) flattened_patches (`torch.Tensor` 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](/docs/transformers/main/fr/model_doc/auto#transformers.AutoImageProcessor). Voir [Kosmos2_5ImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails. width (`torch.Tensor` de forme `(batch_size,)`) : La largeur d'origine (avant redimensionnement) de chaque image du lot. Cela peut être obtenu à l'aide de [AutoImageProcessor](/docs/transformers/main/fr/model_doc/auto#transformers.AutoImageProcessor). Voir [Kosmos2_5ImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails. height (`torch.Tensor` de forme `(batch_size,)`) : La hauteur d'origine (avant redimensionnement) de chaque image du lot. Cela peut être obtenu à l'aide de [AutoImageProcessor](/docs/transformers/main/fr/model_doc/auto#transformers.AutoImageProcessor). Voir [Kosmos2_5ImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__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 d'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 emplacements qui ne sont pas destinés aux caractéristiques d'image (c.-à-d. 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 qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) 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és 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.Tensor` de forme `(batch_size, latent_query_num, hidden_size)`, *facultatif*): Séquence d'états cachés à la sortie de `Kosmos2ImageToTextProjection`. inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. 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]`. [Que sont les position IDs ?](../glossary#position-ids) use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`). output_attentions (`bool`, *facultatif*) : Indique s'il faut ou non retourner les tenseurs d'attention de toutes les couches d'attention. Voir `attentions` sous les tenseurs retournés pour plus de détails. output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails. 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.Tensor)` Un `transformers.models.kosmos2_5.modeling_kosmos2_5.Kosmos2_5ForConditionalGenerationModelOutput` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou si `config.return_dict=False`) comprenant divers éléments selon la configuration (``) et les entrées. - **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de modélisation du langage (pour la prédiction du jeton suivant). - **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.vocab_size)`) -- Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax). - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. - **width** (`torch.Tensor` de forme `(batch_size,)`) -- La largeur d'origine (avant redimensionnement) de chaque image du lot. - **height** (`torch.Tensor` de forme `(batch_size,)`) -- La hauteur d'origine (avant redimensionnement) de chaque image du lot. - **image_embeds** (`torch.Tensor` de forme `(batch_size, latent_query_num, hidden_size)`, *facultatif*) -- Séquence d'états cachés à la sortie de `Kosmos2ImageToTextProjection`. - **projection_attentions** (`tuple(torch.Tensor)`, *facultatif*) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations d'attention fournies par `Kosmos2ImageToTextProjection`, après le softmax d'attention, utilisées 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](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache). Pour plus de détails, consultez notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et, le cas échéant, si `config.is_encoder_decoder=True`, dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel. La méthode forward de [Kosmos2_5ForConditionalGeneration](/docs/transformers/main/fr/model_doc/kosmos2_5#transformers.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 : ```python >>> 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 = "" # >>> 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 '1\n[REG] BLACK SAKURA\n45,455\n1\nCOOKIE DOH SAUCES\n0\n1\nNATA DE COCO\n0\nSub Total 45,455\nPB1 (10%) 4,545\nRounding 0\nTotal 50,000\nCard Payment 50,000\n' ```