# HyperCLOVAX Vision V2 HyperCLOVAX Vision V2 é um modelo multimodal de visão e linguagem desenvolvido pela NAVER. Ele combina o backbone do modelo de linguagem [HyperClovaX](./hyperclovax) com um codificador de visão [Qwen2.5-VL](./qwen2_5_vl). O modelo suporta entradas de texto, imagem e vídeo e é capaz de raciocínio em cadeia de pensamento por meio de tokens de raciocínio integrados (`...`). Você pode encontrar o checkpoint original HyperCLOVAX-SEED-Think-32B na página [naver-hyperclovax/HyperCLOVAX-SEED-Think-32B](https://huggingface.co/naver-hyperclovax/HyperCLOVAX-SEED-Think-32B). O exemplo abaixo demonstra como gerar texto com base em uma imagem usando [AutoModelForImageTextToText](/docs/transformers/main/pt/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) ``` A quantização reduz a carga de memória de modelos grandes ao representar os pesos em uma precisão menor. Consulte a visão geral de [Quantização](../quantization/overview) para mais backends de quantização disponíveis. O exemplo abaixo usa [bitsandbytes](../quantization/bitsandbytes) para carregar o modelo em 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") ``` ## Observações - O modelo suporta raciocínio em cadeia de pensamento (chain-of-thought). Por padrão, o prompt de geração antecede um bloco `\n\n` vazio. Para gerar um rastro de raciocínio explícito dentro das tags `...`, passe `thinking=True` para `apply_chat_template` (somente entradas de imagem/texto): ```python inputs = processor.apply_chat_template( messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt", thinking=True, ).to(model.device) ``` - O modelo suporta conversas de múltiplas rodadas com mídias mistas. Imagens e vídeos podem aparecer em várias rodadas. ```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?"}, ], }, ] ``` - O modelo suporta chamadas de função/ferramenta. Passe as ferramentas usando o parâmetro `tools` em `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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hyperclovax_vision_v2/configuration_hyperclovax_vision_v2.py#L29) **Parâmetros:** text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de texto. vision_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de visão. image_token_id (`int`, *opcional*, padrão `128060`) : O índice do token de imagem usado como marcador para as imagens de entrada. video_token_id (`int`, *opcional*, padrão `128061`) : O índice do token de vídeo usado como marcador de posição para os vídeos de entrada. tie_word_embeddings (`bool`, *opcional*, padrão `True`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo. Esta é a classe de configuração para armazenar a configuração de um HyperCLOVAXVisionV2Model. Ela é usada para instanciar um modelo Hyperclovax Vision V2 de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do [naver-hyperclovax/HyperCLOVAX-SEED-Think-32B](https://huggingface.co/naver-hyperclovax/HyperCLOVAX-SEED-Think-32B) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. ```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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hyperclovax_vision_v2/processing_hyperclovax_vision_v2.py#L39) **Parâmetros:** image_processor (`Qwen2VLImageProcessor`) : O processador de imagem é uma entrada obrigatória. tokenizer (`GPT2Tokenizer`) : O tokenizer é uma entrada obrigatória. video_processor (`Qwen2VLVideoProcessor`) : O processador de vídeo é uma entrada obrigatória. chat_template (`str`) : Um modelo Jinja para converter listas de mensagens em um chat em uma string tokenizável. Constrói um HyperCLOVAXVisionV2Processor que encapsula um processador de imagem, um tokenizer e um processador de vídeo em um único processador. [HyperCLOVAXVisionV2Processor](/docs/transformers/main/pt/model_doc/hyperclovax_vision_v2#transformers.HyperCLOVAXVisionV2Processor) oferece todas as funcionalidades de [Qwen2VLImageProcessor](/docs/transformers/main/pt/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor), [GPT2Tokenizer](/docs/transformers/main/pt/model_doc/gpt2#transformers.GPT2Tokenizer) e [Qwen2VLVideoProcessor](/docs/transformers/main/pt/model_doc/qwen2_vl#transformers.Qwen2VLVideoProcessor). Consulte [~Qwen2VLImageProcessor](/docs/transformers/main/pt/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor), [~GPT2Tokenizer](/docs/transformers/main/pt/model_doc/gpt2#transformers.GPT2Tokenizer) e [~Qwen2VLVideoProcessor](/docs/transformers/main/pt/model_doc/qwen2_vl#transformers.Qwen2VLVideoProcessor) para mais informações. #### 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) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hyperclovax_vision_v2/processing_hyperclovax_vision_v2.py#L113) **Parâmetros:** generated_outputs (`torch.Tensor` ou `np.ndarray`) : A saída da função `generate` do modelo. A saída deve ser um tensor com a forma `(batch_size, sequence_length)` ou `(sequence_length,)`. skip_special_tokens (`bool`, *opcional*, padrão `True`) : Indica se os tokens especiais devem ser removidos na saída. Argumento passado para o método `batch_decode` do tokenizer. clean_up_tokenization_spaces (`bool`, *opcional*, padrão `False`) : Indica se os espaços de tokenização devem ser limpos ou não. Argumento passado para o método `batch_decode` do tokenizer. - ****kwargs** : Argumentos adicionais a serem passados para o `batch_decode method` do tokenizer. **Retorna:** `list[str]` O texto decodificado. Pós-processe a saída do modelo para decodificar o texto. ## HyperCLOVAXVisionV2Model[[transformers.HyperCLOVAXVisionV2Model]] #### transformers.HyperCLOVAXVisionV2Model[[transformers.HyperCLOVAXVisionV2Model]] ```python transformers.HyperCLOVAXVisionV2Model(config: HyperCLOVAXVisionV2Config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hyperclovax_vision_v2/modeling_hyperclovax_vision_v2.py#L51) **Parâmetros:** config ([HyperCLOVAXVisionV2Config](/docs/transformers/main/pt/model_doc/hyperclovax_vision_v2#transformers.HyperCLOVAXVisionV2Config)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. O modelo Hyperclovax Vision V2 sem processamento adicional, que gera os hidden-states brutos sem nenhum head específico no topo. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### 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: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hyperclovax_vision_v2/modeling_hyperclovax_vision_v2.py#L142) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). pixel_values (`torch.Tensor`, *opcional*) : Valores de pixels das imagens de entrada após o pré-processamento por [Qwen2VLImageProcessor](/docs/transformers/main/pt/model_doc/qwen2_vl#transformers.Qwen2VLImageProcessor). Um tensor 2D de forma `(total_num_patches, channels * patch_size^2 * temporal_patch_size)`. Na sequência de tokens de entrada, cada posição de imagem deve conter `config.image_token_id`. pixel_values_videos (`torch.Tensor`, *opcional*) : Valores de pixels dos vídeos de entrada, com o mesmo formato de `pixel_values`. image_grid_thw (`torch.LongTensor` de forma `(num_images, 3)`, *opcional*) : As dimensões temporal, de altura e de largura da grade de recursos para cada imagem. Cada linha contém as contagens da grade `[temporal, height, width]`. video_grid_thw (`torch.LongTensor` de forma `(num_videos, 3)`, *opcional*) : As dimensões temporal, de altura e de largura da grade de recursos para cada vídeo. mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *opcional*) : Dicionário em que as chaves são as modalidades suportadas e os valores são as saídas codificadas para essa modalidade. Cada saída codificada é uma tupla que consiste em (`pooler_output`, *opcional*: `last_hidden_states`, *opcional*: `hidden_states`, *opcional*: `attentions`) `pooler_output` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de recursos multimodais do codificador mesclados em incorporações de texto. **Retorna:** [CausalLMOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou `tuple(torch.Tensor)` Um [CausalLMOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([HyperCLOVAXVisionV2Config](/docs/transformers/main/pt/model_doc/hyperclovax_vision_v2#transformers.HyperCLOVAXVisionV2Config)) e das entradas. O método forward do [HyperCLOVAXVisionV2Model](/docs/transformers/main/pt/model_doc/hyperclovax_vision_v2#transformers.HyperCLOVAXVisionV2Model) sobrescreve o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem (para previsão do próximo token). - **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax). - **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. #### get_image_features[[transformers.HyperCLOVAXVisionV2Model.get_image_features]] ```python get_image_features(pixel_values: Tensor, image_grid_thw: LongTensor, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hyperclovax_vision_v2/modeling_hyperclovax_vision_v2.py#L80) **Parâmetros:** pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Os tensores correspondentes às imagens de entrada. image_grid_thw (`torch.LongTensor` de forma `(num_images, 3)`) : O tempo, a altura e a largura da forma dos recursos de cada imagem no LLM. **Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([HyperCLOVAXVisionV2Config](/docs/transformers/main/pt/model_doc/hyperclovax_vision_v2#transformers.HyperCLOVAXVisionV2Config)) e das entradas. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. #### get_video_features[[transformers.HyperCLOVAXVisionV2Model.get_video_features]] ```python get_video_features(pixel_values_videos: Tensor, video_grid_thw: LongTensor, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hyperclovax_vision_v2/modeling_hyperclovax_vision_v2.py#L65) **Parâmetros:** pixel_values_videos (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Os tensores correspondentes aos vídeos de entrada. video_grid_thw (`torch.LongTensor` de forma `(num_videos, 3)`) : O valor temporal, a altura e a largura da forma dos recursos de cada vídeo no LLM. **Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([HyperCLOVAXVisionV2Config](/docs/transformers/main/pt/model_doc/hyperclovax_vision_v2#transformers.HyperCLOVAXVisionV2Config)) e das entradas. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. ## HyperCLOVAXVisionV2ForConditionalGeneration[[transformers.HyperCLOVAXVisionV2ForConditionalGeneration]] #### transformers.HyperCLOVAXVisionV2ForConditionalGeneration[[transformers.HyperCLOVAXVisionV2ForConditionalGeneration]] ```python transformers.HyperCLOVAXVisionV2ForConditionalGeneration(config: HyperCLOVAXVisionV2Config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hyperclovax_vision_v2/modeling_hyperclovax_vision_v2.py#L230) **Parâmetros:** config ([HyperCLOVAXVisionV2Config](/docs/transformers/main/pt/model_doc/hyperclovax_vision_v2#transformers.HyperCLOVAXVisionV2Config)) : Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. O Modelo Hyperclovax Vision V2 para geração de tokens condicionada a outras modalidades (por exemplo, geração de texto a partir de imagem e texto). Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel). Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.). Este modelo também é uma subclasse de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso e comportamento gerais. #### 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: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hyperclovax_vision_v2/modeling_hyperclovax_vision_v2.py#L278) **Parâmetros:** input_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada no vocabulário. O preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) pixel_values (`torch.Tensor`, *opcional*) : Valores de pixels das imagens de entrada após o pré-processamento. pixel_values_videos (`torch.Tensor`, *opcional*) : Valores de pixels dos vídeos de entrada, no mesmo formato que `pixel_values`. image_grid_thw (`torch.LongTensor` de forma `(num_images, 3)`, *opcional*) : contagens de grade `[temporal, height, width]` por imagem. video_grid_thw (`torch.LongTensor` de forma `(num_videos, 3)`, *opcional*) : contagens de grade `[temporal, height, width]` por vídeo. attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em `[0, 1]`: - 1 para tokens que **não estão mascarados**, - 0 para tokens que **estão mascarados**. [O que são máscaras de atenção?](../glossary#attention-mask) position_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo `[0, config.n_positions - 1]`. [O que são IDs de posição?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para este modelo) com a forma `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com a forma `(batch_size, sequence_length)`. inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo. labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de modelagem de linguagem mascarada. use_cache (`bool`, *opcional*) : Se definido como `True`, os estados de chave-valor de `past_key_values` são retornados e podem ser usados para acelerar a decodificação (veja `past_key_values`). logits_to_keep (`int` ou `torch.Tensor`, *opcional*, padrão 0) : Se for um `int`, calcula os logits para os últimos `logits_to_keep` tokens. mm_encoder_outputs (`dict[str, ~modeling_outputs.BaseModelOutputWithPooling]`, *opcional*) : Dicionário em que as chaves são as modalidades suportadas e os valores são as saídas codificadas para essa modalidade. Cada saída codificada é uma tupla que consiste em (`pooler_output`, *opcional*: `last_hidden_states`, *opcional*: `hidden_states`, *opcional*: `attentions`) `pooler_output` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) é uma sequência de recursos multimodais do codificador mesclados em incorporações de texto. **Retorna:** [CausalLMOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou `tuple(torch.Tensor)` Um [CausalLMOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([HyperCLOVAXVisionV2Config](/docs/transformers/main/pt/model_doc/hyperclovax_vision_v2#transformers.HyperCLOVAXVisionV2Config)) e das entradas. O método forward de [HyperCLOVAXVisionV2ForConditionalGeneration](/docs/transformers/main/pt/model_doc/hyperclovax_vision_v2#transformers.HyperCLOVAXVisionV2ForConditionalGeneration) substitui o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem (para previsão do próximo token). - **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax). - **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Exemplo: ```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: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hyperclovax_vision_v2/modeling_hyperclovax_vision_v2.py#L265) **Parâmetros:** pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Os tensores correspondentes às imagens de entrada. image_grid_thw (`torch.LongTensor` de forma `(num_images, 3)`, *opcional*) : O tempo, a altura e a largura da forma dos recursos de cada imagem no LLM. **Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([HyperCLOVAXVisionV2Config](/docs/transformers/main/pt/model_doc/hyperclovax_vision_v2#transformers.HyperCLOVAXVisionV2Config)) e das entradas. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Exemplo: ```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: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/hyperclovax_vision_v2/modeling_hyperclovax_vision_v2.py#L252) **Parâmetros:** pixel_values_videos (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Os tensores correspondentes aos vídeos de entrada. video_grid_thw (`torch.LongTensor` de forma `(num_videos, 3)`, *opcional*) : O valor temporal, a altura e a largura da forma dos recursos de cada vídeo no LLM. **Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([HyperCLOVAXVisionV2Config](/docs/transformers/main/pt/model_doc/hyperclovax_vision_v2#transformers.HyperCLOVAXVisionV2Config)) e das entradas. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Exemplo: ```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] ```