# HyperCLOVAX Vision V2 HyperCLOVAX Vision V2 est un modèle multimodal vision-langage développé par NAVER. Il combine le socle du modèle de langage [HyperClovaX](./hyperclovax) avec un encodeur visuel [Qwen2.5-VL](./qwen2_5_vl). Le modèle prend en charge les entrées texte, image et vidéo et est capable de raisonnement par chaîne de pensée grâce à des jetons de réflexion intégrés (`...`). Vous pouvez trouver le point de contrôle original HyperCLOVAX-SEED-Think-32B sur la page [naver-hyperclovax/HyperCLOVAX-SEED-Think-32B](https://huggingface.co/naver-hyperclovax/HyperCLOVAX-SEED-Think-32B). L'exemple ci-dessous montre comment générer du texte à partir d'une image avec [AutoModelForImageTextToText](/docs/transformers/main/fr/model_doc/auto#transformers.AutoModelForImageTextToText). ```python from transformers import AutoModelForImageTextToText, AutoProcessor model = AutoModelForImageTextToText.from_pretrained( "naver-hyperclovax/HyperCLOVAX-SEED-Think-32B", device_map="auto", ) processor = AutoProcessor.from_pretrained("naver-hyperclovax/HyperCLOVAX-SEED-Think-32B") messages = [ { "role": "system", "content": "You are a helpful assistant.", }, { "role": "user", "content": [ { "type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg", }, {"type": "text", "text": "Describe this image."}, ], }, ] inputs = processor.apply_chat_template( messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt", ).to(model.device) generated_ids = model.generate(**inputs, max_new_tokens=256) generated_ids_trimmed = [ out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids) ] output_text = processor.batch_decode( generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False ) print(output_text) ``` ```python from transformers import AutoModelForImageTextToText, AutoProcessor model = AutoModelForImageTextToText.from_pretrained( "naver-hyperclovax/HyperCLOVAX-SEED-Think-32B", device_map="auto", ) processor = AutoProcessor.from_pretrained("naver-hyperclovax/HyperCLOVAX-SEED-Think-32B") messages = [ { "role": "system", "content": "You are a helpful assistant.", }, { "role": "user", "content": [ { "type": "video", "url": "/path/to/video.mp4", }, {"type": "text", "text": "Describe this video."}, ], }, ] inputs = processor.apply_chat_template( messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt", ).to(model.device) generated_ids = model.generate(**inputs, max_new_tokens=256) generated_ids_trimmed = [ out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids) ] output_text = processor.batch_decode( generated_ids_trimmed, skip_special_tokens=True, clean_up_tokenization_spaces=False ) print(output_text) ``` La quantification réduit la charge mémoire des grands modèles en représentant les poids avec une précision inférieure. Reportez-vous à l'aperçu de la [Quantization](../quantization/overview) pour plus d'informations sur les backends de quantification disponibles. L'exemple ci-dessous utilise [bitsandbytes](../quantization/bitsandbytes) pour charger le modèle en 4 bits. ```python from transformers import AutoModelForImageTextToText, AutoProcessor, BitsAndBytesConfig quantization_config = BitsAndBytesConfig(load_in_4bit=True) model = AutoModelForImageTextToText.from_pretrained( "naver-hyperclovax/HyperCLOVAX-SEED-Think-32B", device_map="auto", quantization_config=quantization_config, ) processor = AutoProcessor.from_pretrained("naver-hyperclovax/HyperCLOVAX-SEED-Think-32B") ``` ## Notes - Le modèle prend en charge le raisonnement par chaîne de pensée. Par défaut, le prompt de génération préfixe un bloc `\n\n` vide. Pour générer une trace de raisonnement explicite dans les balises `...`, passez `thinking=True` à `apply_chat_template` (entrées image/texte uniquement) : ```python inputs = processor.apply_chat_template( messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt", thinking=True, ).to(model.device) ``` - Le modèle prend en charge les conversations multi-tours avec des médias mixtes. Des images et des vidéos peuvent apparaître sur plusieurs tours. ```python messages = [ { "role": "user", "content": [ {"type": "image", "url": "https://example.com/image1.jpg"}, {"type": "text", "text": "What do you see in this image?"}, ], }, { "role": "assistant", "content": "I see a cat sitting on a couch.", }, { "role": "user", "content": [ {"type": "image", "url": "https://example.com/image2.jpg"}, {"type": "text", "text": "How does this compare to the first image?"}, ], }, ] ``` - Le modèle prend en charge l'appel de fonctions/outils. Passez les outils à l'aide du paramètre `tools` dans `apply_chat_template` : ```python tools = [ { "type": "function", "function": { "name": "get_weather", "description": "Get the current weather for a location.", "parameters": { "type": "object", "properties": { "location": {"type": "string", "description": "City name"}, }, "required": ["location"], }, }, } ] messages = [ {"role": "user", "content": "What is the weather in Seoul?"} ] inputs = processor.apply_chat_template( messages, tools=tools, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt", ).to(model.device) ``` ## HyperCLOVAXVisionV2Config[[transformers.HyperCLOVAXVisionV2Config]] #### transformers.HyperCLOVAXVisionV2Config[[transformers.HyperCLOVAXVisionV2Config]] ```python transformers.HyperCLOVAXVisionV2Config(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, image_token_id: int = 128060, video_token_id: int = 128061, tie_word_embeddings: bool = True) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hyperclovax_vision_v2/configuration_hyperclovax_vision_v2.py#L29) **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. image_token_id (`int`, *facultatif*, valeur par défaut `128060`) : L'index du jeton d'image utilisé comme espace réservé pour les images d'entrée. video_token_id (`int`, *facultatif*, valeur par défaut `128061`) : L'index du jeton vidéo utilisé comme espace réservé pour les vidéos d'entrée. tie_word_embeddings (`bool`, *facultatif*, valeur par défaut `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 HyperCLOVAXVisionV2Model. Elle est utilisée pour instancier un modèle Hyperclovax Vision V2 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 [naver-hyperclovax/HyperCLOVAX-SEED-Think-32B](https://huggingface.co/naver-hyperclovax/HyperCLOVAX-SEED-Think-32B) 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. ```python >>> from transformers import HyperCLOVAXVisionV2Config, HyperCLOVAXVisionV2ForConditionalGeneration >>> # Initializing a HyperCLOVAX Vision V2 configuration with defaults >>> configuration = HyperCLOVAXVisionV2Config() >>> # Initializing a model from the configuration >>> model = HyperCLOVAXVisionV2ForConditionalGeneration(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## HyperCLOVAXVisionV2Processor[[transformers.HyperCLOVAXVisionV2Processor]] #### transformers.HyperCLOVAXVisionV2Processor[[transformers.HyperCLOVAXVisionV2Processor]] ```python transformers.HyperCLOVAXVisionV2Processor(image_processor = None, tokenizer = None, video_processor = None, chat_template = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hyperclovax_vision_v2/processing_hyperclovax_vision_v2.py#L39) **Paramètres :** image_processor (`Qwen2VLImageProcessor`) : le processeur d'images est une entrée obligatoire. tokenizer (`GPT2Tokenizer`) : le tokenizer est une entrée obligatoire. video_processor (`Qwen2VLVideoProcessor`) : le processeur vidéo est une entrée obligatoire. chat_template (`str`) : Un modèle Jinja pour convertir des listes de messages d'une conversation en une chaîne tokenisable. Construit un HyperCLOVAXVisionV2Processor qui encapsule un processeur d’images, un tokeniseur et un processeur de vidéos en un seul processeur. [HyperCLOVAXVisionV2Processor](/docs/transformers/main/fr/model_doc/hyperclovax_vision_v2#transformers.HyperCLOVAXVisionV2Processor) offre toutes les fonctionnalités de [Qwen2VLImageProcessor](/docs/transformers/main/fr/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor), [GPT2Tokenizer](/docs/transformers/main/fr/model_doc/gpt2#transformers.GPT2Tokenizer) et [Qwen2VLVideoProcessor](/docs/transformers/main/fr/model_doc/qwen2_vl#transformers.Qwen2VLVideoProcessor). Consultez [~Qwen2VLImageProcessor](/docs/transformers/main/fr/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor), [~GPT2Tokenizer](/docs/transformers/main/fr/model_doc/gpt2#transformers.GPT2Tokenizer) et [~Qwen2VLVideoProcessor](/docs/transformers/main/fr/model_doc/qwen2_vl#transformers.Qwen2VLVideoProcessor) pour plus d’informations. #### post_process_image_text_to_text[[transformers.HyperCLOVAXVisionV2Processor.post_process_image_text_to_text]] ```python post_process_image_text_to_text(generated_outputs, skip_special_tokens = True, clean_up_tokenization_spaces = False, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hyperclovax_vision_v2/processing_hyperclovax_vision_v2.py#L113) **Paramètres :** generated_outputs (`torch.Tensor` ou `np.ndarray`) : La sortie de la fonction `generate` du modèle. La sortie est censée être un tenseur de forme `(batch_size, sequence_length)` ou `(sequence_length,)`. skip_special_tokens (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut supprimer les jetons spéciaux dans la sortie. Argument transmis à la méthode `batch_decode` du tokeniseur. clean_up_tokenization_spaces (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut nettoyer les espaces de tokenisation. Argument transmis à la méthode `batch_decode` du tokenizer. - ****kwargs** : Arguments supplémentaires à transmettre à la méthode `batch_decode method` du tokenizer. **Retourne :** `list[str]` Le texte décodé. Post-traitez la sortie du modèle pour décoder le texte. ## HyperCLOVAXVisionV2Model[[transformers.HyperCLOVAXVisionV2Model]] #### transformers.HyperCLOVAXVisionV2Model[[transformers.HyperCLOVAXVisionV2Model]] ```python transformers.HyperCLOVAXVisionV2Model(config: HyperCLOVAXVisionV2Config) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hyperclovax_vision_v2/modeling_hyperclovax_vision_v2.py#L51) **Paramètres :** config ([HyperCLOVAXVisionV2Config](/docs/transformers/main/fr/model_doc/hyperclovax_vision_v2#transformers.HyperCLOVAXVisionV2Config)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Le modèle Hyperclovax Vision V2 brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet. Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux. #### forward[[transformers.HyperCLOVAXVisionV2Model.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, pixel_values: typing.Optional[torch.Tensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, image_grid_thw: typing.Optional[torch.LongTensor] = None, video_grid_thw: typing.Optional[torch.LongTensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hyperclovax_vision_v2/modeling_hyperclovax_vision_v2.py#L142) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/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) attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`. [Que sont les identifiants de position ?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`. Seule une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/main/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut. Le modèle renverra le même format de cache que celui fourni en entrée. Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. use_cache (`bool`, *facultatif*) : Si défini sur `True`, les états clé-valeur de `past_key_values` sont renvoyés et peuvent être utilisés pour accélérer le décodage (voir `past_key_values`). pixel_values (`torch.Tensor`, *facultatif*) : Valeurs des pixels des images d'entrée après prétraitement par [Qwen2VLImageProcessor](/docs/transformers/main/fr/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor). Un tenseur 2D de forme `(total_num_patches, channels * patch_size^2 * temporal_patch_size)`. Dans la séquence de jetons d'entrée, chaque position d'image doit contenir `config.image_token_id`. pixel_values_videos (`torch.Tensor`, *facultatif*) : Valeurs des pixels des vidéos d'entrée, avec le même format que `pixel_values`. image_grid_thw (`torch.LongTensor` de forme `(num_images, 3)`, *facultatif*) : Les dimensions temporelle, de hauteur et de largeur de la grille de caractéristiques pour chaque image. Chaque ligne contient les compteurs de grille `[temporal, height, width]`. video_grid_thw (`torch.LongTensor` de forme `(num_videos, 3)`, *facultatif*) : Les dimensions temporelle, de hauteur et de largeur de la grille de caractéristiques pour chaque vidéo. mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *facultatif*) : Dictionnaire dont les clés sont les modalités prises en charge et les valeurs sont les sorties encodées pour cette modalité. Chaque sortie encodée est un tuple composé de (`pooler_output`, *facultatif* : `last_hidden_states`, *facultatif* : `hidden_states`, *facultatif* : `attentions`) `pooler_output` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) est une séquence de fonctionnalités multimodales de l'encodeur fusionnées dans les embeddings de texte. **Retourne :** [CausalLMOutputWithPast](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou `tuple(torch.Tensor)` Un [CausalLMOutputWithPast](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([HyperCLOVAXVisionV2Config](/docs/transformers/main/fr/model_doc/hyperclovax_vision_v2#transformers.HyperCLOVAXVisionV2Config)) et les entrées. La méthode forward du modèle [HyperCLOVAXVisionV2Model](/docs/transformers/main/fr/model_doc/hyperclovax_vision_v2#transformers.HyperCLOVAXVisionV2Model) redéfinit la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. - **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de modélisation du langage (pour la prédiction du jeton suivant). - **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.vocab_size)`) -- Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax). - **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/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) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. #### get_image_features[[transformers.HyperCLOVAXVisionV2Model.get_image_features]] ```python get_image_features(pixel_values: Tensor, image_grid_thw: LongTensor, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hyperclovax_vision_v2/modeling_hyperclovax_vision_v2.py#L80) **Paramètres :** pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux images d'entrée. image_grid_thw (`torch.LongTensor` de forme `(num_images, 3)`) : La dimension temporelle, la hauteur et la largeur de la forme des caractéristiques de chaque image dans le LLM. **Retourne :** [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Un [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([HyperCLOVAXVisionV2Config](/docs/transformers/main/fr/model_doc/hyperclovax_vision_v2#transformers.HyperCLOVAXVisionV2Config)) 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. - **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. #### get_video_features[[transformers.HyperCLOVAXVisionV2Model.get_video_features]] ```python get_video_features(pixel_values_videos: Tensor, video_grid_thw: LongTensor, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hyperclovax_vision_v2/modeling_hyperclovax_vision_v2.py#L65) **Paramètres :** pixel_values_videos (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux vidéos d'entrée. video_grid_thw (`torch.LongTensor` de forme `(num_videos, 3)`) : La dimension temporelle, la hauteur et la largeur de la forme des caractéristiques de chaque vidéo dans le LLM. **Retourne :** [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Un [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([HyperCLOVAXVisionV2Config](/docs/transformers/main/fr/model_doc/hyperclovax_vision_v2#transformers.HyperCLOVAXVisionV2Config)) 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. - **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. ## HyperCLOVAXVisionV2ForConditionalGeneration[[transformers.HyperCLOVAXVisionV2ForConditionalGeneration]] #### transformers.HyperCLOVAXVisionV2ForConditionalGeneration[[transformers.HyperCLOVAXVisionV2ForConditionalGeneration]] ```python transformers.HyperCLOVAXVisionV2ForConditionalGeneration(config: HyperCLOVAXVisionV2Config) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hyperclovax_vision_v2/modeling_hyperclovax_vision_v2.py#L230) **Paramètres :** config ([HyperCLOVAXVisionV2Config](/docs/transformers/main/fr/model_doc/hyperclovax_vision_v2#transformers.HyperCLOVAXVisionV2Config)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L'initialisation à partir d'un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Le modèle Hyperclovax Vision V2 pour la génération de jetons conditionnée sur d'autres modalités (par exemple, la génération texte-image-vers-texte). Ce modèle hérite de [PreTrainedModel](/docs/transformers/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.HyperCLOVAXVisionV2ForConditionalGeneration.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, image_grid_thw: typing.Optional[torch.LongTensor] = None, video_grid_thw: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: 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, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hyperclovax_vision_v2/modeling_hyperclovax_vision_v2.py#L278) **Paramètres :** input_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut. Les indices peuvent être obtenus à l'aide de [AutoTokenizer](/docs/transformers/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) pixel_values (`torch.Tensor`, *facultatif*) : Valeurs des pixels des images d'entrée après prétraitement. pixel_values_videos (`torch.Tensor`, *facultatif*) : Valeurs des pixels des vidéos d'entrée, même format que `pixel_values`. image_grid_thw (`torch.LongTensor` de forme `(num_images, 3)`, *facultatif*) : `[temporal, height, width]` nombre de cellules de la grille par image. video_grid_thw (`torch.LongTensor` de forme `(num_videos, 3)`, *facultatif*) : `[temporal, height, width]` nombre de cellules de la grille par vidéo. attention_mask (`torch.Tensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans `[0, 1]` : - 1 pour les jetons qui ne sont **pas masqués**, - 0 pour les jetons qui sont **masqués**. [Qu'est-ce qu'un masque d'attention ?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle `[0, config.n_positions - 1]`. [Que sont les identifiants de position ?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *facultatif*) : États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Il s'agit généralement des `past_key_values` renvoyés par le modèle à une étape antérieure du décodage, lorsque `use_cache=True` ou `config.use_cache=True`. Seule une instance de [Cache](/docs/transformers/main/fr/internal/generation_utils#transformers.Cache) est autorisée en entrée, voir notre [guide sur le cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Si aucun `past_key_values` n'est transmis, [DynamicCache](/docs/transformers/main/fr/internal/generation_utils#transformers.DynamicCache) est initialisé par défaut. Le modèle renverra le même format de cache que celui fourni en entrée. Si `past_key_values` sont utilisés, l'utilisateur doit fournir uniquement les `input_ids` non traités (ceux pour lesquels les états de clés et de valeurs passées ne sont pas fournis à ce modèle) de forme `(batch_size, unprocessed_length)` au lieu de tous les `input_ids` de forme `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) : Facultativement, au lieu de passer `input_ids`, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indices `input_ids` en vecteurs associés, par rapport à la matrice de recherche d'intégration interne du modèle. labels (`torch.LongTensor` de forme `(batch_size, sequence_length)`, *facultatif*) : Étiquettes pour le calcul de la perte de modélisation de langage masqué. 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`). logits_to_keep (`int` ou `torch.Tensor`, *facultatif*, valeur par défaut 0) : Si c'est un `int`, calcule les logits pour les `logits_to_keep` derniers jetons. mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *facultatif*) : Dictionnaire dont les clés sont les modalités prises en charge et les valeurs sont les sorties encodées pour cette modalité. Chaque sortie encodée est un tuple composé de (`pooler_output`, *facultatif* : `last_hidden_states`, *facultatif* : `hidden_states`, *facultatif* : `attentions`) `pooler_output` de forme `(batch_size, sequence_length, hidden_size)`, *facultatif*) est une séquence de fonctionnalités multimodales de l'encodeur fusionnées dans les embeddings de texte. **Retourne :** [CausalLMOutputWithPast](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou `tuple(torch.Tensor)` Un [CausalLMOutputWithPast](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([HyperCLOVAXVisionV2Config](/docs/transformers/main/fr/model_doc/hyperclovax_vision_v2#transformers.HyperCLOVAXVisionV2Config)) et les entrées. La méthode forward de [HyperCLOVAXVisionV2ForConditionalGeneration](/docs/transformers/main/fr/model_doc/hyperclovax_vision_v2#transformers.HyperCLOVAXVisionV2ForConditionalGeneration) 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. - **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de modélisation du langage (pour la prédiction du jeton suivant). - **logits** (`torch.Tensor` de forme `(batch_size, sequence_length, config.vocab_size)`) -- Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax). - **past_key_values** (`Cache`, *facultatif*, renvoyé lorsque `use_cache=True` est passé ou lorsque `config.use_cache=True`) -- Il s'agit d'une instance de [Cache](/docs/transformers/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) qui peuvent être utilisés (voir l'entrée `past_key_values`) pour accélérer le décodage séquentiel. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. Exemple : ```python >>> from PIL import Image >>> import requests >>> from transformers import AutoProcessor, HyperCLOVAXVisionV2ForConditionalGeneration >>> model = HyperCLOVAXVisionV2ForConditionalGeneration.from_pretrained( ... "naver-hyperclovax/HyperCLOVAX-SEED-Think-32B", device_map="auto" ... ) >>> processor = AutoProcessor.from_pretrained("naver-hyperclovax/HyperCLOVAX-SEED-Think-32B") >>> messages = [ ... {"role": "user", "content": [ ... {"type": "image", "url": "http://images.cocodataset.org/val2017/000000039769.jpg"}, ... {"type": "text", "text": "Describe this image in detail."}, ... ]} ... ] >>> inputs = processor.apply_chat_template( ... messages, tokenize=True, return_dict=True, add_generation_prompt=True, return_tensors="pt" ... ).to(model.device) >>> output = model.generate(**inputs, max_new_tokens=200) >>> processor.decode(output[0], skip_special_tokens=True) ``` #### get_image_features[[transformers.HyperCLOVAXVisionV2ForConditionalGeneration.get_image_features]] ```python get_image_features(pixel_values: Tensor, image_grid_thw: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hyperclovax_vision_v2/modeling_hyperclovax_vision_v2.py#L265) **Paramètres :** pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux images d'entrée. image_grid_thw (`torch.LongTensor` de forme `(num_images, 3)`, *facultatif*) : La dimension temporelle, la hauteur et la largeur de la forme des caractéristiques de chaque image dans le LLM. **Retourne :** [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Un [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([HyperCLOVAXVisionV2Config](/docs/transformers/main/fr/model_doc/hyperclovax_vision_v2#transformers.HyperCLOVAXVisionV2Config)) 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. - **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. Exemple : ```python >>> from PIL import Image >>> from transformers import AutoProcessor, HyperCLOVAXVisionV2ForConditionalGeneration >>> model = HyperCLOVAXVisionV2ForConditionalGeneration.from_pretrained("naver-hyperclovax/HyperCLOVAX-SEED-Think-32B") >>> processor = AutoProcessor.from_pretrained("naver-hyperclovax/HyperCLOVAX-SEED-Think-32B") >>> messages = [ ... { ... "role": "user", "content": [ ... {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"}, ... {"type": "text", "text": "Where is the cat standing?"}, ... ] ... }, ... ] >>> inputs = processor.apply_chat_template( ... messages, ... tokenize=True, ... return_dict=True, ... return_tensors="pt", ... add_generation_prompt=True ... ) >>> # Generate >>> generate_ids = model.generate(**inputs) >>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0] ``` #### get_video_features[[transformers.HyperCLOVAXVisionV2ForConditionalGeneration.get_video_features]] ```python get_video_features(pixel_values_videos: Tensor, video_grid_thw: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hyperclovax_vision_v2/modeling_hyperclovax_vision_v2.py#L252) **Paramètres :** pixel_values_videos (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`) : Les tenseurs correspondant aux vidéos d'entrée. video_grid_thw (`torch.LongTensor` de forme `(num_videos, 3)`, *facultatif*) : La dimension temporelle, la hauteur et la largeur de la forme des caractéristiques de chaque vidéo dans le LLM. **Retourne :** [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Un [BaseModelOutputWithPooling](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([HyperCLOVAXVisionV2Config](/docs/transformers/main/fr/model_doc/hyperclovax_vision_v2#transformers.HyperCLOVAXVisionV2Config)) 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. - **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque couche) de forme `(batch_size, sequence_length, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, sequence_length, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. Exemple : ```python >>> from PIL import Image >>> from transformers import AutoProcessor, HyperCLOVAXVisionV2ForConditionalGeneration >>> model = HyperCLOVAXVisionV2ForConditionalGeneration.from_pretrained("naver-hyperclovax/HyperCLOVAX-SEED-Think-32B") >>> processor = AutoProcessor.from_pretrained("naver-hyperclovax/HyperCLOVAX-SEED-Think-32B") >>> messages = [ ... { ... "role": "user", "content": [ ... {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"}, ... {"type": "text", "text": "Where is the cat standing?"}, ... ] ... }, ... ] >>> inputs = processor.apply_chat_template( ... messages, ... tokenize=True, ... return_dict=True, ... return_tensors="pt", ... add_generation_prompt=True ... ) >>> # Generate >>> generate_ids = model.generate(**inputs) >>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0] ```