Comprendre et compter les jetons


Gemini et d'autres modèles d'IA générative traitent les entrées et les sorties avec un niveau de précision appelé jeton.

Ce guide explique comment obtenir les fenêtres de contexte de modèles spécifiques, ainsi que comment compter les jetons pour des cas d'utilisation tels que la saisie de texte, le chat, la saisie multimodale, ainsi que les instructions et outils système.

À propos des jetons

Les jetons peuvent être composés d'un seul caractère comme z ou de mots entiers comme cat. Les mots longs sont divisés en plusieurs jetons. L'ensemble de tous les jetons utilisés par le modèle est appelé "vocabulaire", et le processus de division du texte en jetons est appelé tokenisation.

Pour les modèles Gemini, un jeton équivaut à environ quatre caractères. 100 jetons correspondent à environ 60-80 mots en anglais.

Lorsque la facturation est activée, le coût d'un appel à l'API Gemini est déterminé en partie par le nombre de jetons d'entrée et de sortie. Il peut donc être utile de savoir comment compter les jetons.

Essayer de compter les jetons dans un Colab

Vous pouvez essayer de compter les jetons en utilisant un Colab.

Afficher sur ai.google.dev Essayer un notebook Colab Afficher le notebook sur GitHub

Fenêtres de contexte

Les modèles disponibles via l'API Gemini ont des fenêtres de contexte mesurées en jetons. La fenêtre de contexte définit la quantité d'entrées que vous pouvez fournir et la quantité de sortie que le modèle peut générer. Vous pouvez déterminer la taille de la fenêtre de contexte à l'aide de l'API ou en consultant la documentation des modèles.

Dans l'exemple suivant, vous pouvez constater que le modèle gemini-1.0-pro-001 a une limite d'entrée d'environ 30 000 jetons et une limite de sortie d'environ 2 000 jetons, ce qui signifie une fenêtre de contexte d'environ 32 000 jetons.

model_info = genai.get_model("models/gemini-1.5-flash")

# Returns the "context window" for the model,
# which is the combined input and output token limits.
print(f"{model_info.input_token_limit=}")
print(f"{model_info.output_token_limit=}")
# ( input_token_limit=30720, output_token_limit=2048 )
count_tokens.py

Par ailleurs, si vous demandez les limites de jetons pour un modèle tel que gemini-1.5-flash-001, vous verrez qu'il a une fenêtre de contexte de 2 millions.

Compter les jetons

Toutes les entrées et sorties de l'API Gemini sont tokenisées, y compris le texte, les fichiers image et les autres modalités non textuelles.

Vous pouvez compter les jetons de différentes manières:

  • Appelez count_tokens avec l'entrée de la requête.
    Cette méthode renvoie le nombre total de jetons dans l'entrée uniquement. Vous pouvez effectuer cet appel avant d'envoyer l'entrée au modèle pour vérifier la taille de vos requêtes.

  • Utilisez l'attribut usage_metadata sur l'objet response après avoir appelé generate_content.
    Cela renvoie le nombre total de jetons à la fois en entrée et en sortie : total_token_count.
    Il renvoie également le nombre de jetons de l'entrée et de la sortie séparément : prompt_token_count (jetons d'entrée) et candidates_token_count (jetons de sortie).

Compter les jetons de texte

Si vous appelez count_tokens avec une entrée textuelle uniquement, il renvoie le nombre de jetons du texte dans l'entrée uniquement (total_tokens). Vous pouvez effectuer cet appel avant d'appeler generate_content pour vérifier la taille de vos requêtes.

Une autre option consiste à appeler generate_content, puis à utiliser l'attribut usage_metadata sur l'objet response pour obtenir les éléments suivants:

  • Le nombre de jetons distincts de l'entrée (prompt_token_count) et de la sortie (candidates_token_count)
  • Nombre total de jetons en entrée et en sortie (total_token_count).
model = genai.GenerativeModel("models/gemini-1.5-flash")

prompt = "The quick brown fox jumps over the lazy dog."

# Call `count_tokens` to get the input token count (`total_tokens`).
print("total_tokens: ", model.count_tokens(prompt))
# ( total_tokens: 10 )

response = model.generate_content(prompt)

# On the response for `generate_content`, use `usage_metadata`
# to get separate input and output token counts
# (`prompt_token_count` and `candidates_token_count`, respectively),
# as well as the combined token count (`total_token_count`).
print(response.usage_metadata)
# ( prompt_token_count: 11, candidates_token_count: 73, total_token_count: 84 )
count_tokens.py

Compter les jetons multitours (chat)

Si vous appelez count_tokens avec l'historique des discussions, il renvoie le nombre total de jetons du texte de chaque rôle dans la discussion (total_tokens).

Vous pouvez également appeler send_message, puis utiliser l'attribut usage_metadata sur l'objet response pour obtenir ce qui suit :

  • Le nombre de jetons distincts de l'entrée (prompt_token_count) et de la sortie (candidates_token_count)
  • Nombre total de jetons dans l'entrée et la sortie (total_token_count)

Pour déterminer l'ampleur de votre prochain tour de conversation, vous devez l'ajouter à l'historique lorsque vous appelez count_tokens.

model = genai.GenerativeModel("models/gemini-1.5-flash")

chat = model.start_chat(
    history=[
        {"role": "user", "parts": "Hi my name is Bob"},
        {"role": "model", "parts": "Hi Bob!"},
    ]
)
# Call `count_tokens` to get the input token count (`total_tokens`).
print(model.count_tokens(chat.history))
# ( total_tokens: 10 )

response = chat.send_message(
    "In one sentence, explain how a computer works to a young child."
)

# On the response for `send_message`, use `usage_metadata`
# to get separate input and output token counts
# (`prompt_token_count` and `candidates_token_count`, respectively),
# as well as the combined token count (`total_token_count`).
print(response.usage_metadata)
# ( prompt_token_count: 25, candidates_token_count: 21, total_token_count: 46 )

from google.generativeai.types.content_types import to_contents

# You can call `count_tokens` on the combined history and content of the next turn.
print(model.count_tokens(chat.history + to_contents("What is the meaning of life?")))
# ( total_tokens: 56 )
count_tokens.py

Compter les jetons multimodales

Toutes les entrées dans l'API Gemini sont tokenisées, y compris les fichiers texte, les fichiers image et d'autres modalités non textuelles. Notez les points clés suivants concernant la tokenisation de l'entrée multimodale lors du traitement par l'API Gemini:

  • Les images sont considérées comme ayant une taille fixe. Elles consomment donc un nombre fixe de jetons (actuellement 258 jetons), quelle que soit leur taille d'affichage ou de fichier.

  • Les fichiers vidéo et audio sont convertis en jetons selon les taux fixes suivants : vidéo à 263 jetons par seconde et audio à 32 jetons par seconde.

Fichiers image

Lors du traitement, l'API Gemini considère que les images ont une taille fixe. Elles consomment donc un nombre fixe de jetons (actuellement 258 jetons), quelle que soit leur taille d'affichage ou de fichier.

Si vous appelez count_tokens avec une entrée texte et image, la fonction renvoie le nombre de jetons combinés du texte et de l'image dans l'entrée uniquement (total_tokens). Vous pouvez effectuer cet appel avant d'appeler generate_content pour vérifier la taille de vos requêtes. Vous pouvez également appeler count_tokens séparément sur le texte et sur le fichier.

Une autre option consiste à appeler generate_content, puis à utiliser l'attribut usage_metadata sur l'objet response pour obtenir les éléments suivants:

  • Le nombre de jetons distincts de l'entrée (prompt_token_count) et de la sortie (candidates_token_count)
  • Nombre total de jetons en entrée et en sortie (total_token_count).

Exemple utilisant une image importée à partir de l'API File:

model = genai.GenerativeModel("models/gemini-1.5-flash")

prompt = "Tell me about this image"
your_image_file = genai.upload_file(path=media / "organ.jpg")

# Call `count_tokens` to get the input token count
# of the combined text and file (`total_tokens`).
# An image's display or file size does not affect its token count.
# Optionally, you can call `count_tokens` for the text and file separately.
print(model.count_tokens([prompt, your_image_file]))
# ( total_tokens: 263 )

response = model.generate_content([prompt, your_image_file])
response.text
# On the response for `generate_content`, use `usage_metadata`
# to get separate input and output token counts
# (`prompt_token_count` and `candidates_token_count`, respectively),
# as well as the combined token count (`total_token_count`).
print(response.usage_metadata)
# ( prompt_token_count: 264, candidates_token_count: 80, total_token_count: 345 )
count_tokens.py

Exemple d'image fournie en tant que données intégrées:

import PIL.Image

model = genai.GenerativeModel("models/gemini-1.5-flash")

prompt = "Tell me about this image"
your_image_file = PIL.Image.open(media / "organ.jpg")

# Call `count_tokens` to get the input token count
# of the combined text and file (`total_tokens`).
# An image's display or file size does not affect its token count.
# Optionally, you can call `count_tokens` for the text and file separately.
print(model.count_tokens([prompt, your_image_file]))
# ( total_tokens: 263 )

response = model.generate_content([prompt, your_image_file])

# On the response for `generate_content`, use `usage_metadata`
# to get separate input and output token counts
# (`prompt_token_count` and `candidates_token_count`, respectively),
# as well as the combined token count (`total_token_count`).
print(response.usage_metadata)
# ( prompt_token_count: 264, candidates_token_count: 80, total_token_count: 345 )
count_tokens.py

Fichiers vidéo ou audio

L'audio et la vidéo sont chacun convertis en jetons, selon les taux fixes suivants:

  • Vidéo: 263 jetons par seconde
  • Audio: 32 jetons par seconde

Si vous appelez count_tokens avec une entrée texte et vidéo/audio, le nombre de jetons combinés du texte et du fichier vidéo/audio dans l'entrée uniquement (total_tokens) est renvoyé. Vous pouvez effectuer cet appel avant d'appeler generate_content pour vérifier la taille de vos requêtes. Vous pouvez également appeler count_tokens séparément sur le texte et sur le fichier.

Une autre option consiste à appeler generate_content, puis à utiliser l'attribut usage_metadata sur l'objet response pour obtenir les éléments suivants:

  • Le nombre de jetons distincts de l'entrée (prompt_token_count) et de la sortie (candidates_token_count)
  • Nombre total de jetons en entrée et en sortie (total_token_count).
import time

model = genai.GenerativeModel("models/gemini-1.5-flash")

prompt = "Tell me about this video"
your_file = genai.upload_file(path=media / "Big_Buck_Bunny.mp4")

# Videos need to be processed before you can use them.
while your_file.state.name == "PROCESSING":
    print("processing video...")
    time.sleep(5)
    your_file = genai.get_file(your_file.name)

# Call `count_tokens` to get the input token count
# of the combined text and video/audio file (`total_tokens`).
# A video or audio file is converted to tokens at a fixed rate of tokens per second.
# Optionally, you can call `count_tokens` for the text and file separately.
print(model.count_tokens([prompt, your_file]))
# ( total_tokens: 300 )

response = model.generate_content([prompt, your_file])

# On the response for `generate_content`, use `usage_metadata`
# to get separate input and output token counts
# (`prompt_token_count` and `candidates_token_count`, respectively),
# as well as the combined token count (`total_token_count`).
print(response.usage_metadata)
# ( prompt_token_count: 301, candidates_token_count: 60, total_token_count: 361 )

count_tokens.py

Instructions et outils système

Les instructions système et les outils sont également comptabilisés dans le nombre total de jetons pour l'entrée.

Si vous utilisez des instructions système, le nombre de total_tokens augmente pour refléter l'ajout de system_instruction.

model = genai.GenerativeModel(model_name="gemini-1.5-flash")

prompt = "The quick brown fox jumps over the lazy dog."

print(model.count_tokens(prompt))
# total_tokens: 10

model = genai.GenerativeModel(
    model_name="gemini-1.5-flash", system_instruction="You are a cat. Your name is Neko."
)

# The total token count includes everything sent to the `generate_content` request.
# When you use system instructions, the total token count increases.
print(model.count_tokens(prompt))
# ( total_tokens: 21 )
count_tokens.py

Si vous utilisez un appel de fonction, le nombre de total_tokens augmente pour refléter l'ajout de tools.

model = genai.GenerativeModel(model_name="gemini-1.5-flash")

prompt = "I have 57 cats, each owns 44 mittens, how many mittens is that in total?"

print(model.count_tokens(prompt))
# ( total_tokens: 22 )

def add(a: float, b: float):
    """returns a + b."""
    return a + b

def subtract(a: float, b: float):
    """returns a - b."""
    return a - b

def multiply(a: float, b: float):
    """returns a * b."""
    return a * b

def divide(a: float, b: float):
    """returns a / b."""
    return a / b

model = genai.GenerativeModel(
    "models/gemini-1.5-flash-001", tools=[add, subtract, multiply, divide]
)

# The total token count includes everything sent to the `generate_content` request.
# When you use tools (like function calling), the total token count increases.
print(model.count_tokens(prompt))
# ( total_tokens: 206 )
count_tokens.py