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 dans et spécifiques à notre tokenizer.

• Jeton pour indiquer une instruction système : system
• Jeton pour indiquer un tour d'utilisateur : user
• Jeton pour indiquer un tour de modèle : model
• Jeton pour indiquer le début d'un tour de dialogue : <|turn>
• Jeton pour indiquer 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 spécifier où les jetons d'image et audio doivent être insérés. Après la tokenisation, ces jetons sont remplacés par les embeddings souples réels dans le 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"""

Audio

Utilisez les structures de requête suivantes pour le traitement audio :

• Reconnaissance vocale audio (ASR)

Transcribe the following speech segment in {LANGUAGE} into {LANGUAGE} text.

Follow these specific instructions for formatting the answer:
*   Only output the transcription, with no newlines.
*   When transcribing numbers, write the digits, i.e. write 1.7 and not one point seven, and write 3 instead of three.

• Traduction vocale automatique (AST)

Transcribe the following speech segment in {SOURCE_LANGUAGE}, then translate it into {TARGET_LANGUAGE}.
When formatting the answer, first output the transcription in {SOURCE_LANGUAGE}, then one newline, then output the string '{TARGET_LANGUAGE}: ', then the translation in {TARGET_LANGUAGE}.

Jetons de contrôle agentifs et de raisonnement

Pour prendre en charge les workflows agentifs, 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 garantit que tous les caractères spéciaux (tels que {, }, , ou des 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 fonction doivent être placés entre ce jeton (par exemple, key:<|"|>string value<|"|>).

Mode de réflexion

Pour activer le mode de réflexion, incluez le <|think|> jeton de contrôle 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 de réflexion est conçu pour être activé au niveau de la conversation. Il doit être consolidé en un seul tour de système avec vos autres instructions système, telles que les définitions d'outils.

Exemple de raisonnement et d'appel de fonction

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

1. Requête de l'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 arrête 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 montre 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 les 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

La gestion appropriée des réflexions générées par le modèle est essentielle pour maintenir les performances sur plusieurs tours de conversation.

• Conversations multitours standards : vous devez supprimer (supprimer) les réflexions 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 de réflexion au milieu d'une conversation, vous pouvez supprimer le jeton <|think|> lorsque vous supprimez les réflexions précédentes.
• Appel de fonction (exception) : si un seul tour de modèle 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 réflexions 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 empêcher le modèle d'entrer dans des boucles de raisonnement cycliques.

• Synthèse des réflexions : une technique d'inférence fortement recommandée consiste à extraire, à synthétiser et à réinjecter les réflexions précédentes du modèle dans la fenêtre de contexte sous forme de texte standard.
• Contraintes de formatage : étant donné que Gemma 4 n'a pas été explicitement entraîné avec des réflexions brutes incluses dans la requête (en dehors du scénario d'appel d'outil spécifique mentionné ci-dessus), aucun format strict ou spécifique n'est attendu par le modèle pour ces réflexions injectées. Vous pouvez mettre en forme le raisonnement résumé de la manière la plus adaptée à votre architecture agentive 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). 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 une "poignée de main" entre le modèle et votre environnement d'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 volumineux (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 de 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 les grands modèles avec des ensembles de données sans réflexion

Lorsque vous affinez 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 réflexion 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 dispose de capacités de suivi des instructions exceptionnellement fortes 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 (SI) 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 à une profondeur inférieure (un concept que nous appelons une instruction de réflexion "FAIBLE"), vous pouvez obtenir une efficacité de réflexion adaptative.

• Coût réduit : les tests ont montré que l'application d'une instruction système de réflexion "FAIBLE" peut réduire le nombre de jetons de réflexion générés d'environ 20 %.
• Démonstration de faisabilité : comme ce comportement est 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" unique. L'instruction "FAIBLE" 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é de sortie pour vos cas d'utilisation spécifiques.