Este modelo foi contribuído para o Hugging Face Transformers em 2026-05-05.

Gemma 4 Assistant

Visão geral

O Gemma 4 Assistant é um modelo pequeno, somente de texto, que habilita a decodificação especulativa para modelos Gemma 4 usando o método de Previsão de Múltiplos Tokens (MTP) e o gerador de candidatos associado. Modelos pré-treinados são fornecidos para as variantes IT dos modelos Gemma 4 E2B, E4B, 31B e 26B-A4B (MoE).

Arquiteturalmente, o Gemma 4 Assistant compartilha o mesmo backbone Gemma4TextModel que os outros modelos Gemma 4, mas difere em alguns pontos-chave:

• O modelo inteiro usa compartilhamento de KV. Essa técnica, introduzida originalmente com o Gemma 3n, permite que o modelo reutilize o cache de KV preenchido pelo modelo de destino que o assistente suporta, permitindo que o assistente pule completamente a fase de pre-fille e reduza consideravelmente o cálculo de atenção durante a passagem direta.
• Os valores de position_ids são constantes. Como o cache KV é compartilhado e o assistente não possui uma forma de atualizar o cache, ele prevê todos os tokens a partir do mesmo ID de posição.
• As entradas são a concatenação dos embeddings e dos hidden states. Para se adaptar ao KV cache estático e a position_ids, o modelo recebe suas entradas como a concatenação do embedding e dos hidden_states do último token visto pelo modelo de destino e os projeta para o espaço do modelo assistente com uma transformação nn.Linear. A definição de último token visto muda ao longo do loop de decodificação assistida. Para o primeiro token rascunhado após o pre-fill, o último token visto será o último token do prompt. Para as etapas de rascunho subsequentes, o último token visto será o último token gerado pelo assistente (dentro de uma rodada de rascunho) ou o último token aceito pelo modelo de destino (entre as rodadas de rascunho).
• A cross-attention é usada para aproveitar ao máximo o contexto do modelo de destino. A cross-attention permite que os estados de consulta gerados pelo assistente prestem atenção aos valores do cache KV compartilhados pelo modelo de destino, permitindo que o assistente preveja com precisão mais tokens rascunhados por rodada de rascunho.

Você pode encontrar todos os checkpoints originais do Gemma 4 Assistant na liberação Gemma 4.

Exemplos de uso

O exemplo abaixo demonstra como gerar texto com base em uma imagem usando Pipeline ou a classe AutoModel.

import torch
from transformers import pipeline

pipeline = pipeline(
    task="image-text-to-text",
    model="google/gemma-4-E2B-it",
    assistant_model="google/gemma-4-E2B-it-assistant",
)
pipeline(
    images="https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg",
    text="<|image|>\n\nWhat is shown in this image?"
)

import torch
from transformers import AutoProcessor, AutoModelForImageTextToText

model = AutoModelForImageTextToText.from_pretrained(
    "google/gemma-4-E2B-it",
    dtype=torch.bfloat16,
    device_map="auto",
)
assistant_model = AutoModelForCausalLM.from_pretrained(
    "google/gemma-4-E2B-it-assistant",
    dtype=torch.bfloat16,
    device_map="auto",
)

processor = AutoProcessor.from_pretrained(
    "google/gemma-4-E2B-it",
    padding_side="left"
)
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, assistant_model=assistant_model)
print(processor.decode(output[0][input_len:], skip_special_tokens=True))

Gemma4AssistantConfig

>>> from transformers import (
>>>     Gemma4AssistantConfig,
>>>     Gemma4AssistantForCausalLM,
>>>     Gemma4TextConfig,
>>> )

>>> # Initializing a Gemma 4 Text config similar to google/gemma-4-e2b-it-assistant.
>>> text_config = Gemma4TextConfig(...)

>>> # Initializing a Gemma 4 Assistant config similar to google/gemma-4-e2b-it-assistant.
>>> configuration = Gemma4AssistantConfig(text_config)

>>> # Initializing a model from the google/gemma-4-e2b-it-assistant configuration.
>>> model = Gemma4AssistantForCausalLM(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

Gemma4AssistantForCausalLM

>>> from transformers import AutoTokenizer, Gemma4AssistantForCausalLM, Gemma4ForCausalLM

>>> model = Gemma4ForCausalLM.from_pretrained("google/gemma-4-e2b-it")
>>> assistant_model = Gemma4AssistantForCausalLM.from_pretrained("google/gemma-4-e2b-it-assistant")
>>> tokenizer = AutoTokenizer.from_pretrained("google/gemma-4-e2b-it")

>>> prompt = "What is your favorite condiment?"
>>> inputs = tokenizer(prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, assistant_model=assistant_model, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True)[0]
"What is your favorite condiment?"