# Gemma4 Unified ## Visão geral O Gemma 4 12B Unified é um modelo multimodal **sem encoder**, com variantes pré-treinadas e ajustadas por instruções. Diferentemente do [Gemma 4 padrão](./gemma4), que utiliza torres de encoder dedicadas, o Gemma 4 12B Unified projeta as entradas brutas diretamente no espaço de incorporação do modelo de linguagem por meio de pipelines lineares leves. Isso resulta em uma arquitetura mais simples, mantendo um forte desempenho multimodal. Principais diferenças em relação ao Gemma 4 padrão: - **Sem a torre de visão**: Os patches de pixels brutos são projetados diretamente no espaço do LM por meio de um pipeline `Dense + LayerNorm` com embeddings posicionais 2D fatorizados, substituindo o codificador de visão. - **No Audio Tower**: amostras brutas de forma de onda de 16 kHz são divididas em quadros de comprimento fixo e projetadas por meio de um pipeline simples `RMSNorm → Linear`, substituindo o espectrograma mel + codificador Conformer. - **Pipeline multimodal compartilhado**: tanto a visão quanto o áudio utilizam o mesmo `Gemma4UnifiedMultimodalEmbedder` (RMSNorm → Linear) para a projeção final no espaço oculto do texto. Você pode encontrar os checkpoints originais do Gemma 4 12B Unified na liberação [Gemma 4](https://huggingface.co/collections/google/gemma-4). ### Pipeline de Visão Sem Codificador A principal diferença arquitetônica em relação ao Gemma 4 padrão é a remoção da torre do codificador de visão. Em vez disso, o Gemma 4 12B Unified processa imagens por meio de um pipeline leve: 1. **Fragmentação em blocos**: As imagens são divididas em blocos de `16×16` pixels 2. **Merging de patches**: patches adjacentes de `3×3` são mesclados em patches de modelo de `48×48`, cada um com `48² × 3 = 6,912` canais de pixels brutos 3. **Projeção**: `LayerNorm → Dense → LayerNorm` projeta cada patch mesclado para a dimensão de incorporação do LM 4. **Positional Embedding**: São adicionados embeddings posicionais 2D fatorizados (embeddings aprendidos separadamente para os eixos x e y, somados entre si) 5. **Normalização final**: uma `LayerNorm` final é aplicada 6. **Embutidor multimodal**: `RMSNorm → Linear` projeta para o tamanho oculto do texto Assim como o Gemma 4 padrão, o modelo processa **imagens de diferentes tamanhos** usando um **número fixo de tokens**. As mesmas restrições se aplicam: - O número total de pixels deve caber dentro de um orçamento de patches - Tanto a altura quanto a largura devem ser divisíveis por **48** (= tamanho do patch 16 × kernel de pooling 3) > [!IMPORTANT] > Gemma 4 12B Unified **não** aplica normalização de média/desvio padrão. A própria camada de incorporação de patches do modelo lida com o escalonamento final internamente. O número de tokens suaves por imagem é configurável. As opções suportadas e o padrão (**280 tokens suaves**) são: | Tokens Suaves | Patches (antes do pooling) | Área Aprox. da Imagem | |:-----------:|:------------------------:|:-------------------:| | 70 | 630 | ~161 mil pixels | | 140 | 1,260 | ~323 mil pixels | | **280** | **2,520** | **~645 mil pixels** | | 560 | 5,040 | ~1,3M pixels | | 1,120 | 10,080 | ~2,6M pixels | ### Pipeline de Áudio Sem Encoder O pipeline de áudio é simplificado de forma semelhante. Em vez de calcular espectrogramas mel e processá-los por meio de um codificador Conformer, as amostras brutas de forma de onda de 16 kHz são: 1. **Dividido** em quadros de comprimento fixo, com 640 amostras cada (40 ms por quadro a 16 kHz) 2. **Projetado** diretamente por meio de `RMSNorm → Linear` via o compartilhado `Gemma4UnifiedMultimodalEmbedder` Como não há **redução de amostragem**, o número de soft tokens de saída é igual ao número de quadros de entrada: `ceil(num_samples / 640)`. ## Exemplos de uso O exemplo abaixo demonstra como gerar texto com base em uma imagem e uma amostra de áudio 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 pipe = pipeline( task="any-to-any", model="google/gemma-4-12B-it", ) image_messages = [ { "role": "user", "content": [ { "type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg" }, { "type": "text", "text": "What is shown in this image?" } ] } ] image_output = pipe(image_messages, return_full_text=False) print(image_output[0]["generated_text"]) audio_messages = [ { "role": "user", "content": [ {"type": "text", "text": "Please transcribe the following audio:"}, { "type": "audio", "url": "https://huggingface.co/datasets/eustlb/audio-samples/resolve/main/bcn_weather.mp3", }, ], } ] audio_output = pipe(audio_messages, return_full_text=False) print(audio_output[0]["generated_text"]) ``` ### Imagem ```python from transformers import AutoModelForMultimodalLM, AutoProcessor model = AutoModelForMultimodalLM.from_pretrained( "google/gemma-4-12B-it", device_map="auto" ) processor = AutoProcessor.from_pretrained( "google/gemma-4-12B-it" ) messages = [ { "role": "user", "content": [ {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"}, {"type": "text", "text": "What is shown in this image?"}, ] }, ] inputs = processor.apply_chat_template( messages, tokenize=True, return_dict=True, return_tensors="pt", add_generation_prompt=True, ).to(model.device) input_len = inputs["input_ids"].shape[-1] output = model.generate(**inputs, max_new_tokens=50, cache_implementation="static") print(processor.decode(output[0][input_len:], skip_special_tokens=True)) ``` ### Áudio ```python from transformers import AutoModelForMultimodalLM, AutoProcessor messages = [ { "role": "user", "content": [ {"type": "text", "text": "Please transcribe the following audio:"}, { "type": "audio", "url": "https://huggingface.co/datasets/eustlb/audio-samples/resolve/main/bcn_weather.mp3", }, ], } ] model = AutoModelForMultimodalLM.from_pretrained( "google/gemma-4-12B-it", device_map="auto" ) processor = AutoProcessor.from_pretrained( "google/gemma-4-12B-it" ) inputs = processor.apply_chat_template( messages, tokenize=True, add_generation_prompt=True, return_dict=True, return_tensors="pt" ).to(model.device, dtype=model.dtype) input_len = inputs["input_ids"].shape[-1] outputs = model.generate(**inputs, max_new_tokens=200) print(processor.decode(outputs[0][input_len:], skip_special_tokens=False)) ``` ## Gemma4UnifiedAudioConfig[[transformers.Gemma4UnifiedAudioConfig]] #### transformers.Gemma4UnifiedAudioConfig[[transformers.Gemma4UnifiedAudioConfig]] ```python transformers.Gemma4UnifiedAudioConfig(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, audio_embed_dim: int = 640, rms_norm_eps: float = 1e-06, initializer_range: float = 0.02) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4_unified/configuration_gemma4_unified.py#L36) **Parâmetros:** audio_embed_dim (`int`, padrão 640) : Dimensão dos recursos de áudio de entrada para o incorporador multimodal. Cada token suave de áudio é um quadro de forma de onda bruto com `audio_samples_per_token` amostras, portanto `audio_embed_dim == audio_samples_per_token`. rms_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização rms. 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 Gemma4UnifiedModel. Ela é usada para instanciar um modelo Gemma4 Unified 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 [google/gemma-4-12B-it](https://huggingface.co/google/gemma-4-12B-it) 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. ## Gemma4UnifiedConfig[[transformers.Gemma4UnifiedConfig]] #### transformers.Gemma4UnifiedConfig[[transformers.Gemma4UnifiedConfig]] ```python transformers.Gemma4UnifiedConfig(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: transformers.models.gemma4_unified.configuration_gemma4_unified.Gemma4UnifiedTextConfig | dict[str, typing.Any] | None = None, vision_config: transformers.models.gemma4_unified.configuration_gemma4_unified.Gemma4UnifiedVisionConfig | dict[str, typing.Any] | None = None, audio_config: transformers.models.gemma4_unified.configuration_gemma4_unified.Gemma4UnifiedAudioConfig | dict[str, typing.Any] | None = None, boi_token_id: int | None = 255999, eoi_token_id: int | None = 258882, image_token_id: int | None = 258880, video_token_id: int | None = 258884, boa_token_id: int | None = 256000, eoa_token_index: int | None = 258883, audio_token_id: int | None = 258881, initializer_range: float | None = 0.02, tie_word_embeddings: bool = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4_unified/configuration_gemma4_unified.py#L283) **Parâmetros:** text_config (`Union[~models.gemma4_unified.configuration_gemma4_unified.Gemma4UnifiedTextConfig, dict[str, Any]]`, *opcional*) : O objeto de configuração ou dicionário do backbone de texto. vision_config (`Union[~models.gemma4_unified.configuration_gemma4_unified.Gemma4UnifiedVisionConfig, dict[str, Any]]`, *opcional*) : O objeto de configuração ou dicionário do backbone de visão. audio_config (`Union[~models.gemma4_unified.configuration_gemma4_unified.Gemma4UnifiedAudioConfig, dict[str, Any]]`, *opcional*) : O objeto de configuração ou dicionário do backbone de áudio. boi_token_id (`int`, *opcional*, padrão 255999) : O índice do token de início de imagem para envolver o prompt da imagem. eoi_token_id (`int`, *opcional*, padrão 258882) : O índice do token de fim de imagem para envolver o prompt da imagem. image_token_id (`int`, *opcional*, padrão `258880`) : O índice do token de imagem usado como marcador para as imagens de entrada. video_token_id (`int`, *opcional*, padrão `258884`) : O índice do token de vídeo usado como marcador de posição para os vídeos de entrada. boa_token_id (`int`, *opcional*, padrão 256000) : O índice do token de início de áudio para envolver o prompt de áudio. eoa_token_index (`int`, *opcional*, padrão 258883) : O índice do token de fim de áudio para envolver o prompt de áudio. audio_token_id (`int`, *opcional*, padrão `258881`) : O índice do token de áudio usado como marcador para o áudio de entrada. 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 `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 Gemma4UnifiedModel. Ela é usada para instanciar um modelo Gemma4 Unified 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 [google/gemma-4-12B-it](https://huggingface.co/google/gemma-4-12B-it) 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. Exemplo: ```python >>> from transformers import ( >>> Gemma4UnifiedAudioConfig, >>> Gemma4UnifiedConfig, >>> Gemma4UnifiedForConditionalGeneration, >>> Gemma4UnifiedTextConfig, >>> Gemma4UnifiedVisionConfig, >>> ) >>> # Initializing a Gemma 4 Audio config. >>> audio_config = Gemma4UnifiedAudioConfig() >>> # Initializing a Gemma 4 Text config. >>> text_config = Gemma4UnifiedTextConfig() >>> # Initializing a Gemma 4 vision config. >>> vision_config = Gemma4UnifiedVisionConfig() >>> # Initializing a Gemma 4 config similar to google/gemma-4-e2b-it >>> configuration = Gemma4UnifiedConfig(text_config, vision_config, audio_config) >>> # Initializing a model from the google/gemma-4-e2b-it configuration >>> model = Gemma4UnifiedForConditionalGeneration(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Gemma4UnifiedTextConfig[[transformers.Gemma4UnifiedTextConfig]] #### transformers.Gemma4UnifiedTextConfig[[transformers.Gemma4UnifiedTextConfig]] ```python transformers.Gemma4UnifiedTextConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 262144, hidden_size: int = 2304, intermediate_size: int = 9216, num_hidden_layers: int = 30, num_attention_heads: int = 8, num_key_value_heads: int = 4, head_dim: int = 256, hidden_activation: str = 'gelu_pytorch_tanh', max_position_embeddings: int = 262144, initializer_range: float = 0.02, rms_norm_eps: float = 1e-06, use_cache: bool = True, pad_token_id: int | None = 0, eos_token_id: int | list[int] | None = 1, bos_token_id: int | None = 2, tie_word_embeddings: bool = True, rope_parameters: dict | None = None, attention_bias: bool = False, attention_dropout: int | float | None = 0.0, sliding_window: int = 1024, layer_types: list[str] | None = None, final_logit_softcapping: float | None = None, use_bidirectional_attention: typing.Optional[typing.Literal['all', 'vision']] = 'vision', attention_k_eq_v: bool = False, num_kv_shared_layers: int = 0, use_double_wide_mlp: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4_unified/configuration_gemma4_unified.py#L88) **Parâmetros:** vocab_size (`int`, *opcional*, padrão `262144`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`. hidden_size (`int`, *opcional*, padrão `2304`) : Dimensão das representações ocultas. intermediate_size (`int`, *opcional*, padrão `9216`) : Dimensão das representações do MLP. num_hidden_layers (`int`, *opcional*, padrão `30`) : Número de camadas ocultas no decodificador do Transformer. num_attention_heads (`int`, *opcional*, padrão `8`) : 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 `4`) : 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 `256`) : A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads hidden_activation (`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. max_position_embeddings (`int`, *opcional*, padrão `262144`) : O comprimento máximo de sequência com o qual este modelo pode ser usado. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. rms_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização rms. 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. pad_token_id (`int`, *opcional*, padrão `0`) : ID do token usado para preenchimento no vocabulário. eos_token_id (`Union[int, list[int]]`, *opcional*, padrão `1`) : ID do token usado para o fim do fluxo no vocabulário. bos_token_id (`int`, *opcional*, padrão `2`) : ID do token usado para o início do fluxo no vocabulário. 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. rope_parameters (`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. 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. attention_dropout (`Union[int, float]`, *opcional*, padrão `0.0`) : A taxa de dropout para as probabilidades de atenção. sliding_window (`int`, *opcional*, padrão `1024`) : Tamanho da janela de atenção deslizante. Se `None`, nenhuma janela deslizante é aplicada. layer_types (`list[str]`, *opcional*) : Uma lista que mapeia explicitamente cada índice de camada com seu tipo de camada. Se não for fornecida, será gerada automaticamente com base nos valores de config. final_logit_softcapping (`float`, *opcional*) : Valor de soft-capping aplicado aos logits finais antes de calcular a distribuição de probabilidade. Os logits são escalados por `tanh(logit / cap) * cap`. use_bidirectional_attention (`str`, *opcional*) : Controla o comportamento da atenção bidirecional. Quando definido como `"vision"`, os tokens de visão usam atenção bidirecional, enquanto os tokens de texto usam atenção causal. Quando definido como `"all"`, todos os tokens usam atenção bidirecional. attention_k_eq_v (`bool`, padrão `False`) : Se as chaves e os valores compartilham os mesmos pesos de projeção. Quando `True`, a saída da projeção de chave é reutilizada como a projeção de valor. num_kv_shared_layers (`int`, padrão 0) : Número de camadas consecutivas do decodificador que compartilham as mesmas projeções de chave-valor. Um valor de 0 significa que não há compartilhamento (cada camada possui projeções de KV independentes). use_double_wide_mlp (`bool`, padrão `False`) : Se deve usar um MLP de largura dupla com projeções de gate e up fundidas. Esta é a classe de configuração para armazenar a configuração de um Gemma4UnifiedModel. Ela é usada para instanciar um modelo Gemma4 Unified 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 [google/gemma-4-12B-it](https://huggingface.co/google/gemma-4-12B-it) 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. ## Gemma4UnifiedVisionConfig[[transformers.Gemma4UnifiedVisionConfig]] #### transformers.Gemma4UnifiedVisionConfig[[transformers.Gemma4UnifiedVisionConfig]] ```python transformers.Gemma4UnifiedVisionConfig(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, patch_size: int = 16, pooling_kernel_size: int = 3, mm_embed_dim: int = 3840, mm_posemb_size: int = 1120, rms_norm_eps: float = 1e-06, output_proj_dims: int = 3840, initializer_range: float = 0.02) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4_unified/configuration_gemma4_unified.py#L238) **Parâmetros:** patch_size (`int`, padrão 16) : Tamanho dos patches de imagem em pixels. As imagens são primeiro divididas em patches nessa resolução. pooling_kernel_size (`int`, padrão 3) : Tamanho do kernel para mesclar patches em patches do modelo. Uma mesclagem 3×3 produz patches do modelo de tamanho `patch_size * pooling_kernel_size = 48` pixels. mm_embed_dim (`int`, padrão 3840) : Dimensão oculta para a projeção Dense do embedding de patch (corresponde ao `hidden_size` do modelo de texto). mm_posemb_size (`int`, padrão 1120) : Tamanho da tabela de incorporação posicional 2D fatorada. A tabela tem a forma `(mm_posemb_size, 2, mm_embed_dim)` e é consultada por eixo. rms_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização rms. output_proj_dims (`int`, padrão 3840) : Dimensão de saída da projeção do incorporador multimodal (mapeia para o tamanho oculto do texto). Isso é definido pelo text_config.hidden_size da configuração composta em tempo de execuçã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 Gemma4UnifiedModel. Ela é usada para instanciar um modelo Gemma4 Unified 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 [google/gemma-4-12B-it](https://huggingface.co/google/gemma-4-12B-it) 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. ## Gemma4UnifiedAudioFeatureExtractor[[transformers.Gemma4UnifiedAudioFeatureExtractor]] #### transformers.Gemma4UnifiedAudioFeatureExtractor[[transformers.Gemma4UnifiedAudioFeatureExtractor]] ```python transformers.Gemma4UnifiedAudioFeatureExtractor(feature_size: int = 640, sampling_rate: int = 16000, padding_value: float = 0.0, audio_samples_per_token: int = 640, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4_unified/feature_extraction_gemma4_unified.py#L30) **Parâmetros:** feature_size (`int`, *opcional*, padrão 640) : A dimensão dos recursos dos recursos extraídos (amostras por token). sampling_rate (`int`, *opcional*, padrão 16000) : A taxa de amostragem na qual os arquivos de áudio devem ser digitalizados, expressa em hertz (Hz). padding_value (`float`, *opcional*, padrão 0.0) : Valor de preenchimento usado para preencher o áudio. audio_samples_per_token (`int`, *opcional*, padrão 640) : Número de amostras de áudio bruto por token de saída. A 16 kHz, 640 amostras = 40 ms. Extrator de recursos de áudio sem codificador que divide a forma de onda bruta em quadros. Diferentemente do extrator de recursos de áudio padrão do Gemma4, que calcula espectrogramas mel, esta versão unificada simplesmente divide o áudio bruto de 16 kHz em quadros de comprimento fixo, cada um com `audio_samples_per_token` amostras. Cada quadro se torna um único soft token de áudio, com as amostras da forma de onda bruta como seus recursos. #### __call__[[transformers.Gemma4UnifiedAudioFeatureExtractor.__call__]] ```python __call__(raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]], padding: bool | str = 'longest', max_length: int | None = None, truncation: bool = True, return_tensors: str | transformers.utils.generic.TensorType | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4_unified/feature_extraction_gemma4_unified.py#L95) **Parâmetros:** raw_speech : As formas de onda de áudio bruto(s) a serem processadas. padding (`str`, *opcional*, padrão `"longest"`) : Estratégia de preenchimento para lotes com comprimentos diferentes. max_length (`int`, *opcional*) : Número máximo de tokens a serem gerados por áudio. truncation (`bool`, *opcional*, padrão `True`) : Se deve truncar o áudio acima de `max_length` tokens. return_tensors (`str`, *opcional*) : O tipo dos tensores a serem retornados. Divida as formas de onda de áudio bruto em quadros de comprimento fixo para o modelo unificado. ## Gemma4UnifiedImageProcessor[[transformers.Gemma4UnifiedImageProcessor]] #### transformers.Gemma4UnifiedImageProcessor[[transformers.Gemma4UnifiedImageProcessor]] ```python transformers.Gemma4UnifiedImageProcessor(**kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4_unified/image_processing_gemma4_unified.py#L214) **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 `None`) : Descreve as dimensões de entrada máximas 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 `3`) : 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 `False`) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*, padrão `[0.0, 0.0, 0.0]`) : 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 `[1.0, 1.0, 1.0]`) : 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. patch_size (`int`, *kwargs*, *opcional*) : Tamanho de cada patch de imagem do professor em pixels (antes da fusão). max_soft_tokens (`int`, *kwargs*, *opcional*) : Número máximo de tokens suaves (de visão) por imagem após a fusão de patches. Deve ser um dos valores {70, 140, 280, 560, 1120}. pooling_kernel_size (`int`, *kwargs*, *opcional*) : Tamanho do kernel para mesclar os patches do professor nos patches do modelo. Constrói um processador de imagem unificado Gemma4. ## Gemma4UnifiedVideoProcessor[[transformers.Gemma4UnifiedVideoProcessor]] #### transformers.Gemma4UnifiedVideoProcessor[[transformers.Gemma4UnifiedVideoProcessor]] ```python transformers.Gemma4UnifiedVideoProcessor(**kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4_unified/video_processing_gemma4_unified.py#L216) **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 `None`) : Descreve as dimensões de entrada máximas 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 `3`) : 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.0, 0.0, 0.0]`) : 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 `[1.0, 1.0, 1.0]`) : 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 `32`) : 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*) : Tamanho de cada patch de imagem em pixels. max_soft_tokens (`int`, *kwargs*, *opcional*) : Número máximo de tokens suaves (de visão) por quadro de vídeo. Deve ser um dos valores {70, 140, 280, 560, 1120}. pooling_kernel_size (`int`, *kwargs*, *opcional*) : Tamanho do kernel de pooling espacial aplicado após a patchification. - ****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 Gemma4UnifiedVideoProcessor. #### preprocess[[transformers.Gemma4UnifiedVideoProcessor.preprocess]] ```python preprocess(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]]], **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4_unified/video_processing_gemma4_unified.py#L275) **Parâmetros:** 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]]]`) : Vídeo a ser pré-processado. 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`. 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. 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_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*) : 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*) : Número máximo de quadros a amostrar quando `do_sample_frames=True`. return_metadata (`bool`, *kwargs*, *opcional*) : Se deve ou não retornar os 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*) : Retorna tensores empilhados se definido como `'pt'`, caso contrário, retorna uma lista de tensores. patch_size (`int`, *kwargs*, *opcional*) : Tamanho de cada patch de imagem em pixels. max_soft_tokens (`int`, *kwargs*, *opcional*) : Número máximo de tokens suaves (de visão) por quadro de vídeo. Deve ser um dos valores {70, 140, 280, 560, 1120}. pooling_kernel_size (`int`, *kwargs*, *opcional*) : Tamanho do kernel de pooling espacial aplicado após a patchification. **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. ## Gemma4UnifiedProcessor[[transformers.Gemma4UnifiedProcessor]] #### transformers.Gemma4UnifiedProcessor[[transformers.Gemma4UnifiedProcessor]] ```python transformers.Gemma4UnifiedProcessor(feature_extractor, image_processor, tokenizer, video_processor, chat_template = None, image_seq_length: int = 280, audio_seq_length: int = 750, audio_ms_per_token: int = 40, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4_unified/processing_gemma4_unified.py#L107) **Parâmetros:** feature_extractor (*Gemma4UnifiedAudioFeatureExtractor*) : O extrator de recursos é uma entrada obrigatória. image_processor (*Gemma4UnifiedImageProcessor*) : O processador de imagens é uma entrada obrigatória. tokenizer (*tokenizer_class*) : O tokenizer é uma entrada obrigatória. video_processor (*Gemma4UnifiedVideoProcessor*) : 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. image_seq_length (*int*, *opcional*, padrão 280) : O número de tokens suaves por imagem usados para a expansão do placeholder. audio_seq_length (*int*, *optional*, padrão 750) : O número máximo de soft tokens de áudio por segmento de áudio. Atua como um limite superior quando as contagens dinâmicas de tokens de áudio são calculadas. audio_ms_per_token (*int*, *opcional*, padrão 40) : Milissegundos de áudio por token suave de saída. Usado para calcular dinamicamente o número de tokens de espaço reservado de áudio como `ceil(duration_ms / audio_ms_per_token)`. O padrão de 40 vem da redução de tempo 4× da convolução SSCP em quadros de 10 ms. Constrói um Gemma4UnifiedProcessor que encapsula um extrator de recursos, um processador de imagem, um tokenizador e um processador de vídeo em um único processador. [*Gemma4UnifiedProcessor*] oferece todas as funcionalidades de [*Gemma4UnifiedAudioFeatureExtractor*], [*Gemma4UnifiedImageProcessor*], [*tokenizer_class*] e [*Gemma4UnifiedVideoProcessor*]. Consulte [*~Gemma4UnifiedAudioFeatureExtractor*], [*~Gemma4UnifiedImageProcessor*], [*~tokenizer_class*] e [*~Gemma4UnifiedVideoProcessor*] para mais informações. #### __call__[[transformers.Gemma4UnifiedProcessor.__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, audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/processing_utils.py#L653) **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`. audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`, *opcional*) : O áudio ou lote de áudios a ser preparado. Cada áudio pode ser um array NumPy ou um tensor PyTorch. No caso de um array NumPy/tensor PyTorch, cada áudio deve ter a forma (C, T), onde C é o número de canais e T é o comprimento de amostras do áudio. 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. ## Gemma4UnifiedPreTrainedModel[[transformers.Gemma4UnifiedPreTrainedModel]] #### transformers.Gemma4UnifiedPreTrainedModel[[transformers.Gemma4UnifiedPreTrainedModel]] ```python transformers.Gemma4UnifiedPreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4_unified/modeling_gemma4_unified.py#L527) **Parâmetros:** config ([PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig)) : 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. 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.Gemma4UnifiedPreTrainedModel.forward]] ```python forward(*args, **kwargs) ``` Um valor simulado para um caminho pontilhado (por exemplo, `torch.float32`): as cadeias de acesso a atributos e as chamadas se comportam como decoradores de passagem, o `repr` é o caminho pontilhado, e o uso como classe base substitui uma base de `type` simples (PEP 560 `__mro_entries__`), de modo que as subclasses reais mantêm um metaclass normal e o `inspect.signature` lê o `__init__` real delas, em vez do de um mock. ## Gemma4UnifiedModel[[transformers.Gemma4UnifiedModel]] #### transformers.Gemma4UnifiedModel[[transformers.Gemma4UnifiedModel]] ```python transformers.Gemma4UnifiedModel(config: Gemma4UnifiedConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4_unified/modeling_gemma4_unified.py#L863) **Parâmetros:** config ([Gemma4UnifiedConfig](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedConfig)) : 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 base Gemma 4, composto por um backbone de visão, um backbone de áudio 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.Gemma4UnifiedModel.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, input_features: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, input_features_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, mm_token_type_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, image_position_ids: typing.Optional[torch.LongTensor] = None, video_position_ids: typing.Optional[torch.LongTensor] = None, num_frames_per_video: 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/gemma4_unified/modeling_gemma4_unified.py#L964) **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 [Gemma4UnifiedImageProcessor](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedImageProcessor). Veja [Gemma4UnifiedImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([Gemma4UnifiedProcessor](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedProcessor) usa [Gemma4UnifiedImageProcessor](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedImageProcessor) para processar imagens). 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 [Gemma4UnifiedVideoProcessor](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedVideoProcessor). Veja [Gemma4UnifiedVideoProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para detalhes ([Gemma4UnifiedProcessor](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedProcessor) usa [Gemma4UnifiedVideoProcessor](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedVideoProcessor) para processar vídeos). input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando [Gemma4UnifiedAudioFeatureExtractor](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedAudioFeatureExtractor). Veja [Gemma4UnifiedAudioFeatureExtractor.__call__()](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedAudioFeatureExtractor.__call__) para detalhes ([Gemma4UnifiedProcessor](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedProcessor) usa [Gemma4UnifiedAudioFeatureExtractor](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedAudioFeatureExtractor) para processar áudios). 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) input_features_mask (`torch.Tensor` de forma `(num_images, seq_length)`) : A máscara de atenção para o áudio de entrada. 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)`. 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.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`). image_position_ids (`torch.LongTensor` de forma `(batch_size, max_patches, 2)`, *opcional*) : coordenadas de posição dos patches 2D do processador de imagem, em que `(-1, -1)` indica preenchimento. Transmitidas ao codificador de visão para o cálculo do embedding posicional. video_position_ids (`torch.LongTensor` de forma `(total_num_frames, max_patches, 2)`, *opcional*) : coordenadas de posição dos patches 2D do processador de vídeo, em que `(-1, -1)` indica preenchimento. Transmitidas ao codificador de visão para o cálculo do embedding posicional. num_frames_per_video (`torch.LongTensor` de forma `(num_videos,)`, *opcional*) : Número de quadros pertencentes a cada vídeo. Obrigatório sempre que `pixel_values_videos` for passado, pois os quadros de todos os vídeos são concatenados ao longo de um único eixo. 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:** `Gemma4UnifiedModelOutputWithPast` ou `tuple(torch.Tensor)` Um `Gemma4UnifiedModelOutputWithPast` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) compreendendo vários elementos dependendo da configuração ([Gemma4UnifiedConfig](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedConfig)) e das entradas. O método forward do [Gemma4UnifiedModel](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedModel) 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.Tensor` 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.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. - **image_hidden_states** (`torch.Tensor`, *opcional*) -- Um `torch.Tensor` 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. - **audio_hidden_states** (`torch.Tensor`, *opcional*) -- Um `torch.Tensor` de tamanho `(batch_size, num_images, sequence_length, hidden_size)`. audio_hidden_states do modelo produzido pelo codificador de áudio e após projetar o último estado oculto. - **shared_kv_states** (`dict`, *opcional*) -- Dicionário que mapeia strings de tipo de camada para tuplas de tensores (key_states, value_states). Usado para passar estados KV compartilhados entre camadas durante o compartilhamento de KV. ## Gemma4UnifiedTextModel[[transformers.Gemma4UnifiedTextModel]] #### transformers.Gemma4UnifiedTextModel[[transformers.Gemma4UnifiedTextModel]] ```python transformers.Gemma4UnifiedTextModel(config: Gemma4UnifiedTextConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4_unified/modeling_gemma4_unified.py#L560) **Parâmetros:** config ([Gemma4UnifiedTextConfig](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedTextConfig)) : 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 linguagem unificado base Gemma 4 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.Gemma4UnifiedTextModel.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, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4_unified/modeling_gemma4_unified.py#L588) **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`). **Retorna:** `Gemma4UnifiedTextModelOutputWithPast` ou `tuple(torch.Tensor)` Um `Gemma4UnifiedTextModelOutputWithPast` ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) compreendendo vários elementos dependendo da configuração ([Gemma4UnifiedConfig](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedConfig)) e das entradas. O método forward do [Gemma4UnifiedTextModel](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedTextModel) 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. - **shared_kv_states** (`dict`, *opcional*) -- Dicionário que mapeia strings de tipo de camada para tuplas de tensores (key_states, value_states). Usado para passar estados KV compartilhados entre camadas durante o compartilhamento de KV. ## Gemma4UnifiedForCausalLM[[transformers.Gemma4UnifiedForCausalLM]] #### transformers.Gemma4UnifiedForCausalLM[[transformers.Gemma4UnifiedForCausalLM]] ```python transformers.Gemma4UnifiedForCausalLM(config: Gemma4UnifiedTextConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4_unified/modeling_gemma4_unified.py#L664) **Parâmetros:** config ([Gemma4UnifiedTextConfig](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedTextConfig)) : 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 linguagem base Gemma 4 com 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.Gemma4UnifiedForCausalLM.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, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4_unified/modeling_gemma4_unified.py#L681) **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. 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). **Retorna:** `Gemma4UnifiedCausalLMOutputWithPast` ou `tuple(torch.Tensor)` Um `Gemma4UnifiedCausalLMOutputWithPast` 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 ([Gemma4UnifiedConfig](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedConfig)) e das entradas. O método forward de [Gemma4UnifiedForCausalLM](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedForCausalLM) 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.text_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) 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.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. - **image_hidden_states** (`torch.Tensor`, *opcional*) -- Um `torch.Tensor` de tamanho `(batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states do modelo produzido pelo codificador de visão após projetar o último estado oculto. - **audio_hidden_states** (`torch.Tensor`, *opcional*) -- Um `torch.Tensor` de tamanho `(batch_size, num_images, sequence_length, hidden_size)`. audio_hidden_states do modelo produzido pelo codificador de áudio e após projetar o último estado oculto. - **shared_kv_states** (`dict`, *opcional*) -- Dicionário que mapeia strings de tipo de camada para tuplas de tensores (key_states, value_states). Usado para passar estados KV compartilhados entre camadas durante o compartilhamento de KV. Exemplo: ```python >>> from transformers import AutoTokenizer, Gemma4UnifiedForCausalLM >>> model = Gemma4UnifiedForCausalLM.from_pretrained("google/gemma-4-12B-it") >>> tokenizer = AutoTokenizer.from_pretrained("google/gemma-4-12B-it") >>> prompt = "What is your favorite condiment?" >>> inputs = tokenizer(prompt, return_tensors="pt") >>> # Generate >>> generate_ids = model.generate(inputs.input_ids, max_length=30) >>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0] "What is your favorite condiment?" ``` ## Gemma4UnifiedForConditionalGeneration[[transformers.Gemma4UnifiedForConditionalGeneration]] #### transformers.Gemma4UnifiedForConditionalGeneration[[transformers.Gemma4UnifiedForConditionalGeneration]] ```python transformers.Gemma4UnifiedForConditionalGeneration(config: Gemma4UnifiedConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma4_unified/modeling_gemma4_unified.py#L1274) **Parâmetros:** config ([Gemma4UnifiedConfig](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedConfig)) : 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 base Gemma 4, composto por um backbone de visão, um backbone de áudio, um modelo de linguagem e 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.Gemma4UnifiedForConditionalGeneration.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, input_features: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, input_features_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, image_position_ids: typing.Optional[torch.LongTensor] = None, video_position_ids: typing.Optional[torch.LongTensor] = None, num_frames_per_video: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, mm_token_type_ids: typing.Optional[torch.LongTensor] = 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/gemma4_unified/modeling_gemma4_unified.py#L1300) **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 [Gemma4UnifiedImageProcessor](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedImageProcessor). Veja [Gemma4UnifiedImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([Gemma4UnifiedProcessor](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedProcessor) usa [Gemma4UnifiedImageProcessor](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedImageProcessor) para processar imagens). 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 [Gemma4UnifiedVideoProcessor](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedVideoProcessor). Veja [Gemma4UnifiedVideoProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2VideoProcessor.__call__) para detalhes ([Gemma4UnifiedProcessor](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedProcessor) usa [Gemma4UnifiedVideoProcessor](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedVideoProcessor) para processar vídeos). input_features (`torch.Tensor` de forma `(batch_size, sequence_length, feature_dim)`, *opcional*) : Os tensores correspondentes às características de áudio de entrada. As características de áudio podem ser obtidas usando [Gemma4UnifiedAudioFeatureExtractor](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedAudioFeatureExtractor). Veja [Gemma4UnifiedAudioFeatureExtractor.__call__()](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedAudioFeatureExtractor.__call__) para detalhes ([Gemma4UnifiedProcessor](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedProcessor) usa [Gemma4UnifiedAudioFeatureExtractor](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedAudioFeatureExtractor) para processar áudios). 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) input_features_mask (`torch.Tensor` de forma `(num_images, seq_length)`) : A máscara de atenção para o áudio de entrada. 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) image_position_ids (`torch.LongTensor` de forma `(batch_size, max_patches, 2)`, *opcional*) : coordenadas de posição dos patches 2D do processador de imagem, em que `(-1, -1)` indica preenchimento. Transmitidas ao codificador de visão para o cálculo do embedding posicional. video_position_ids (`torch.LongTensor` de forma `(total_num_frames, max_patches, 2)`, *opcional*) : coordenadas de posição dos patches 2D do processador de vídeo, em que `(-1, -1)` indica preenchimento. Transmitidas ao codificador de visão para o cálculo do embedding posicional. num_frames_per_video (`torch.LongTensor` de forma `(num_videos,)`, *opcional*) : Número de quadros pertencentes a cada vídeo. Obrigatório sempre que `pixel_values_videos` for passado, pois os quadros de todos os vídeos são concatenados ao longo de um único eixo. 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.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. 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:** `Gemma4UnifiedCausalLMOutputWithPast` ou `tuple(torch.Tensor)` Um `Gemma4UnifiedCausalLMOutputWithPast` 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 ([Gemma4UnifiedConfig](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedConfig)) e das entradas. O método forward de [Gemma4UnifiedForConditionalGeneration](/docs/transformers/main/pt/model_doc/gemma4_unified#transformers.Gemma4UnifiedForConditionalGeneration) 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.text_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) 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.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. - **image_hidden_states** (`torch.Tensor`, *opcional*) -- Um `torch.Tensor` de tamanho `(batch_size, num_images, sequence_length, hidden_size)`. image_hidden_states do modelo produzido pelo codificador de visão após projetar o último estado oculto. - **audio_hidden_states** (`torch.Tensor`, *opcional*) -- Um `torch.Tensor` de tamanho `(batch_size, num_images, sequence_length, hidden_size)`. audio_hidden_states do modelo produzido pelo codificador de áudio e após projetar o último estado oculto. - **shared_kv_states** (`dict`, *opcional*) -- Dicionário que mapeia strings de tipo de camada para tuplas de tensores (key_states, value_states). Usado para passar estados KV compartilhados entre camadas durante o compartilhamento de KV. Exemplo: ```python >>> from PIL import Image >>> from transformers import AutoProcessor, Gemma4UnifiedForConditionalGeneration >>> model = Gemma4UnifiedForConditionalGeneration.from_pretrained("google/gemma-4-12B-it") >>> processor = AutoProcessor.from_pretrained("google/gemma-4-12B-it") >>> 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] ```