Mise en forme des requêtes Gemma 4

À partir de Gemma 4, nous introduisons de nouveaux jetons de contrôle. Pour Gemma 3 et les versions antérieures, consultez le document précédent.

Les sections suivantes spécifient les jetons de contrôle utilisés par Gemma 4 et leurs cas d'utilisation. Notez que les jetons de contrôle sont réservés et spécifiques à notre tokenizer.

• Jeton indiquant une instruction système : system
• Jeton indiquant un tour d'utilisateur : user
• Jeton indiquant un tour de modèle : model
• Jeton indiquant le début d'un tour de dialogue : <|turn>
• Jeton indiquant la fin d'un tour de dialogue : <turn|>

Voici un exemple de dialogue :

<|turn>system
You are a helpful assistant.<turn|>
<|turn>user
Hello.<turn|>

Multimodalités

Nous utilisons deux jetons d'espace réservé spéciaux (<|image|> et <|audio|>) pour indiquer où insérer les jetons d'image et audio. Après la tokenisation, ces jetons sont remplacés par les embeddings souples réels à l'intérieur du modèle.

Voici un exemple de dialogue :

prompt = """<|turn>user
Describe this image: <|image|>

And translate these audio:

a. <|audio|>
b. <|audio|><turn|>
<|turn>model"""

Jetons de contrôle agentique et de raisonnement

Pour prendre en charge les workflows agentiques, Gemma utilise des jetons de contrôle spécialisés qui délimitent le raisonnement interne (réflexion) des actions externes (appel de fonction). Ces jetons permettent au modèle de traiter une logique complexe avant de fournir une réponse finale ou d'interagir avec des outils externes.

Appel de fonction

Gemma 4 est entraîné sur six jetons spéciaux pour gérer le cycle de vie de l'utilisation des outils.

Délimiteur pour les valeurs de chaîne : <|"|>

Un seul jeton, <|"|>, est utilisé comme délimiteur pour toutes les valeurs de chaîne dans les blocs de données structurées.

• Objectif : ce jeton permet de s'assurer que tous les caractères spéciaux (tels que {, }, , ou les guillemets) à l'intérieur d'une chaîne sont traités comme du texte littéral et non comme faisant partie de la syntaxe sous-jacente de la structure de données.
• Utilisation : Tous les littéraux de chaîne dans vos déclarations, appels et réponses de fonctions doivent être placés entre ce jeton (par exemple, key:<|"|>string value<|"|>).

Mode Réflexion

Pour activer le mode réflexion, incluez le jeton de contrôle <|think|> dans l'instruction système.

Voici un exemple de dialogue :

<|turn>system
<|think|><turn|>
<|turn>user
What is the water formula?<turn|>
<|turn>model
<|channel>thought
...
<channel|>The most common interpretation of "the water formula" refers...<turn|>

Le mode Réflexion est conçu pour être activé au niveau de la conversation. Ces instructions doivent être regroupées en un seul tour système, en même temps que vos autres instructions système, telles que les définitions d'outils.

Exemple de raisonnement et d'appel de fonction

Lors d'un tour agentique, le modèle peut "réfléchir" en privé avant de décider d'appeler une fonction. Le cycle de vie suit la séquence suivante :

1. Requête utilisateur : l'utilisateur pose une question.
2. Raisonnement interne : le modèle réfléchit en privé dans le canal de réflexion.
3. Demande d'outil : le modèle interrompt la génération pour demander un appel d'outil.
4. Exécution et injection : l'application exécute l'outil et ajoute la réponse.
5. Réponse finale : le modèle lit la réponse et génère la réponse finale.

L'exemple suivant illustre un modèle utilisant un outil météo :

<|turn>system
<|think|>You are a helpful assistant.<|tool>declaration:get_current_temperature{...}<tool|><turn|>
<|turn>user
What's the temperature in London?<turn|>
<|turn>model
<|channel>thought
...
<channel|><|tool_call>call:get_current_temperature{location:<|"|>London<|"|>}<tool_call|><|tool_response>

Votre application doit analyser la réponse du modèle pour extraire le nom et les arguments de la fonction, exécuter la fonction, puis ajouter tool_calls et tool_responses à l'historique de chat sous le rôle assistant.

<|turn>model
<|tool_call>call:get_current_weather{location:<|"|>London<|"|>}<tool_call|><|tool_response>response:get_current_weather{temperature:15,weather:<|"|>sunny<|"|>}<tool_response|>

Enfin, Gemma lit la réponse de l'outil et répond à l'utilisateur.

The temperature in London is 15 degrees and it is sunny.<turn|>

Voici l'historique de chat JSON complet pour cet exemple :

[
  {
    "role": "system",
    "content": "You are a helpful assistant."
  },
  {
    "role": "user",
    "content": "What's the temperature in London?"
  },
  {
    "role": "assistant",
    "tool_calls": [
      {
        "function": {
          "name": "get_current_weather",
          "arguments": {
            "location": "London"
          }
        }
      }
    ],
    "tool_responses": [
      {
        "name": "get_current_weather",
        "response": {
          "temperature": 15,
          "weather": "sunny"
        }
      }
    ],
    "content": "The temperature in London is 15 degrees and it is sunny."
  }
]

Gérer le contexte de réflexion entre les tours

Il est essentiel de gérer correctement les pensées générées par le modèle pour maintenir les performances dans les conversations multitours.

• Conversations multitours standards : vous devez supprimer (dépouiller) les pensées générées par le modèle lors du tour précédent avant de renvoyer l'historique de la conversation au modèle pour le tour suivant. Si vous souhaitez désactiver le mode réflexion en cours de conversation, vous pouvez supprimer le jeton <|think|> lorsque vous supprimez les pensées précédentes.
• Appel de fonction (exception) : si un tour de modèle unique implique des appels de fonction ou d'outil, les réflexions ne doivent PAS être supprimées entre les appels de fonction.

Workflows agentifs et tâches de longue durée

Étant donné que les pensées brutes sont supprimées entre les tours standards, les développeurs qui créent des agents de longue durée peuvent souhaiter conserver le contexte de raisonnement pour éviter que le modèle n'entre dans des boucles de raisonnement cycliques.

• Synthèse des réflexions : une technique d'inférence fortement recommandée consiste à extraire et à résumer les réflexions précédentes du modèle, puis à les réintégrer dans la fenêtre de contexte sous forme de texte standard.
• Contraintes de mise en forme : comme Gemma 4 n'a pas été explicitement entraîné avec des pensées brutes incluses dans la requête (en dehors du scénario d'appel d'outil spécifique mentionné ci-dessus), le modèle n'attend pas de format strict ou spécifique pour ces pensées injectées. Vous pouvez mettre en forme le raisonnement résumé de la manière qui convient le mieux à votre architecture agentique spécifique.

Remarques sur l'intégration

• État interne : les jetons <|channel> et <channel|> sont généralement utilisés pour le traitement de la chaîne de pensée (CoT, chain-of-thought). Dans les applications standards destinées aux utilisateurs, ce contenu est généralement masqué pour l'utilisateur final.
• Boucle d'outil : les jetons tool_call et tool_response facilitent la "prise de contact" entre le modèle et l'environnement de votre application. L'application intercepte le tool_call, exécute le code sous-jacent et renvoie le résultat au modèle dans les jetons tool_response.
• Comportement du modèle : les modèles plus grands (par exemple, gemma-4-26B-A4B-it, gemma-4-31B-it) peuvent parfois générer un canal de réflexion même lorsque le mode réflexion est explicitement désactivé. Pour stabiliser le comportement du modèle dans ces cas extrêmes, envisagez d'ajouter un jeton de réflexion vide à la requête.

Conseil : Affiner de grands modèles avec des ensembles de données sans réflexion

Lorsque vous réglez finement des modèles Gemma plus volumineux avec un ensemble de données qui n'inclut pas de réflexion, vous pouvez obtenir de meilleurs résultats en ajoutant le canal vide à vos requêtes d'entraînement :

<|turn>model
<|channel>thought
<channel|>

Conseil : Efficacité de la pensée adaptative à l'aide d'instructions système

Bien que la "réflexion" dans Gemma 4 soit officiellement compatible en tant que fonctionnalité booléenne ON ou OFF, le modèle possède des capacités de suivi des instructions exceptionnellement solides qui vous permettent de moduler son comportement de réflexion de manière dynamique.

Plutôt que de vous appuyer sur un paramètre de framework codé en dur pour une réflexion "élevée" ou "faible", vous pouvez utiliser des instructions système pour guider le modèle vers un mode de réflexion réduit. En demandant explicitement au modèle de réfléchir efficacement ou à un niveau de profondeur inférieur (un concept que nous appelons "LOW"), vous pouvez obtenir une efficacité de pensée adaptative.

• Coût réduit : les tests ont montré que l'application d'une instruction système de pensée "FAIBLE" peut réduire le nombre de jetons de pensée générés d'environ 20 %.
• Preuve du concept : ce comportement étant un sous-produit de la capacité d'instruction du modèle plutôt que d'un entraînement spécifique, il n'existe pas de requête "parfaite". L'instruction "LOW" est une démonstration de faisabilité.
• Personnalisation : nous encourageons vivement les développeurs à tester leurs propres instructions système personnalisées. Vous pouvez affiner la profondeur, la longueur et le style du processus de réflexion du modèle pour équilibrer parfaitement la latence, le coût et la qualité des résultats pour vos cas d'utilisation spécifiques.