Este modelo fue aportado a Hugging Face Transformers el 2026-06-03.

Gemma 4 Asistente Unificado

Resumen

Gemma 4 Unified Assistant es un modelo pequeño, solo de texto, que permite la decodificación especulativa para los modelos Gemma 4 Unified mediante el método de Predicción de Múltiples Tokens (MTP) y el generador de candidatos asociado. Se proporcionan modelos preentrenados para las variantes IT del modelo Gemma 4 12B.

Para obtener más información, consulte Gemma4 Assistant. En términos arquitectónicos y conceptuales, comparten el mismo concepto y las mismas diferencias con su modelo base:

• El modelo completo utiliza el intercambio de KV. Esta técnica, introducida originalmente con Gemma 3n, permite que el modelo reutilice la caché de KV poblada por el modelo objetivo que el asistente soporta, lo que permite al asistente omitir por completo la fase de pre-fille y reducir considerablemente el cálculo de atención durante la pasada hacia adelante.
• El valor de position_ids es constante. Dado que la caché KV se comparte y el asistente no tiene forma de actualizarla, el asistente predice todos los tokens desde el mismo ID de posición.
• Las entradas son la concatenación de embeddings y estados ocultos. Para adaptarse a la caché KV estática y a position_ids, el modelo toma sus entradas como la concatenación de embedding y hidden_states del último token visto por el modelo objetivo y los proyecta al espacio del modelo asistente mediante una transformación nn.Linear. La definición de último token visto cambia a lo largo del bucle de decodificación asistida. Para el primer token redactado después del pre-llenado, el último token visto será el último token del prompt. Para los pasos de redacción posteriores, el último token visto será el último token generado por el asistente (dentro de una ronda de redacción) o el último token aceptado por el modelo objetivo (entre rondas de redacción).
• La atención cruzada se utiliza para aprovechar al máximo el contexto del modelo objetivo. La atención cruzada permite que los estados de consulta generados por el asistente presten atención a los valores compartidos de la caché KV del modelo objetivo, lo que permite al asistente predecir con precisión más tokens redactados por ronda de redacción.

Ejemplos de uso

El siguiente ejemplo demuestra cómo generar texto a partir de una imagen con Pipeline o la clase AutoModel.

import torch
from transformers import pipeline

pipeline = pipeline(
    task="image-text-to-text",
    model="google/gemma-4-12B-it",
    assistant_model="google/gemma-4-12B-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-12B-it",
    dtype=torch.bfloat16,
    device_map="auto",
)
assistant_model = AutoModelForCausalLM.from_pretrained(
    "google/gemma-4-12B-it-assistant",
    dtype=torch.bfloat16,
    device_map="auto",
)

processor = AutoProcessor.from_pretrained(
    "google/gemma-4-12B-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))

Gemma4UnifiedAssistantConfig

>>> from transformers import (
...     Gemma4UnifiedAssistantConfig,
...     Gemma4UnifiedAssistantForCausalLM,
...     Gemma4UnifiedTextConfig,
... )

>>> # Initializing a Gemma 4 Unified Text config for the assistant.
>>> text_config = Gemma4UnifiedTextConfig(...)

>>> # Initializing a Gemma 4 Unified Assistant config.
>>> configuration = Gemma4UnifiedAssistantConfig(text_config=text_config)

>>> # Initializing a model from the configuration.
>>> model = Gemma4UnifiedAssistantForCausalLM(configuration)

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

Gemma4UnifiedAssistantForCausalLM

>>> from transformers import AutoTokenizer, Gemma4UnifiedAssistantForCausalLM, Gemma4UnifiedForConditionalGeneration

>>> model = Gemma4UnifiedForConditionalGeneration.from_pretrained("google/gemma-4-e2b-it")
>>> assistant_model = Gemma4UnifiedAssistantForCausalLM.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?"