Comprendre et compter les jetons


Gemini et d'autres modèles d'IA générative traitent les entrées et les sorties de manière précise appelé jeton.

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

À propos des jetons

Les jetons peuvent être des caractères simples comme z ou des mots entiers comme cat. Mots longs sont divisés en plusieurs jetons. L'ensemble de tous les jetons utilisés par le modèle le vocabulaire, et le processus de division du texte en jetons s'appelle la tokenisation.

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

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

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 en jetons. La fenêtre de contexte définit la quantité d'entrées que vous pouvez fournir et la quantité de sortie qu'il peut générer. Vous pouvez déterminer la taille fenêtre de contexte à l'aide de l'API ou en consultant la modèles.

Dans l'exemple suivant, vous pouvez voir que le modèle gemini-1.0-pro-001 a une d'environ 30 000 jetons en entrée et une limite de sortie d'environ 2 000 jetons, ce qui correspond à 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

Autre exemple : si vous demandez les limites de jetons pour un modèle comme gemini-1.5-flash-001, vous verriez qu'elle 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 les textes, les images des fichiers et d'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.
    Cela renvoie le nombre total de jetons dans uniquement l'entrée. 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.
    Cette commande renvoie le nombre total de jetons en entrée et en sortie: total_token_count
    Elle renvoie également séparément le nombre de jetons de l'entrée et de la sortie: 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 de texte uniquement, le nombre de jetons est renvoyé du texte dans l'entrée uniquement (total_tokens). Vous pouvez passer cet appel avant le en appelant generate_content pour vérifier la taille de vos requêtes.

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

  • Le nombre de jetons de l'entrée (prompt_token_count) et la sortie (candidates_token_count)
  • Le 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, le jeton total est renvoyé le nombre de messages pour chaque rôle dans le chat (total_tokens).

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

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

Pour comprendre l'ampleur de votre prochain tour de conversation, vous devez ajouter 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 multimodaux

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

  • Les images sont considérées comme ayant une taille fixe et consomment donc un nombre fixe de (258 jetons actuellement), 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: la vidéo à 263 jetons par seconde et l'audio à 32 jetons par seconde.

Fichiers image

Pendant le traitement, l'API Gemini considère que les images ont une taille fixe. Elles utilisent un nombre fixe de jetons (actuellement 258), quel que soit leur d'affichage ou de taille de fichier.

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

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

  • Le nombre de jetons de l'entrée (prompt_token_count) et la sortie (candidates_token_count)
  • Le 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 qui fournit l'image sous forme de 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, la fonction renvoie nombre de jetons combinés du texte et du fichier vidéo/audio dans l'entrée uniquement (total_tokens). Vous pouvez effectuer cet appel avant d'appeler generate_content pour et vérifier la taille de vos requêtes. Vous pouvez également appeler count_tokens sur le texte et le fichier séparément.

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

  • Le nombre de jetons de l'entrée (prompt_token_count) et la sortie (candidates_token_count)
  • Le 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 le saisie.

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 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