# Molmo2 [Molmo2](https://huggingface.co/papers/2601.10611) é uma família de modelos de visão-linguagem de pesos abertos da AllenAI que estão no estado da arte entre os modelos de código aberto, com capacidades excepcionais em ancoragem orientada por pontos para tarefas de imagem única, múltiplas imagens e vídeo. A arquitetura combina um Vision Transformer (ViT) para processamento de imagens com uma camada de adaptador que conecta as modalidades de visão e texto, e um decodificador de texto baseado em arquitetura de transformer com embeddings de posição rotativos. O resumo do artigo é o seguinte: *Os modelos de vídeo e linguagem (VLMs) mais fortes de hoje em dia permanecem proprietários. Os modelos de pesos abertos mais fortes ou dependem de dados sintéticos de VLMs proprietárias, efetivamente destilando a partir delas, ou não divulgam seus dados de treinamento ou receita. Como resultado, a comunidade de código aberto carece das fundações necessárias para melhorar os modelos de linguagem de vídeo (e imagem) do estado da arte. Crucialmente, muitas aplicações downstream exigem mais do que apenas compreensão de vídeo de alto nível; elas exigem ancoragem -- seja por apontar ou por rastrear em pixels. Mesmo os modelos proprietários carecem dessa capacidade. Apresentamos o Molmo2, uma nova família de VLMs que é do estado da arte entre os modelos de código aberto e demonstra novas capacidades excepcionais em ancoragem dirigida por pontos em tarefas de imagem única, múltiplas imagens e vídeo. Nossa principal contribuição é uma coleção de 7 novos conjuntos de dados de vídeo e 2 conjuntos de dados de múltiplas imagens, incluindo um conjunto de dados de legendas de vídeo altamente detalhadas para pré-treinamento, um conjunto de dados de perguntas e respostas de vídeo em formato livre para ajuste fino, um novo conjunto de dados de rastreamento de objetos com consultas complexas e um inovador novo conjunto de dados de apontamento de vídeo, todos coletados sem o uso de VLMs fechadas. Também apresentamos uma receita de treinamento para esses dados que utiliza um esquema eficiente de empacotamento e codificação de árvore de mensagens, e mostramos que a atenção bidirecional em tokens de visão e uma nova estratégia de ponderação de tokens melhoram o desempenho. Nosso melhor modelo de 8B supera outros na classe de modelos de pesos e dados abertos em vídeos curtos, contagem e legendagem, e é competitivo em vídeos longos. Em ancoragem de vídeo, o Molmo2 supera significativamente os modelos de pesos abertos existentes, como o Qwen3-VL (35,5 vs 29,6 de precisão na contagem de vídeo) e supera modelos proprietários, como o Gemini 3 Pro, em algumas tarefas (38,4 vs 20,0 F1 no apontamento de vídeo e 56,2 vs 41,1 J&F no rastreamento de vídeo).* Você pode encontrar todos os checkpoints originais do Molmo2 na coleção [Molmo2](https://huggingface.co/collections/allenai/molmo2-67d6b5b0e138c5d621de1e5d). ## Exemplo de uso ### Geração de texto a partir de imagem e texto O exemplo abaixo demonstra como gerar texto com base em uma imagem usando [Pipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.Pipeline) ou a classe [AutoModel](/docs/transformers/main/pt/model_doc/auto#transformers.AutoModel). ```python from transformers import pipeline pipeline = pipeline( task="image-text-to-text", model="allenai/Molmo2-8B", device_map="auto", ) messages = [ { "role": "user", "content": [ {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"}, {"type": "text", "text": "Describe this image."}, ], } ] pipeline(text=messages, max_new_tokens=128, return_full_text=False) ``` ```python from transformers import AutoModelForImageTextToText, AutoProcessor processor = AutoProcessor.from_pretrained("allenai/Molmo2-8B") model = AutoModelForImageTextToText.from_pretrained( "allenai/Molmo2-8B", device_map="auto", ) messages = [ { "role": "user", "content": [ {"type": "text", "text": "Describe this image."}, {"type": "image", "image": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"}, ], } ] inputs = processor.apply_chat_template( messages, tokenize=True, add_generation_prompt=True, return_tensors="pt", return_dict=True, ) generated_ids = model.generate(**inputs, max_new_tokens=128) generated_text = processor.decode( generated_ids[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True ) print(generated_text) # In this captivating image, a snow leopard is captured ... ``` ### Apontamento de vídeo Molmo2 também pode gerar pontos ancorados para entradas de vídeo. Os pontos são retornados no texto gerado como um payload ``, em que cada grupo de coordenadas contém um timestamp seguido pelos ids dos pontos e pelas coordenadas normalizadas da imagem. ```python import torch from transformers import AutoModelForImageTextToText, AutoProcessor model_id = "allenai/Molmo2-8B" video_url = "https://storage.googleapis.com/oe-training-public/demo_videos/many_penguins.mp4" processor = AutoProcessor.from_pretrained(model_id) model = AutoModelForImageTextToText.from_pretrained(model_id, device_map="auto") messages = [ { "role": "user", "content": [ {"type": "text", "text": "Point to the penguins."}, {"type": "video", "video": video_url}, ], } ] inputs = processor.apply_chat_template( messages, tokenize=True, add_generation_prompt=True, return_tensors="pt", return_dict=True, ) generated_ids = model.generate(**inputs, max_new_tokens=128, do_sample=False) input_len = inputs["input_ids"].shape[1] generated_text = processor.decode(generated_ids[0][input_len:], skip_special_tokens=True) print(generated_text) ``` ## Molmo2Config[[transformers.Molmo2Config]] #### transformers.Molmo2Config[[transformers.Molmo2Config]] ```python transformers.Molmo2Config(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, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, adapter_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, image_start_token_id: int = 151936, low_res_image_start_token_id: int = 151940, image_end_token_id: int = 151937, image_patch_id: int = 151938, frame_start_token_id: int = 151943, frame_end_token_id: int = 151944, initializer_range: float = 0.02, tie_word_embeddings: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/molmo2/configuration_molmo2.py#L171) **Parâmetros:** vision_config (`Molmo2VisionConfig`, *opcional*) : Configuração para o backbone do transformador de visão. adapter_config (`Molmo2AdapterConfig`, *opcional*) : Configuração para o adaptador de visão para linguagem. text_config (`Union[dict, ~configuration_utils.PreTrainedConfig]`, *opcional*) : O objeto de configuração ou dicionário do backbone de texto. image_start_token_id (`int`, *opcional*, padrão 151936) : ID do token que marca o início de uma região de imagem. low_res_image_start_token_id (`int`, *opcional*, padrão 151940) : ID do token que marca o início de um recorte de imagem de baixa resolução. image_end_token_id (`int`, *opcional*, padrão 151937) : ID do token que marca o fim de uma região de imagem. image_patch_id (`int`, *opcional*, padrão 151938) : ID do token para patches de imagem. frame_start_token_id (`int`, *opcional*, padrão 151943) : ID do token que marca o início de um quadro de vídeo. frame_end_token_id (`int`, *opcional*, padrão 151944) : ID do token que marca o fim de um quadro de vídeo. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. tie_word_embeddings (`bool`, *opcional*, padrão `False`) : Se os embeddings de palavras de entrada e saída do modelo devem ser vinculados. Esta é a classe de configuração para armazenar a configuração de um Molmo2Model. Ela é usada para instanciar um modelo Molmo2 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 [allenai/Molmo2-8B](https://huggingface.co/allenai/Molmo2-8B) 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. ## Molmo2VisionConfig[[transformers.Molmo2VisionConfig]] #### transformers.Molmo2VisionConfig[[transformers.Molmo2VisionConfig]] ```python transformers.Molmo2VisionConfig(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 = 1152, intermediate_size: int = 4304, num_hidden_layers: int = 25, num_attention_heads: int = 16, num_key_value_heads: int = 16, head_dim: int = 72, hidden_act: str = 'gelu_pytorch_tanh', layer_norm_eps: float = 1e-06, image_size: list[int] | None = None, patch_size: int = 14, num_position_embeddings: int | None = None, num_channels: int = 3, attention_dropout: float = 0.0, attention_bias: bool = True, initializer_range: float = 0.02) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/molmo2/configuration_molmo2.py#L30) **Parâmetros:** hidden_size (`int`, *opcional*, padrão `1152`) : Dimensão das representações ocultas. intermediate_size (`int`, *opcional*, padrão `4304`) : Dimensão das representações do MLP. num_hidden_layers (`int`, *opcional*, padrão `25`) : Número de camadas ocultas no decodificador do Transformer. num_attention_heads (`int`, *opcional*, padrão `16`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. num_key_value_heads (`int`, *opcional*, padrão `16`) : Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Se `num_key_value_heads=num_attention_heads`, o modelo usará Multi Head Attention (MHA); se `num_key_value_heads=1`, o modelo usará Multi Query Attention (MQA); caso contrário, será usado GQA. Ao converter um checkpoint multi-head para um checkpoint GQA, cada cabeça de chave e valor do grupo deve ser construída pela média (meanpooling) de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte [este artigo](https://huggingface.co/papers/2305.13245). Se não for especificado, o valor padrão será `num_attention_heads`. head_dim (`int`, *opcional*, padrão `72`) : A dimensão da cabeça de atenção. Se for None, o padrão será hidden_size // num_attention_heads hidden_act (`str`, *opcional*, padrão `gelu_pytorch_tanh`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. layer_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização de camada. image_size (`list[int]`, *opcional*) : Tamanho da imagem de entrada como (altura, largura), `[378, 378]` quando não fornecido. patch_size (`int`, *opcional*, padrão `14`) : O tamanho (resolução) de cada patch. num_position_embeddings (`int`, *opcional*) : Número de incorporações posicionais, uma para cada trecho de imagem. Derivado de `image_size` e `patch_size` quando não fornecido. num_channels (`int`, *opcional*, padrão `3`) : O número de canais de entrada. attention_dropout (`float`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção. attention_bias (`bool`, *opcional*, padrão `True`) : Se deve usar um viés nas camadas de projeção de query, key, value e output durante a autoatenção. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. Esta é a classe de configuração para armazenar a configuração de um Molmo2Model. Ela é usada para instanciar um modelo Molmo2 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 [allenai/Molmo2-8B](https://huggingface.co/allenai/Molmo2-8B) 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. ## Molmo2AdapterConfig[[transformers.Molmo2AdapterConfig]] #### transformers.Molmo2AdapterConfig[[transformers.Molmo2AdapterConfig]] ```python transformers.Molmo2AdapterConfig(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, vision_feature_layer: list[int] | None = None, hidden_size: int = 1152, num_attention_heads: int = 16, num_key_value_heads: int = 16, head_dim: int = 72, attention_dropout: float = 0.0, attention_bias: bool = True, hidden_act: str = 'silu', intermediate_size: int = 18944, text_hidden_size: int = 3584, mlp_bias: bool = False, initializer_range: float = 0.02) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/molmo2/configuration_molmo2.py#L75) **Parâmetros:** vision_feature_layer (`list[int]`, *opcional*) : Índices das camadas do ViT cujas saídas são concatenadas e agregadas, `[24, 18]` quando não fornecidos. Índices negativos contam a partir da última camada. hidden_size (`int`, *opcional*, padrão `1152`) : Dimensão das representações ocultas. num_attention_heads (`int`, *opcional*, padrão `16`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. num_key_value_heads (`int`, *opcional*, padrão `16`) : Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Se `num_key_value_heads=num_attention_heads`, o modelo usará Multi Head Attention (MHA); se `num_key_value_heads=1`, o modelo usará Multi Query Attention (MQA); caso contrário, será usado GQA. Ao converter um checkpoint multi-head para um checkpoint GQA, cada cabeça de chave e valor do grupo deve ser construída pela média (meanpooling) de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte [este artigo](https://huggingface.co/papers/2305.13245). Se não for especificado, o valor padrão será `num_attention_heads`. head_dim (`int`, *opcional*, padrão `72`) : A dimensão da cabeça de atenção. Se for None, o padrão será hidden_size // num_attention_heads attention_dropout (`float`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção. attention_bias (`bool`, *opcional*, padrão `True`) : Se deve usar um viés nas camadas de projeção de query, key, value e output durante a autoatenção. hidden_act (`str`, *opcional*, padrão `silu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. intermediate_size (`int`, *opcional*, padrão `18944`) : Dimensão das representações do MLP. text_hidden_size (`int`, *opcional*, padrão 3584) : Tamanho oculto do modelo de texto (usado para projeção). mlp_bias (`bool`, *opcional*, padrão `False`) : Se deve usar um viés nas camadas up_proj, down_proj e gate_proj das camadas MLP. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. Esta é a classe de configuração para armazenar a configuração de um Molmo2Model. Ela é usada para instanciar um modelo Molmo2 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 [allenai/Molmo2-8B](https://huggingface.co/allenai/Molmo2-8B) 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. ## Molmo2TextConfig[[transformers.Molmo2TextConfig]] #### transformers.Molmo2TextConfig[[transformers.Molmo2TextConfig]] ```python transformers.Molmo2TextConfig(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 = 4096, num_attention_heads: int = 32, num_key_value_heads: int = 8, head_dim: int = 128, vocab_size: int = 151936, additional_vocab_size: int = 128, attention_bias: bool = False, qk_norm_type: str = 'qwen3', num_hidden_layers: int = 36, intermediate_size: int = 12288, hidden_act: str = 'silu', attention_dropout: float = 0.0, max_position_embeddings: int = 36864, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, rope_scaling_layers: list[int] | None = None, rms_norm_eps: float = 1e-06, norm_after: bool = False, initializer_range: float = 0.02, use_cache: bool = True, tie_word_embeddings: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/molmo2/configuration_molmo2.py#L111) **Parâmetros:** hidden_size (`int`, *opcional*, padrão `4096`) : Dimensão das representações ocultas. num_attention_heads (`int`, *opcional*, padrão `32`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. num_key_value_heads (`int`, *opcional*, padrão `8`) : Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Se `num_key_value_heads=num_attention_heads`, o modelo usará Multi Head Attention (MHA); se `num_key_value_heads=1`, o modelo usará Multi Query Attention (MQA); caso contrário, será usado GQA. Ao converter um checkpoint multi-head para um checkpoint GQA, cada cabeça de chave e valor do grupo deve ser construída pela média (meanpooling) de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte [este artigo](https://huggingface.co/papers/2305.13245). Se não for especificado, o valor padrão será `num_attention_heads`. head_dim (`int`, *opcional*, padrão `128`) : A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads vocab_size (`int`, *opcional*, padrão `151936`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`. additional_vocab_size (`int`, *opcional*, padrão 128) : Número de tokens de vocabulário adicionais além do vocabulário base. attention_bias (`bool`, *opcional*, padrão `False`) : Se deve usar um viés nas camadas de projeção de query, key, value e output durante a autoatenção. qk_norm_type (`str`, *opcional*, padrão `"qwen3"`) : Layout de normalização de query/key usado pelo checkpoint. `"qwen3"` normaliza por head; `"olmo"` normaliza os tensores completos de query/key projetados. num_hidden_layers (`int`, *opcional*, padrão `36`) : Número de camadas ocultas no decodificador do Transformer. intermediate_size (`int`, *opcional*, padrão `12288`) : Dimensão das representações do MLP. hidden_act (`str`, *opcional*, padrão `silu`) : A função de ativação não linear (função ou string) no decodificador. Por exemplo, `"gelu"`, `"relu"`, `"silu"`, etc. attention_dropout (`float`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção. max_position_embeddings (`int`, *opcional*, padrão `36864`) : O comprimento máximo de sequência com o qual este modelo pode ser usado. rope_parameters (`Union[~modeling_rope_utils.RopeParameters, dict]`, *opcional*) : Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor para `rope_theta` e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com `max_position_embeddings` maiores. rope_scaling_layers (`list[int]`, *opcional*) : Índices das camadas que aplicam o RoPE escalonado descrito por `rope_parameters`. As camadas restantes usam um RoPE não escalonado com o mesmo theta. Todas as camadas são escalonadas quando não fornecido. rms_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização rms. norm_after (`bool`, *opcional*, padrão `False`) : Se deve aplicar a normalização de camada após os blocos de atenção/FFN em vez de antes. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. use_cache (`bool`, *opcional*, padrão `True`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (não utilizado por todos os modelos). Relevante apenas se `config.is_decoder=True` ou quando o modelo for um modelo generativo somente de decodificador. tie_word_embeddings (`bool`, *opcional*, padrão `False`) : 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 Molmo2Model. Ela é usada para instanciar um modelo Molmo2 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 [allenai/Molmo2-8B](https://huggingface.co/allenai/Molmo2-8B) 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. ## Molmo2Processor[[transformers.Molmo2Processor]] #### transformers.Molmo2Processor[[transformers.Molmo2Processor]] ```python transformers.Molmo2Processor(image_processor = None, video_processor = None, tokenizer = None, chat_template: str | None = None, image_use_col_tokens: bool | None = True, use_single_crop_col_tokens: bool | None = None, use_single_crop_start_token: bool | None = True, video_use_col_tokens: bool | None = False, use_frame_special_tokens: bool | None = True, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/molmo2/processing_molmo2.py#L44) **Parâmetros:** image_processor (`Molmo2ImageProcessor`) : O processador de imagens é uma entrada obrigatória. video_processor (`Molmo2VideoProcessor`) : O processador de vídeo é uma entrada obrigatória. tokenizer (`TokenizersBackend`) : O tokenizer é uma entrada obrigatória. chat_template (`str`, *opcional*) : Um modelo Jinja para converter listas de mensagens em um chat em uma string tokenizável. image_use_col_tokens (`bool`, *opcional*, padrão `True`) : Se deve adicionar tokens de separador de colunas (``) após cada linha de patches da visão de imagem de alta resolução. use_single_crop_col_tokens (`bool`, *opcional*) : Se deve adicionar tokens de separador de coluna após cada linha de patch da visão de imagem de baixa resolução (single-crop). Se `None`, usa `image_use_col_tokens` como padrão. use_single_crop_start_token (`bool`, *opcional*, padrão `True`) : Se deve iniciar a visualização da imagem de baixa resolução com `` em vez do `` regular. video_use_col_tokens (`bool`, *opcional*, padrão `False`) : Se deve adicionar tokens de separador de coluna após cada linha de patches dos quadros de vídeo. use_frame_special_tokens (`bool`, *opcional*, padrão `True`) : Se deve envolver cada quadro de vídeo com os tokens `` / ``. Se `False`, usa `` / `` como alternativa. Constrói um Molmo2Processor que encapsula um processador de imagem, um processador de vídeo e um tokenizer em um único processador. [Molmo2Processor](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2Processor) oferece todas as funcionalidades de [Molmo2ImageProcessor](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor), [Molmo2VideoProcessor](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor) e [TokenizersBackend](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend). Consulte [~Molmo2ImageProcessor](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor), [~Molmo2VideoProcessor](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor) e [~TokenizersBackend](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend) para mais informações. #### __call__[[transformers.Molmo2Processor.__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] | list[list[str]] | None = None, videos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/molmo2/processing_molmo2.py#L103) **Parâmetros:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`, *opcional*) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina `do_rescale=False`. text (`Union[str, list[str], list[list[str]]]`, *opcional*) : A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pretokenizada). Se você passar uma entrada pretokenizada, defina `is_split_into_words=True` para evitar ambiguidade com entradas em lote. videos (`Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]]`, *opcional*) : Vídeo para pré-processar. Espera um único vídeo ou um lote de vídeos com valores de pixel variando de 0 a 255. Se estiver passando vídeos com valores de pixel entre 0 e 1, defina `do_rescale=False`. return_tensors (`str` ou [TensorType](/docs/transformers/main/pt/internal/file_utils#transformers.TensorType), *opcional*) : Se definido, retornará tensores de um framework específico. Os valores aceitos são: - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do NumPy. - ****kwargs** ([ProcessingKwargs](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados. ## Molmo2ImageProcessor[[transformers.Molmo2ImageProcessor]] #### transformers.Molmo2ImageProcessor[[transformers.Molmo2ImageProcessor]] ```python transformers.Molmo2ImageProcessor(**kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/molmo2/image_processing_molmo2.py#L193) **Parâmetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve converter a imagem para RGB. do_resize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve redimensionar a imagem. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, padrão `{'height' : 378, 'width': 378}`): Descreve as dimensões máximas de entrada para o modelo. default_to_square (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, padrão `2`) : Filtro de reamostragem a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`. do_rescale (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve reescalar a imagem. rescale_factor (`float`, *kwargs*, *opcional*, padrão `0.00392156862745098`) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*, padrão `True`) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.5, 0.5, 0.5]`) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.5, 0.5, 0.5]`) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. do_pad (`bool`, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : O tamanho em `{"height": int, "width" int}` para preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida para o pré-processamento. Se `pad_size` não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros. max_crops (`int`, *kwargs*, *opcional*, padrão é 8) : Número máximo de recortes a serem usados por imagem. overlap_margins (`list[int]`, *kwargs*, *opcional*, padrão `[4, 4]`) : Margens de sobreposição (em patches) para a extração de recortes sobrepostos. patch_size (`int`, *kwargs*, *opcional*, padrão 14) : O tamanho do patch espacial do codificador de visão. pooling_size (`list[int]`, *kwargs*, *opcional*, padrão `[2, 2]`) : O tamanho de pooling do adaptador de visão. Constrói um processador de imagem Molmo2ImageProcessor. #### __call__[[transformers.Molmo2ImageProcessor.__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']], *args, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/image_processing_utils.py#L215) Pré-processa uma imagem ou um lote de imagens. #### preprocess[[transformers.Molmo2ImageProcessor.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: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/molmo2/image_processing_molmo2.py#L353) **Parâmetros:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina `do_rescale=False`. do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem para RGB. do_resize (`bool`, *kwargs*, *opcional*) : Se deve redimensionar a imagem. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Descreve as dimensões máximas de entrada para o modelo. default_to_square (`bool`, *kwargs*, *opcional*) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`. do_rescale (`bool`, *kwargs*, *opcional*) : Se deve reescalar a imagem. rescale_factor (`float`, *kwargs*, *opcional*) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. do_pad (`bool`, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : O tamanho em `{"height": int, "width" int}` para preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida para o pré-processamento. Se `pad_size` não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando `do_pad=True.` do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores. disable_grouping (`bool`, *kwargs*, *opcional*) : Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *opcional*) : O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros. max_crops (`int`, *kwargs*, *opcional*, padrão é 8) : Número máximo de recortes a serem usados por imagem. overlap_margins (`list[int]`, *kwargs*, *opcional*, padrão `[4, 4]`) : Margens de sobreposição (em patches) para a extração de recortes sobrepostos. patch_size (`int`, *kwargs*, *opcional*, padrão 14) : O tamanho do patch espacial do codificador de visão. pooling_size (`list[int]`, *kwargs*, *opcional*, padrão `[2, 2]`) : O tamanho de pooling do adaptador de visão. **Retorna:** `~image_processing_base.BatchFeature` - **data** (`dict`) -- Dicionário de listas/arrays/tensors retornados pelo método __call__ ('pixel_values', etc.). - **tensor_type** (`Union[None, str, TensorType]`, *opcional*) -- Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização. ## Molmo2VideoProcessor[[transformers.Molmo2VideoProcessor]] #### transformers.Molmo2VideoProcessor[[transformers.Molmo2VideoProcessor]] ```python transformers.Molmo2VideoProcessor(**kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/molmo2/video_processing_molmo2.py#L148) **Parâmetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem para RGB. do_resize (`bool`, *kwargs*, *opcional*) : Se deve redimensionar a imagem. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, padrão `{'height' : 378, 'width': 378}`): Descreve as dimensões máximas de entrada para o modelo. default_to_square (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, padrão `2`) : Filtro de reamostragem a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`. do_rescale (`bool`, *kwargs*, *opcional*) : Se deve reescalar a imagem. rescale_factor (`float`, *kwargs*, *opcional*, padrão `0.00392156862745098`) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.5, 0.5, 0.5]`) : Média da imagem a ser usada para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.5, 0.5, 0.5]`) : Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se `do_normalize` estiver definido como `True`. do_center_crop (`bool`, *kwargs*, *opcional*) : Se deve centralizar o recorte da imagem. do_pad (`bool`, *kwargs*, *opcional*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding depende do modelo. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Tamanho da imagem de saída após aplicar `center_crop`. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : Apenas `ChannelDimension.FIRST` é suportado. Adicionado para compatibilidade com processadores lentos. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *opcional*) : O formato da dimensão de canal para a imagem de entrada. Se não for definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes: - `"channels_first"` ou `ChannelDimension.FIRST`: imagem no formato (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST`: imagem no formato (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada. do_sample_frames (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve amostrar quadros do vídeo antes do processamento ou processar o vídeo inteiro. video_metadata (`Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None]`, *kwargs*) : Metadados do vídeo contendo informações sobre a duração total, o fps e o número total de quadros. Será usado para amostrar quadros do vídeo ou calcular timestamps. Não passe nenhum metadado, a menos que você esteja tentando decodificar o vídeo manualmente antes do processamento fps (`Annotated[int | float | None, None]`, *kwargs*) : Quadros-alvo a amostrar por segundo quando `do_sample_frames=True`. num_frames (`Annotated[int | None, None]`, *kwargs*, padrão `64`) : Número máximo de quadros a amostrar quando `do_sample_frames=True`. return_metadata (`bool`, *kwargs*, *opcional*, padrão `False`) : Se deve ou não retornar metadados do vídeo. Os metadados do vídeo são um objeto contendo informações sobre a duração do vídeo, fps, backend de decodificação, etc. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Se definido, retornará tensors de um framework específico. Os valores aceitos são: - `'pt'`: Retorna objetos `torch.Tensor` do PyTorch. - `'np'`: Retorna objetos `np.ndarray` do NumPy. patch_size (`int`, *kwargs*, *opcional*) : Lado, em pixels, de cada patch do ViT para os quadros de vídeo. pooling_size (`list[int]`, *kwargs*, *opcional*) : `[pool_h, pool_w]` janela de pooling aplicada às características de patches de vídeo. max_fps (`int`, *kwargs*, *opcional*) : Taxa máxima de amostragem em quadros por segundo para vídeos curtos. - ****kwargs** ([ProcessingKwargs](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessingKwargs), *opcional*) : Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados. Constrói um processador de vídeo Molmo2VideoProcessor. #### __call__[[transformers.Molmo2VideoProcessor.__call__]] ```python __call__(videos, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/video_processing_utils.py#L86) ## Molmo2Model[[transformers.Molmo2Model]] #### transformers.Molmo2Model[[transformers.Molmo2Model]] ```python transformers.Molmo2Model(config: Molmo2Config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/molmo2/modeling_molmo2.py#L735) **Parâmetros:** config ([Molmo2Config](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2Config)) : 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 Molmo2, que consiste em um backbone de visão, um adaptador de pooling e um modelo de linguagem, sem uma cabeça de modelagem de linguagem. 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.Molmo2Model.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.FloatTensor] = None, image_token_pooling: typing.Optional[torch.Tensor] = None, image_grids: typing.Optional[torch.Tensor] = None, image_num_crops: typing.Optional[torch.Tensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, video_token_pooling: typing.Optional[torch.Tensor] = None, video_grids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, mm_token_type_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.FloatTensor] = None, use_cache: bool | None = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/molmo2/modeling_molmo2.py#L803) **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.FloatTensor` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [Molmo2ImageProcessor](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor). Veja [Molmo2ImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([Molmo2Processor](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2Processor) usa [Molmo2ImageProcessor](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor) para processar imagens). image_token_pooling (`torch.Tensor` de forma `(num_image_tokens, pool_h * pool_w)`, *opcional*) : Índices para a sequência achatada de patches de imagem coletados por cada token de imagem agrupado, com `-1` marcando os slots de preenchimento. Pode ser obtido usando [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor). Veja [ProcessorMixin.__call__()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.__call__) para detalhes. image_grids (`torch.Tensor` de forma `(num_images, 4)`, *opcional*) : Grade de tokens agrupados `[low_res_h, low_res_w, high_res_h, high_res_w]` por imagem. Pode ser obtida usando [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor). Veja [ProcessorMixin.__call__()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.__call__) para detalhes. image_num_crops (`torch.Tensor` de forma `(num_images,)`, *opcional*) : Número de recortes por imagem, incluindo a visão de baixa resolução. Pode ser obtido usando [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor). Veja [ProcessorMixin.__call__()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.__call__) para mais detalhes. pixel_values_videos (`torch.Tensor` de forma `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *opcional*) : Os tensores correspondentes ao vídeo de entrada. Os valores de pixels para vídeos podem ser obtidos usando [Molmo2VideoProcessor](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor). Veja [Molmo2VideoProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para detalhes ([Molmo2Processor](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2Processor) usa [Molmo2VideoProcessor](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor) para processar vídeos). video_token_pooling (`torch.Tensor` de forma `(num_video_tokens, pool_h * pool_w)`, *opcional*) : Índices na sequência achatada de patches de quadros de vídeo coletados por cada token de vídeo agrupado, com `-1` marcando os slots de preenchimento. Pode ser obtido usando [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor). Veja [ProcessorMixin.__call__()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.__call__) para detalhes. video_grids (`torch.Tensor` de forma `(num_videos, 3)`, *opcional*) : Grade de tokens `[num_frames, pooled_h, pooled_w]` por vídeo. Pode ser obtida usando [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor). Veja [ProcessorMixin.__call__()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.__call__) para mais detalhes. 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.Tensor` 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)`. mm_token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada correspondentes a cada modalidade. Por exemplo, texto (0), imagem (1), vídeo (2). Os ids de tipo de token multimodal podem ser obtidos usando [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor). Veja [ProcessorMixin.__call__()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.__call__) para mais detalhes. inputs_embeds (`torch.FloatTensor` 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`). 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:** `Molmo2ModelOutputWithPast` ou `tuple(torch.FloatTensor)` Um `Molmo2ModelOutputWithPast` ou uma tupla de `torch.FloatTensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([Molmo2Config](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2Config)) e das entradas. O método forward do [Molmo2Model](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2Model) 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. - **last_hidden_state** (`torch.FloatTensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. Se `past_key_values` for usado, apenas o último hidden-state das sequências, com forma `(batch_size, 1, hidden_size)`, é retornado. - **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.FloatTensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.FloatTensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de 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.FloatTensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma 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. - **image_hidden_states** (`torch.FloatTensor`, *opcional*) -- Um `torch.FloatTensor` de tamanho `(batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states do modelo produzido pelo codificador de visão e após projetar o último estado oculto. ## Molmo2TextModel[[transformers.Molmo2TextModel]] #### transformers.Molmo2TextModel[[transformers.Molmo2TextModel]] ```python transformers.Molmo2TextModel(config: Molmo2TextConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/molmo2/modeling_molmo2.py#L645) **Parâmetros:** config ([Molmo2TextConfig](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2TextConfig)) : 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 de texto Molmo2 puro, que gera estados ocultos 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.Molmo2TextModel.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.FloatTensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/molmo2/modeling_molmo2.py#L670) **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.FloatTensor` 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`). **Retorna:** [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou `tuple(torch.FloatTensor)` Um [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou uma tupla de `torch.FloatTensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([Molmo2Config](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2Config)) e das entradas. O método forward do [Molmo2TextModel](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2TextModel) 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. - **last_hidden_state** (`torch.FloatTensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. Se `past_key_values` for usado, apenas o último hidden-state das sequências, com forma `(batch_size, 1, hidden_size)`, é retornado. - **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 e, opcionalmente, se `config.is_encoder_decoder=True`, nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **hidden_states** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.FloatTensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de 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.FloatTensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma 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. ## Molmo2Adapter[[transformers.Molmo2Adapter]] #### transformers.Molmo2Adapter[[transformers.Molmo2Adapter]] ```python transformers.Molmo2Adapter(config: Molmo2AdapterConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/molmo2/modeling_molmo2.py#L595) **Parâmetros:** config ([Molmo2AdapterConfig](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2AdapterConfig)) : 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 adaptador de visão Molmo2: agrega os recursos de patch do ViT com uma camada de atenção cruzada e os projeta no espaço de incorporação do modelo de linguagem. 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.Molmo2Adapter.forward]] ```python forward(image_features: Tensor, pooled_patches_idx: Tensor, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/molmo2/modeling_molmo2.py#L608) **Parâmetros:** image_features (`torch.Tensor` de forma `(num_crops, num_patches, hidden_size * len(vision_feature_layer))`) : Recursos intermediários concatenados do ViT de cada crop. pooled_patches_idx (`torch.Tensor` de forma `(num_tokens, pool_h * pool_w)`) : Índices na sequência de patches achatada agrupada por cada token de saída; `-1` marca os slots de preenchimento. **Retorna:** [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou `tuple(torch.FloatTensor)` Um [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou uma tupla de `torch.FloatTensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([Molmo2Config](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2Config)) e das entradas. O método forward do [Molmo2Adapter](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2Adapter) 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. - **last_hidden_state** (`torch.FloatTensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **hidden_states** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.FloatTensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de 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.FloatTensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma 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. ## Molmo2VisionModel[[transformers.Molmo2VisionModel]] #### transformers.Molmo2VisionModel[[transformers.Molmo2VisionModel]] ```python transformers.Molmo2VisionModel(config: Molmo2VisionConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/molmo2/modeling_molmo2.py#L536) **Parâmetros:** config ([Molmo2VisionConfig](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VisionConfig)) : 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 Molmo2 puro, que produz estados ocultos brutos sem nenhum cabeçalho 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.Molmo2VisionModel.forward]] ```python forward(pixel_values: Tensor, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/molmo2/modeling_molmo2.py#L556) **Parâmetros:** pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [Molmo2ImageProcessor](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor). Veja [Molmo2ImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([Molmo2Processor](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2Processor) usa [Molmo2ImageProcessor](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor) para processar imagens). **Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.FloatTensor)` Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.FloatTensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([Molmo2Config](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2Config)) e das entradas. O método forward do [Molmo2VisionModel](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VisionModel) 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. - **last_hidden_state** (`torch.FloatTensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **pooler_output** (`torch.FloatTensor` 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 sentença (classificação) durante o pré-treinamento. - **hidden_states** (`tuple(torch.FloatTensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.FloatTensor` (uma para a saída dos embeddings, se o modelo tiver uma camada de embedding, + uma para a saída de cada camada) de 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.FloatTensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma 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. ## Molmo2ForConditionalGeneration[[transformers.Molmo2ForConditionalGeneration]] #### transformers.Molmo2ForConditionalGeneration[[transformers.Molmo2ForConditionalGeneration]] ```python transformers.Molmo2ForConditionalGeneration(config: Molmo2Config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/molmo2/modeling_molmo2.py#L918) **Parâmetros:** config ([Molmo2Config](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2Config)) : 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 Molmo2, que consiste em um backbone de visão, um adaptador de pooling e um modelo de linguagem. 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.Molmo2ForConditionalGeneration.forward]] ```python forward(input_ids: LongTensor = None, pixel_values: typing.Optional[torch.Tensor] = None, image_token_pooling: typing.Optional[torch.Tensor] = None, image_grids: typing.Optional[torch.Tensor] = None, image_num_crops: typing.Optional[torch.Tensor] = None, pixel_values_videos: typing.Optional[torch.Tensor] = None, video_token_pooling: typing.Optional[torch.Tensor] = None, video_grids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: list[torch.FloatTensor] | None = None, mm_token_type_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.FloatTensor] = 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/molmo2/modeling_molmo2.py#L953) **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` de forma `(batch_size, num_channels, image_size, image_size)`, *opcional*) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [Molmo2ImageProcessor](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor). Veja [Molmo2ImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([Molmo2Processor](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2Processor) usa [Molmo2ImageProcessor](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor) para processar imagens). image_token_pooling (`torch.Tensor` de forma `(num_image_tokens, pool_h * pool_w)`, *opcional*) : Índices para a sequência achatada de patches de imagem coletados por cada token de imagem agrupado, com `-1` marcando os slots de preenchimento. Pode ser obtido usando [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor). Veja [ProcessorMixin.__call__()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.__call__) para detalhes. image_grids (`torch.Tensor` de forma `(num_images, 4)`, *opcional*) : Grade de tokens agrupados `[low_res_h, low_res_w, high_res_h, high_res_w]` por imagem. Pode ser obtida usando [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor). Veja [ProcessorMixin.__call__()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.__call__) para detalhes. image_num_crops (`torch.Tensor` de forma `(num_images,)`, *opcional*) : Número de recortes por imagem, incluindo a visão de baixa resolução. Pode ser obtido usando [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor). Veja [ProcessorMixin.__call__()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.__call__) para mais detalhes. pixel_values_videos (`torch.Tensor` de forma `(batch_size, num_frames, num_channels, frame_size, frame_size)`, *opcional*) : Os tensores correspondentes ao vídeo de entrada. Os valores de pixels para vídeos podem ser obtidos usando [Molmo2VideoProcessor](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor). Veja [Molmo2VideoProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para detalhes ([Molmo2Processor](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2Processor) usa [Molmo2VideoProcessor](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor) para processar vídeos). video_token_pooling (`torch.Tensor` de forma `(num_video_tokens, pool_h * pool_w)`, *opcional*) : Índices na sequência achatada de patches de quadros de vídeo coletados por cada token de vídeo agrupado, com `-1` marcando os slots de preenchimento. Pode ser obtido usando [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor). Veja [ProcessorMixin.__call__()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.__call__) para detalhes. video_grids (`torch.Tensor` de forma `(num_videos, 3)`, *opcional*) : Grade de tokens `[num_frames, pooled_h, pooled_w]` por vídeo. Pode ser obtida usando [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor). Veja [ProcessorMixin.__call__()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.__call__) para mais detalhes. 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 (`list[torch.FloatTensor]`, *opcional*) : hidden-states pré-computados (keys e values nos blocos de self-attention e nos blocos de cross-attention) 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 instâncias de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) são permitidas 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 key value passados para este modelo) com formato `(batch_size, unprocessed_length)` em vez de todos os `input_ids` com formato `(batch_size, sequence_length)`. mm_token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices dos tokens da sequência de entrada correspondentes a cada modalidade. Por exemplo, texto (0), imagem (1), vídeo (2). Os ids de tipo de token multimodal podem ser obtidos usando [AutoProcessor](/docs/transformers/main/pt/model_doc/auto#transformers.AutoProcessor). Veja [ProcessorMixin.__call__()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.__call__) para mais detalhes. inputs_embeds (`torch.FloatTensor` 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. Os índices devem estar em `[0, ..., config.vocab_size]` ou ser -100 (veja a docstring de `input_ids`). Tokens com índices definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em `[0, ..., config.vocab_size]`. 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 (`Union[int, torch.Tensor]`, *opcional*, padrão `0`) : Se for um `int`, calcula os logits para os últimos `logits_to_keep` tokens. Se for `0`, calcula os logits para todos os `input_ids` (caso especial). Apenas os logits do último token são necessários para a geração, e calculá-los apenas para esse token pode economizar memória, o que se torna bastante significativo para sequências longas ou tamanho de vocabulário grande. Se for um `torch.Tensor`, deve ser 1D, correspondendo aos índices a serem mantidos na dimensão de comprimento da sequência. Isso é útil ao usar o formato de tensor empacotado (uma única dimensão para lote e comprimento da sequência). 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:** `Molmo2CausalLMOutputWithPast` ou `tuple(torch.FloatTensor)` Um `Molmo2CausalLMOutputWithPast` ou uma tupla de `torch.FloatTensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos, dependendo da configuração ([Molmo2Config](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2Config)) e das entradas. O método forward de [Molmo2ForConditionalGeneration](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ForConditionalGeneration) 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.FloatTensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem (para previsão do próximo token). - **logits** (`torch.FloatTensor` 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.FloatTensor]`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.FloatTensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de 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.FloatTensor]`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.FloatTensor` (uma 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. - **image_hidden_states** (`torch.FloatTensor`, *opcional*) -- Um `torch.FloatTensor` de tamanho `(batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states do modelo produzido pelo codificador de visão e após projetar o último estado oculto. Exemplo: ```python >>> from PIL import Image >>> import requests >>> from transformers import AutoProcessor, Molmo2ForConditionalGeneration >>> model = Molmo2ForConditionalGeneration.from_pretrained("allenai/Molmo2-8B") >>> processor = AutoProcessor.from_pretrained("allenai/Molmo2-8B") >>> prompt = "What's the content of the image?" >>> url = "https://www.ilankelman.org/stopsigns/australia.jpg" >>> image = Image.open(requests.get(url, stream=True).raw) >>> messages = [{"role": "user", "content": [{"type": "text", "text": prompt}, {"type": "image", "image": image}]}] >>> inputs = processor.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt", return_dict=True) >>> # Generate >>> generated_ids = model.generate(**inputs, max_new_tokens=15) >>> generated_tokens = generated_ids[:, inputs['input_ids'].size(1):] >>> processor.post_process_image_text_to_text(generated_tokens, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0] "The image shows a bustling street scene in what appears to be a Chinatown area. There's ..." ```