# Gemma3n ## Visão geral [Gemma3n](https://developers.googleblog.com/en/introducing-gemma-3n/) é um modelo multimodal com variantes pré-treinadas e ajustadas por instrução, disponível nos tamanhos E4B e E2B. Embora grandes partes da arquitetura do modelo de linguagem sejam compartilhadas com as versões anteriores do Gemma, este modelo traz muitas novidades, incluindo [Alternating Updates][altup] (AltUp), [Learned Augmented Residual Layer][laurel] (LAuReL), [MatFormer][matformer], Per-Layer Embeddings (PLE), [Activation Sparsity with Statistical Top-k][spark-transformer] e compartilhamento de cache KV. O modelo de linguagem utiliza um padrão de atenção semelhante ao do [Gemma 3](./gemma3), com camadas alternadas de autoatenção local com janela deslizante (4 camadas locais para cada camada global) e um comprimento máximo de contexto de 32k tokens. O Gemma 3n introduz o MobileNet v5 como codificador de visão, usando uma resolução padrão de 768x768 pixels, e adiciona um codificador de áudio recém-treinado baseado na arquitetura [Universal Speech Model][usm] (USM). A variante ajustada por instrução foi pós-treinada com destilação de conhecimento e aprendizado por reforço. Você pode encontrar todos os checkpoints originais do Gemma 3n na release [Gemma 3n][gemma3n-collection]. > [!TIP] > Clique nos modelos Gemma 3n na barra lateral à direita para ver mais exemplos de como aplicar o Gemma em diferentes tarefas de visão, áudio e linguagem. > > Defina `use_kernels=True` em [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para substituir camadas compatíveis por kernels otimizados do Hub. Consulte [Carregando kernels](../kernel_doc/loading_kernels) para saber mais. O exemplo abaixo demonstra como gerar texto com base em uma imagem usando [Pipeline](/docs/transformers/main/pt/main_classes/pipelines#transformers.Pipeline) ou a classe [AutoModel](/docs/transformers/main/pt/model_doc/auto#transformers.AutoModel). ```python from transformers import pipeline pipeline = pipeline( task="image-text-to-text", model="google/gemma-3n-e4b", device=0, ) pipeline( "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg", text=" What is shown in this image?" ) ``` ```python from transformers import AutoProcessor, Gemma3nForConditionalGeneration model = Gemma3nForConditionalGeneration.from_pretrained( "google/gemma-3n-e4b-it", device_map="auto", attn_implementation="sdpa" ) processor = AutoProcessor.from_pretrained( "google/gemma-3n-e4b-it", padding_side="left" ) messages = [ { "role": "system", "content": [ {"type": "text", "text": "You are a helpful assistant."} ] }, { "role": "user", "content": [ {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"}, {"type": "text", "text": "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) output = model.generate(**inputs, max_new_tokens=50, cache_implementation="static") print(processor.decode(output[0], skip_special_tokens=True)) ``` ## Observações - Use [Gemma3nForConditionalGeneration](/docs/transformers/main/pt/model_doc/gemma3n#transformers.Gemma3nForConditionalGeneration) para entradas de imagem, áudio e texto, imagem e texto, imagem e áudio, áudio e texto, apenas imagem e apenas áudio. - O Gemma 3n suporta múltiplas imagens por entrada, mas certifique-se de que as imagens estejam corretamente agrupadas (batched) antes de passá-las ao processador. Cada lote (batch) deve ser uma lista com uma ou mais imagens. ```py url_cow = "https://media.istockphoto.com/id/1192867753/photo/cow-in-berchida-beach-siniscola.jpg?s=612x612&w=0&k=20&c=v0hjjniwsMNfJSuKWZuIn8pssmD5h5bSN1peBd1CmH4=" url_cat = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg" messages =[ { "role": "system", "content": [ {"type": "text", "text": "You are a helpful assistant."} ] }, { "role": "user", "content": [ {"type": "image", "url": url_cow}, {"type": "image", "url": url_cat}, {"type": "text", "text": "Which image is cuter?"}, ] }, ] ``` - O texto passado ao processador deve ter um token `` em cada local onde uma imagem deve ser inserida. - O Gemma 3n aceita no máximo um clipe de áudio de destino por entrada, embora seja possível fornecer vários clipes de áudio em prompts few-shot, por exemplo. - O texto passado ao processador deve ter um token `` em cada local onde um clipe de áudio deve ser inserido. - O processador possui seu próprio método [apply_chat_template()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.apply_chat_template) para converter mensagens de chat em entradas do modelo. ## Gemma3nAudioFeatureExtractor[[transformers.Gemma3nAudioFeatureExtractor]] #### transformers.Gemma3nAudioFeatureExtractor[[transformers.Gemma3nAudioFeatureExtractor]] ```python transformers.Gemma3nAudioFeatureExtractor(feature_size: int = 128, sampling_rate: int = 16000, padding_value: float = 0.0, return_attention_mask: bool = True, frame_length_ms: float = 32.0, hop_length_ms: float = 10.0, min_frequency: float = 125.0, max_frequency: float = 7600.0, preemphasis: float = 0.97, preemphasis_htk_flavor: bool = True, fft_overdrive: bool = True, dither: float = 0.0, input_scale_factor: float = 1.0, mel_floor: float = 1e-05, per_bin_mean: collections.abc.Sequence[float] | None = None, per_bin_stddev: collections.abc.Sequence[float] | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/feature_extraction_gemma3n.py#L108) **Parâmetros:** feature_size (`int`, *opcional*, padrão 128) : A dimensão dos recursos das características extraídas. 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. Deve corresponder a silêncios. return_attention_mask (`bool`, *opcional*, padrão `True`) : Se deve retornar a máscara de atenção para os espectrogramas MEL gerados. frame_length_ms (`float`, *opcional*, padrão 32.0) : O comprimento de um quadro em milissegundos. hop_length_ms (`float`, *opcional*, padrão 10.0) : Comprimento das janelas sobrepostas para a STFT usada para obter os coeficientes de Frequência Mel. min_frequency (`float`, *opcional*, padrão 125.0) : A frequência mínima (em Hz) para o banco de filtros Mel. max_frequency (`float`, *opcional*, padrão 7600.0) : A frequência máxima (em Hz) para o banco de filtros Mel. preemphasis (`float`, *opcional*, padrão 0.97) : O coeficiente de pré-ênfase. preemphasis_htk_flavor (`bool`, *opcional*, padrão `True`) : Se deve usar pré-ênfase no estilo HTK. fft_overdrive (`bool`, *opcional*, padrão `True`) : Se deve usar overdrive de FFT. dither (`float`, *opcional*, padrão 0.0) : Adiciona dithering. Em outras palavras, adiciona um pequeno ruído gaussiano a cada quadro. Por exemplo, use 0.0001 para adicionar dithering com uma distribuição normal centrada em 0.0 com desvio padrão de 0.0001 (assumindo intervalo [-1,+1] para raw_speech). O valor 0.0 significa sem dithering. O dithering tem efeito semelhante ao de `spectrogram(mel_floor=...)`. Ele reduz os valores altos de log_mel_fbank para sinais com seções de zero duro, quando há um corte de VAD presente no sinal. input_scale_factor (`float`, *opcional*, padrão 1.0) : Fator de escala aplicado à forma de onda de entrada. mel_floor (`float`, *opcional*, padrão 1e-05) : Valor mínimo para os espectrogramas Mel para evitar log(0). per_bin_mean (`Optional[Sequence[float]]`, *opcional*) : Valores médios para normalização por bin. per_bin_stddev (`Optional[Sequence[float]]`, *opcional*) : Valores de desvio padrão para normalização por bin. Um extrator de recursos de áudio Universal Speech Models https://huggingface.co/papers/2303.01037. ## Gemma3nProcessor[[transformers.Gemma3nProcessor]] #### transformers.Gemma3nProcessor[[transformers.Gemma3nProcessor]] ```python transformers.Gemma3nProcessor(feature_extractor, image_processor, tokenizer, chat_template = None, audio_seq_length: int = 188, image_seq_length: int = 256, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/processing_gemma3n.py#L32) **Parâmetros:** feature_extractor (`Gemma3nAudioFeatureExtractor`) : O extrator de recursos é uma entrada obrigatória. image_processor (`SiglipImageProcessor`) : O processador de imagem é uma entrada obrigatória. tokenizer (`GemmaTokenizer`) : O tokenizer é uma entrada obrigatória. chat_template (`str`) : Um modelo Jinja para converter listas de mensagens em um chat em uma string tokenizável. audio_seq_length (`int`, *opcional*, padrão 188) : O número de tokens de áudio suaves que serão adicionados ao prompt de texto image_seq_length (`int`, *opcional*, padrão 256) : O número de soft tokens de imagem que devem ser adicionados Constrói um Gemma3nProcessor que encapsula um extrator de recursos, um processador de imagem e um tokenizador em um único processador. [Gemma3nProcessor](/docs/transformers/main/pt/model_doc/gemma3n#transformers.Gemma3nProcessor) oferece todas as funcionalidades de [Gemma3nAudioFeatureExtractor](/docs/transformers/main/pt/model_doc/gemma3n#transformers.Gemma3nAudioFeatureExtractor), [SiglipImageProcessor](/docs/transformers/main/pt/model_doc/siglip#transformers.SiglipImageProcessor) e [GemmaTokenizer](/docs/transformers/main/pt/model_doc/gemma#transformers.GemmaTokenizer). Consulte [~Gemma3nAudioFeatureExtractor](/docs/transformers/main/pt/model_doc/gemma3n#transformers.Gemma3nAudioFeatureExtractor), [~SiglipImageProcessor](/docs/transformers/main/pt/model_doc/siglip#transformers.SiglipImageProcessor) e [~GemmaTokenizer](/docs/transformers/main/pt/model_doc/gemma#transformers.GemmaTokenizer) para mais informações. #### __call__[[transformers.Gemma3nProcessor.__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, audio: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]] | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/processing_gemma3n.py#L73) **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. audio (`Union[numpy.ndarray, list[float], list[numpy.ndarray], list[list[float]]]`, *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. **Retorna:** `~feature_extraction_utils.BatchFeature` - **data** (`dict`, *opcional*) -- Dicionário de listas/arrays/tensors retornados pelos métodos __call__/pad ('input_values', 'attention_mask', 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. - **skip_tensor_conversion** (`list[str]` ou `set[str]`, *opcional*) -- Lista ou conjunto de chaves que NÃO devem ser convertidas em tensores, mesmo quando `tensor_type` for especificado. ## Gemma3nTextConfig[[transformers.Gemma3nTextConfig]] #### transformers.Gemma3nTextConfig[[transformers.Gemma3nTextConfig]] ```python transformers.Gemma3nTextConfig(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 = 262400, hidden_size: int = 2048, intermediate_size: int | list[int] = 16384, num_hidden_layers: int = 35, num_attention_heads: int = 8, num_key_value_heads: int = 2, head_dim: int = 256, hidden_activation: str = 'gelu_pytorch_tanh', max_position_embeddings: int = 32768, 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 = 512, layer_types: list[str] | None = None, final_logit_softcapping: float = 30.0, vocab_size_per_layer_input: int = 262144, hidden_size_per_layer_input: int = 256, altup_active_idx: int = 0, altup_coef_clip: float = 120.0, altup_correct_scale: bool = True, altup_num_inputs: int = 4, num_kv_shared_layers: int = 15, laurel_rank: int = 64, activation_sparsity_pattern: float | list[float] | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/configuration_gemma3n.py#L36) **Parâmetros:** vocab_size (`int`, *opcional*, padrão `262400`) : 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 `2048`) : Dimensão das representações ocultas. intermediate_size (`Union[int, list[int]]`, *opcional*, padrão `16384`) : Dimensão das representações do MLP. num_hidden_layers (`int`, *opcional*, padrão `35`) : 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 `2`) : 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 `32768`) : 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 `512`) : 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*, padrão `30.0`) : Valor de limitação suave aplicado aos logits finais antes de calcular a distribuição de probabilidade. Os logits são escalados por `tanh(logit / cap) * cap`. vocab_size_per_layer_input (`int`, *opcional*, padrão 262144) : Tamanho do vocabulário dos embeddings de texto por camada que complementam os embeddings padrão. hidden_size_per_layer_input (`int`, *opcional*, padrão 256) : Dimensão das representações ocultas para incorporações por camada. altup_active_idx (`int`, *opcional*, padrão 0) : O índice da previsão a partir da qual o AltUp calculará previsões adicionais ou corrigirá a previsão ativa. altup_coef_clip (`float`, *opcional*, padrão 120.0) : A amplitude máxima de um peso de coeficiente de previsão ou correção AltUp. altup_correct_scale (`bool`, *opcional*, padrão `True`) : Se True, aplica o `AltUp.correct_output_scale` à previsão corrigida em `altup_active_idx`. altup_num_inputs (`int`, *opcional*, padrão 4) : O número de previsões que o AltUp deve fazer com base na sequência de entrada. num_kv_shared_layers (`int`, *opcional*, padrão 15) : O número de camadas que compartilham os valores do cache de KV. Durante a passagem para frente, as últimas `num_kv_shared_layers` camadas do modelo "compartilham" os valores de KV, de modo que cada camada local e global dentro dessa faixa utiliza os valores do cache de KV calculados para a última camada local ou global, respectivamente, antes de entrar nessa faixa. O valor deve ser um múltiplo do tamanho do padrão de atenção (veja o parâmetro `layer_types`). laurel_rank (`int`, *opcional*, padrão 64) : O tamanho intermediário para as projeções lineares na Learned Augmented Residual Layer. activation_sparsity_pattern (`Sequence[float]`, *opcional*) : O fator de esparsidade usado para extrair as ativações top-k de uma camada específica. A Sequence fornecida deve explicitamente fornecer um valor de esparsidade para cada camada do modelo. Por padrão, as primeiras 10 camadas são esparsas com um fator de esparsidade de 0,95 e as demais são densas. Esta é a classe de configuração para armazenar a configuração de um Gemma3nModel. Ela é usada para instanciar um modelo Gemma3N 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-3n-E4B](https://huggingface.co/google/gemma-3n-E4B) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. ```python >>> from transformers import Gemma3nTextModel, Gemma3nTextConfig >>> # Initializing a Gemma3nText gemma3n_text-E4B style configuration >>> configuration = Gemma3nTextConfig() >>> # Initializing a model from the gemma3n_text-E4B style configuration >>> model = Gemma3nTextModel(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Gemma3nVisionConfig[[transformers.Gemma3nVisionConfig]] #### transformers.Gemma3nVisionConfig[[transformers.Gemma3nVisionConfig]] ```python transformers.Gemma3nVisionConfig(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, architecture: str = 'mobilenetv5_300m_enc', initializer_range: float = 0.02, do_pooling: bool = False, model_args: dict | None = None, hidden_size: int = 2048, vocab_size: int = 128, vocab_offset: int = 262144, rms_norm_eps: float = 1e-06) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/configuration_gemma3n.py#L337) **Parâmetros:** architecture (`str`, *opcional*, padrão `"resnet50"`) : A arquitetura do timm a ser carregada. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. do_pooling (`bool`, *opcional*, padrão `True`) : Indica se deve ou não realizar pooling para o last_hidden_state em `TimmWrapperModel`. model_args (`dict[str, Any]`, *opcional*) : Argumentos de palavra-chave adicionais para passar à função `timm.create_model`. Por exemplo, `model_args={"depth": 3}` para `timm/vit_base_patch32_clip_448.laion2b_ft_in12k_in1k` para criar um modelo com 3 blocos. O valor padrão é `None`. hidden_size (`int`, *opcional*, padrão `2048`) : Dimensão das representações ocultas. vocab_size (`int`, *opcional*, padrão `128`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`. vocab_offset (`int`, *opcional*, padrão 262144) : Deslocamento entre o índice de vocabulário do tokenizer para os ids de tokens incorporados por `Gemma3nMultimodalEmbedder` e a tabela `Gemma3nMultimodalEmbedder.embedding` com índice inicial em 0. rms_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização rms. Esta é a classe de configuração para armazenar a configuração de um Gemma3nModel. Ela é usada para instanciar um modelo Gemma3N 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-3n-E4B](https://huggingface.co/google/gemma-3n-E4B) 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 Gemma3nVisionConfig, TimmWrapper >>> # Initializing a TimmWrapper gemma3n_vision-E4B-style configuration >>> configuration = Gemma3nVisionConfig() >>> # Initializing a gemma3n_vision-E4B-style TimmWrapper from the configuration >>> model = TimmWrapper(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Gemma3nAudioConfig[[transformers.Gemma3nAudioConfig]] #### transformers.Gemma3nAudioConfig[[transformers.Gemma3nAudioConfig]] ```python transformers.Gemma3nAudioConfig(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 = 128, vocab_offset: int = 262272, input_feat_size: int = 128, hidden_size: int = 1536, rms_norm_eps: float = 1e-06, gradient_clipping: float = 10000000000.0, conf_attention_chunk_size: int = 12, conf_attention_context_left: int = 13, conf_attention_context_right: int = 0, conf_attention_logit_cap: float = 50.0, conf_num_attention_heads: int = 8, conf_num_hidden_layers: int = 12, conf_conv_kernel_size: int = 5, conf_reduction_factor: int = 4, conf_residual_weight: float = 0.5, sscp_conv_channel_size: list[int] | tuple[int, int] = (128, 32), sscp_conv_group_norm_eps: float = 0.001, sscp_conv_kernel_size: list | tuple[tuple[int, int], tuple[int, int]] = ((3, 3), (3, 3)), sscp_conv_stride_size: list | tuple[tuple[int, int], tuple[int, int]] = ((2, 2), (2, 2))) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/configuration_gemma3n.py#L237) **Parâmetros:** vocab_size (`int`, *opcional*, padrão `128`) : Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos `input_ids`. vocab_offset (`int`, *opcional*, padrão 262272) : Deslocamento entre o índice de vocabulário do tokenizer para os ids de tokens incorporados por `Gemma3nMultimodalEmbedder` e a tabela `Gemma3nMultimodalEmbedder.embedding` com índice inicial em 0. input_feat_size (`int`, *opcional*, padrão 128) : O número de canais em cada quadro do mel-espectrograma. hidden_size (`int`, *opcional*, padrão `1536`) : Dimensão das representações ocultas. rms_norm_eps (`float`, *opcional*, padrão `1e-06`) : O epsilon usado pelas camadas de normalização rms. gradient_clipping (`float`, *opcional*, padrão 10000000000.0) : Valor de recorte usado para estabilizar valores de gradiente extremamente grandes. conf_attention_chunk_size (`int`, *opcional*, padrão 12) : O tamanho da subsequência para o processamento de atenção local dentro da seção Conformer ("conf") do Universal Speech Model. conf_attention_context_left (`int`, *opcional*, padrão 13) : O tamanho do contexto à esquerda da atenção local dentro da seção Conformer ("conf") do Universal Speech Model. conf_attention_context_right (`int`, *opcional*, padrão 0) : O tamanho do contexto à direita da atenção local dentro da seção Conformer ("conf") do Universal Speech Model. conf_attention_logit_cap (`float`, *opcional*, padrão 50.0) : Limite de logits aplicado durante a atenção local na seção Conformer ("conf") do Universal Speech Model. conf_num_attention_heads (`int`, *opcional*, padrão 8) : O número de cabeças de atenção na atenção local dentro da seção Conformer ("conf") do Universal Speech Model. conf_num_hidden_layers (`int`, *opcional*, padrão 12) : O número de camadas que usam atenção local dentro da seção Conformer ("conf") do Universal Speech Model. conf_conv_kernel_size (`int`, *opcional*, padrão 5) : Tamanho do kernel de convolução para o bloco conformer dentro da seção Conformer ("conf") do Universal Speech Model. conf_reduction_factor (`int`, *opcional*, padrão 4) : Fator de redução usado no bloco conformer dentro da seção Conformer ("conf") do Universal Speech Model. conf_residual_weight (`float`, *opcional*, padrão 0.5) : Peso da conexão residual na seção Conformer ("conf") do Universal Speech Model. sscp_conv_channel_size (`tuple(int, int)`, *opcional*, padrão `(128, 32)`) : Os tamanhos dos canais para as primeiras e segundas camadas convolucionais na seção de Projeção de Convolução Sub-amostrada ("sscp") do Universal Speech Model. sscp_conv_group_norm_eps (`float`, *opcional*, padrão 0.001) : Epsilon usado na normalização de grupo na projeção de convolução de subsample na seção "sscp" (Sub-sample Convolution Projection) do Universal Speech Model. sscp_conv_kernel_size (`tuple(tuple(int, int), tuple(int, int))`, *opcional*, padrão `((3, 3), (3, 3))`) : Tamanhos dos kernels das duas camadas convolucionais na projeção de convolução de subsample na seção "sscp" (Sub-sample Convolution Projection) do Universal Speech Model. Os tamanhos dos kernels são especificados como uma tupla de altura e largura para cada camada, onde a altura corresponde à dimensão do tempo e a largura corresponde à dimensão da frequência. sscp_conv_stride_size (`tuple(tuple(int, int), tuple(int, int))`, *opcional*, padrão `((2, 2), (2, 2))`) : Tamanhos de stride das duas camadas convolucionais na projeção de convolução de subsample na seção "sscp" (Sub-sample Convolution Projection) do Universal Speech Model. Os tamanhos de stride são especificados como uma tupla de altura e largura para cada camada, em que a altura corresponde à dimensão temporal e a largura corresponde à dimensão de frequência. Esta é a classe de configuração para armazenar a configuração de um Gemma3nModel. Ela é usada para instanciar um modelo Gemma3N 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-3n-E4B](https://huggingface.co/google/gemma-3n-E4B) 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 Gemma3nAudioConfig, Gemma3nAudioEncoder >>> # Initializing a Gemma3nAudioEncoder gemma3n_audio-E4B-style configuration >>> configuration = Gemma3nAudioConfig() >>> # Initializing a model from the gemma3n_audio-E4B style configuration >>> model = Gemma3nAudioEncoder(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Gemma3nConfig[[transformers.Gemma3nConfig]] #### transformers.Gemma3nConfig[[transformers.Gemma3nConfig]] ```python transformers.Gemma3nConfig(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.gemma3n.configuration_gemma3n.Gemma3nTextConfig | dict[str, typing.Any] | None = None, vision_config: transformers.models.gemma3n.configuration_gemma3n.Gemma3nVisionConfig | dict[str, typing.Any] | None = None, audio_config: transformers.models.gemma3n.configuration_gemma3n.Gemma3nAudioConfig | dict[str, typing.Any] | None = None, audio_soft_tokens_per_image: int | None = 188, vision_soft_tokens_per_image: int | None = 256, boi_token_id: int | None = 255999, eoi_token_id: int | None = 262144, image_token_id: int | None = 262145, boa_token_id: int | None = 256000, eoa_token_id: int | None = 262272, audio_token_id: int | None = 262273, initializer_range: float | None = 0.02, tie_word_embeddings: bool | None = True, use_cache: bool = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/configuration_gemma3n.py#L430) **Parâmetros:** text_config (`Union[~models.gemma3n.configuration_gemma3n.Gemma3nTextConfig, dict[str, Any]]`, *opcional*) : O objeto de configuração ou dicionário do backbone de texto. vision_config (`Union[~models.gemma3n.configuration_gemma3n.Gemma3nVisionConfig, dict[str, Any]]`, *opcional*) : O objeto de configuração ou dicionário do backbone de visão. audio_config (`Union[~models.gemma3n.configuration_gemma3n.Gemma3nAudioConfig, dict[str, Any]]`, *opcional*) : O objeto de configuração ou dicionário do backbone de áudio. audio_soft_tokens_per_image (`int`, *opcional*, padrão 188) : O número de tokens suaves por clipe de áudio. vision_soft_tokens_per_image (`int`, *opcional*, padrão 256) : O número de tokens suaves por imagem. 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 262144) : O índice do token de fim de imagem para envolver o prompt da imagem. image_token_id (`int`, *opcional*, padrão `262145`) : O índice do token de imagem usado como marcador para as imagens 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_id (`int`, *opcional*, padrão 262272) : O índice do token de fim de áudio para envolver o prompt de áudio. audio_token_id (`int`, *opcional*, padrão `262273`) : 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. 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. Esta é a classe de configuração para armazenar a configuração de um Gemma3nModel. Ela é usada para instanciar um modelo Gemma3N 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-3n-E4B](https://huggingface.co/google/gemma-3n-E4B) 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 Gemma3nForConditionalGeneration, Gemma3nConfig, Gemma3nTextConfig >>> # Initializing a MobileNet vision config, which is loaded from TIMM >>> vision_config = Gemma3nVisionConfig() >>> # Initializing a Gemma3n Audio config >>> audio_config = Gemma3nAudioConfig() >>> # Initializing a Gemma3n Text config >>> text_config = Gemma3nTextConfig() >>> # Initializing a Gemma3n gemma-3-4b style configuration >>> configuration = Gemma3nConfig(text_config, vision_config, audio_config) >>> # Initializing a model from the gemma-3-4b style configuration >>> model = Gemma3nTextConfig(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## Gemma3nTextModel[[transformers.Gemma3nTextModel]] #### transformers.Gemma3nTextModel[[transformers.Gemma3nTextModel]] ```python transformers.Gemma3nTextModel(config: Gemma3nTextConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/modeling_gemma3n.py#L1577) **Parâmetros:** config ([Gemma3nTextConfig](/docs/transformers/main/pt/model_doc/gemma3n#transformers.Gemma3nTextConfig)) : 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 3n 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.Gemma3nTextModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, per_layer_inputs: typing.Optional[torch.Tensor] = 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/gemma3n/modeling_gemma3n.py#L1638) **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) per_layer_inputs (`torch.Tensor`, *opcional*, padrão None) : Embebimentos pré-computados por camada. Se for None, eles são derivados de input_ids, se fornecidos. 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:** [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPast) 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 ([Gemma3nConfig](/docs/transformers/main/pt/model_doc/gemma3n#transformers.Gemma3nConfig)) e das entradas. O método forward do [Gemma3nTextModel](/docs/transformers/main/pt/model_doc/gemma3n#transformers.Gemma3nTextModel) 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 e, opcionalmente, se `config.is_encoder_decoder=True`, nos blocos de atenção cruzada) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **hidden_states** (`tuple(torch.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. ## Gemma3nModel[[transformers.Gemma3nModel]] #### transformers.Gemma3nModel[[transformers.Gemma3nModel]] ```python transformers.Gemma3nModel(config: Gemma3nConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/modeling_gemma3n.py#L1923) **Parâmetros:** config ([Gemma3nConfig](/docs/transformers/main/pt/model_doc/gemma3n#transformers.Gemma3nConfig)) : 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 3n, 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.Gemma3nModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: 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, token_type_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, per_layer_inputs: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/modeling_gemma3n.py#L2004) input_features_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*): Máscara de atenção para `input_features`, em que valores não nulos marcam quadros de áudio válidos. per_layer_inputs (`torch.Tensor`, *opcional*): Embeddings de entrada de texto pré-computados por camada, de forma `(batch_size, sequence_length, num_hidden_layers, hidden_size_per_layer_input)`. Quando fornecidos, são usados diretamente em vez de serem calculados a partir de `input_ids` via `get_per_layer_inputs()` no modelo de texto. Se a chamada ao `forward` for feita com `inputs_embeds` em vez de `input_ids`, você deve pré-computá-los e encaminhá-los junto com `inputs_embeds`; caso contrário, o componente de identidade de token dos embeddings por camada será omitido. Exemplo: ```python >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from transformers import AutoProcessor, Gemma3nForConditionalGeneration >>> model = Gemma3nForConditionalGeneration.from_pretrained("google/gemma3n2-3b-mix-224") >>> processor = AutoProcessor.from_pretrained("google/gemma3n2-3b-mix-224") >>> prompt = "Where is the cat standing?" >>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> inputs = processor(images=image, text=prompt, return_tensors="pt") >>> # Generate >>> generate_ids = model.generate(**inputs,) >>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0] "Where is the cat standing?\nsnow" ``` #### get_image_features[[transformers.Gemma3nModel.get_image_features]] ```python get_image_features(pixel_values: Tensor, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/modeling_gemma3n.py#L1938) **Parâmetros:** pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [SiglipImageProcessor](/docs/transformers/main/pt/model_doc/siglip#transformers.SiglipImageProcessor). Veja [SiglipImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([Gemma3nProcessor](/docs/transformers/main/pt/model_doc/gemma3n#transformers.Gemma3nProcessor) usa [SiglipImageProcessor](/docs/transformers/main/pt/model_doc/siglip#transformers.SiglipImageProcessor) para processar imagens). **Retorna:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([Gemma3nConfig](/docs/transformers/main/pt/model_doc/gemma3n#transformers.Gemma3nConfig)) e das entradas. Projeta o último estado oculto do modelo de visão para o espaço do modelo de linguagem. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. #### get_audio_features[[transformers.Gemma3nModel.get_audio_features]] ```python get_audio_features(input_features: Tensor, input_features_mask: Tensor, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/modeling_gemma3n.py#L2155) **Parâmetros:** input_features (`torch.Tensor` de forma `(num_images, seq_length, num_features)`) : Os tensores correspondentes ao áudio de entrada. input_features_mask (`torch.Tensor` de forma `(num_images, seq_length)`) : A máscara de atenção para o áudio de entrada. **Retorna:** `Gemma3nAudioEncoderModelOutput` ou `tuple(torch.Tensor)` Um `Gemma3nAudioEncoderModelOutput` 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 ([Gemma3nConfig](/docs/transformers/main/pt/model_doc/gemma3n#transformers.Gemma3nConfig)) e das entradas. Projeta o último estado oculto do codificador de áudio para o espaço do modelo de linguagem. - **last_hidden_state** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de estados ocultos na saída da última camada do modelo. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. - **audio_mel_mask** (`torch.BoolTensor`, *opcional*) -- Um torch.BoolTensor de forma `(batch_size, num_frames)` ## Gemma3nForCausalLM[[transformers.Gemma3nForCausalLM]] #### transformers.Gemma3nForCausalLM[[transformers.Gemma3nForCausalLM]] ```python transformers.Gemma3nForCausalLM(config: Gemma3nTextConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/modeling_gemma3n.py#L1788) **Parâmetros:** config ([Gemma3nTextConfig](/docs/transformers/main/pt/model_doc/gemma3n#transformers.Gemma3nTextConfig)) : 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 3n 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.Gemma3nForCausalLM.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/gemma3n/modeling_gemma3n.py#L1804) **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:** [CausalLMOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou `tuple(torch.Tensor)` Um [CausalLMOutputWithPast](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.CausalLMOutputWithPast) ou uma tupla de `torch.Tensor` (se `return_dict=False` for passado ou quando `config.return_dict=False`) contendo vários elementos dependendo da configuração ([Gemma3nConfig](/docs/transformers/main/pt/model_doc/gemma3n#transformers.Gemma3nConfig)) e das entradas. O método forward de [Gemma3nForCausalLM](/docs/transformers/main/pt/model_doc/gemma3n#transformers.Gemma3nForCausalLM) substitui o método especial `__call__`. Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de `Module` em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente. - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de modelagem de linguagem (para previsão do próximo token). - **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax). - **past_key_values** (`Cache`, *opcional*, retornado quando `use_cache=True` é passado ou quando `config.use_cache=True`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada `past_key_values`) para acelerar a decodificação sequencial. - **hidden_states** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_hidden_states=True` é passado ou quando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma `(batch_size, sequence_length, hidden_size)`. Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial. - **attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção. Exemplo: ```python >>> from transformers import AutoTokenizer, Gemma3nForCausalLM >>> model = Gemma3nForCausalLM.from_pretrained("google/gemma-2-9b") >>> tokenizer = AutoTokenizer.from_pretrained("google/gemma-2-9b") >>> 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?" ``` ## Gemma3nForConditionalGeneration[[transformers.Gemma3nForConditionalGeneration]] #### transformers.Gemma3nForConditionalGeneration[[transformers.Gemma3nForConditionalGeneration]] ```python transformers.Gemma3nForConditionalGeneration(config: Gemma3nConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/modeling_gemma3n.py#L2184) **Parâmetros:** config ([Gemma3nConfig](/docs/transformers/main/pt/model_doc/gemma3n#transformers.Gemma3nConfig)) : 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 3n, 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.Gemma3nForConditionalGeneration.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: 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, 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, per_layer_inputs: typing.Optional[torch.Tensor] = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/modeling_gemma3n.py#L2199) **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 [SiglipImageProcessor](/docs/transformers/main/pt/model_doc/siglip#transformers.SiglipImageProcessor). Veja [SiglipImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([Gemma3nProcessor](/docs/transformers/main/pt/model_doc/gemma3n#transformers.Gemma3nProcessor) usa [SiglipImageProcessor](/docs/transformers/main/pt/model_doc/siglip#transformers.SiglipImageProcessor) para processar imagens). 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 [Gemma3nAudioFeatureExtractor](/docs/transformers/main/pt/model_doc/gemma3n#transformers.Gemma3nAudioFeatureExtractor). Veja `Gemma3nAudioFeatureExtractor.__call__()` para detalhes ([Gemma3nProcessor](/docs/transformers/main/pt/model_doc/gemma3n#transformers.Gemma3nProcessor) usa [Gemma3nAudioFeatureExtractor](/docs/transformers/main/pt/model_doc/gemma3n#transformers.Gemma3nAudioFeatureExtractor) 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`, *opcional*, padrão None) : 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)`. token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas porções das entradas. Os índices são selecionados em `[0, 1]`: - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*. [O que são IDs de tipo de token?](../glossary#token-type-ids) 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.text_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.text_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). per_layer_inputs (`torch.Tensor`, *opcional*) : Embeddings de texto de entrada pré-computados por camada, com formato `(batch_size, sequence_length, num_hidden_layers, hidden_size_per_layer_input)`. Quando fornecidos, são usados diretamente em vez de serem calculados a partir de `input_ids` via `get_per_layer_inputs()` no modelo de texto. Se estiver chamando o `forward` com `inputs_embeds` em vez de `input_ids`, você deve pré-computá-los e encaminhá-los junto com `inputs_embeds`; caso contrário, a componente de identidade de token dos embeddings por camada será omitida. 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:** `Gemma3nCausalLMOutputWithPast` ou `tuple(torch.Tensor)` Um `Gemma3nCausalLMOutputWithPast` 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 ([Gemma3nConfig](/docs/transformers/main/pt/model_doc/gemma3n#transformers.Gemma3nConfig)) e das entradas. O método forward de [Gemma3nForConditionalGeneration](/docs/transformers/main/pt/model_doc/gemma3n#transformers.Gemma3nForConditionalGeneration) 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. Exemplo: ```python >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> from transformers import AutoProcessor, Gemma3ForConditionalGeneration >>> model = Gemma3ForConditionalGeneration.from_pretrained("google/gemma-3-4b-it") >>> processor = AutoProcessor.from_pretrained("google/gemma-3-4b-it") >>> messages = [ ... { ... "role": "system", ... "content": [ ... {"type": "text", "text": "You are a helpful assistant."} ... ] ... }, ... { ... "role": "user", "content": [ ... {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"}, ... {"type": "text", "text": "Where is the cat standing?"}, ... ] ... }, ... ] >>> inputs = processor.apply_chat_template( ... messages, ... tokenizer=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, clean_up_tokenization_spaces=False)[0] "user\nYou are a helpful assistant.\n\n\n\n\n\nWhere is the cat standing?\nmodel\nBased on the image, the cat is standing in a snowy area, likely outdoors. It appears to" ``` #### get_image_features[[transformers.Gemma3nForConditionalGeneration.get_image_features]] ```python get_image_features(pixel_values: Tensor, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/gemma3n/modeling_gemma3n.py#L2195) **Parâmetros:** pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [SiglipImageProcessor](/docs/transformers/main/pt/model_doc/siglip#transformers.SiglipImageProcessor). Veja [SiglipImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([Gemma3nProcessor](/docs/transformers/main/pt/model_doc/gemma3n#transformers.Gemma3nProcessor) usa [SiglipImageProcessor](/docs/transformers/main/pt/model_doc/siglip#transformers.SiglipImageProcessor) para processar imagens). Exemplo: ```python >>> from PIL import Image >>> from transformers import AutoProcessor, Gemma3nForConditionalGeneration >>> model = Gemma3nForConditionalGeneration.from_pretrained("google/gemma-3n-E4B") >>> processor = AutoProcessor.from_pretrained("google/gemma-3n-E4B") >>> 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] ``` [altup]: https://proceedings.neurips.cc/paper_files/paper/2023/hash/f2059277ac6ce66e7e5543001afa8bb5-Abstract-Conference.html [attention-mask-viz]: https://github.com/huggingface/transformers/blob/beb9b5b02246b9b7ee81ddf938f93f44cfeaad19/src/transformers/utils/attention_visualizer.py#L139 [gemma3n-collection]: https://huggingface.co/collections/google/gemma-3n [laurel]: https://huggingface.co/papers/2411.07501 [matformer]: https://huggingface.co/papers/2310.07707 [spark-transformer]: https://huggingface.co/papers/2506.06644 [usm]: https://huggingface.co/papers/2303.01037