Ce modèle a été contribué à Hugging Face Transformers le 2026-06-03.

Assistant unifié Gemma 4

Aperçu

Gemma 4 Unified Assistant est un petit modèle text-only qui permet le décodage spéculatif pour les modèles Gemma 4 Unified à l'aide de la méthode Multi-Token Prediction (MTP) et du générateur de candidats associé. Des modèles pré-entraînés sont fournis pour les variantes IT du modèle Gemma 4 12B.

Pour plus d’informations, veuillez consulter Gemma4 Assistant. Sur le plan architectural et conceptuel, ils partagent le même concept et les mêmes différences par rapport à leur modèle de base :

• Le modèle entier utilise le partage de KV. Cette technique, introduite à l’origine avec Gemma 3n, permet au modèle de réutiliser le cache KV rempli par le modèle cible pris en charge par l’assistant, ce qui permet à l’assistant de sauter entièrement la phase de pré-remplissage et de réduire considérablement le calcul d’attention lors du passage avant.
• Les valeurs de position_ids sont constantes. Comme le cache KV est partagé et que l'assistant ne dispose d'aucun moyen de mettre à jour le cache, il prédit tous les jetons à partir du même identifiant de position.
• Les entrées sont la concaténation des embeddings et des états cachés. Pour s'adapter à la cache KV statique et à position_ids, le modèle reçoit ses entrées sous forme de la concaténation de l'embedding et des hidden_states du dernier jeton vu par le modèle cible, puis les projette dans l'espace du modèle assistant via une transformation nn.Linear. La définition du dernier jeton vu évolue au fil de la boucle de décodage assisté. Pour le premier jeton rédigé après la pré-remplissage, le dernier jeton vu sera le dernier jeton du prompt. Pour les étapes de rédaction suivantes, le dernier jeton vu sera le dernier jeton généré par l'assistant (au sein d'un cycle de rédaction) ou le dernier jeton accepté par le modèle cible (entre les cycles de rédaction).
• L’attention croisée est utilisée pour tirer le meilleur parti du contexte du modèle cible. L’attention croisée permet aux états de requête générés par l’assistant de prendre en compte les valeurs du cache KV partagé du modèle cible, ce qui permet à l’assistant de prédire avec précision davantage de jetons rédigés par tour de rédaction.

Exemples d'utilisation

L'exemple ci-dessous montre comment générer du texte à partir d'une image avec Pipeline ou la classe 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?"