Comprendre et compter les jetons


Gemini et d'autres modèles d'IA générative traitent les entrées et les sorties à une granularité appelée jeton.

À propos des jetons

Les jetons peuvent être des caractères uniques comme z ou des 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 compter les jetons.

Essayer de compter les jetons dans un Colab

Vous pouvez essayer de compter des jetons à l'aide d'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 voir 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 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

Par exemple, si vous demandez plutôt les limites de jetons pour un modèle comme gemini-1.5-flash-001, vous constaterez qu'il dispose d'une fenêtre de contexte de deux millions de jetons.

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 valeur 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.
    Cette fonction renvoie le nombre total de jetons dans l'entrée et la sortie : total_token_count.
    Il renvoie également le nombre de jetons d'entrée et de 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.

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

  • Nombres 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)
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:

  • Nombres 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 comprendre la taille de votre prochaine prise de parole, 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 de l'API Gemini sont tokenisées, y compris le texte, les fichiers image et les autres modalités non textuelles. Notez les points clés suivants concernant la tokenisation des entrées multimodales 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 aux débits fixes suivants : 263 jetons par seconde pour la vidéo et 32 jetons par seconde pour l'audio.

Fichiers image

Lors du traitement, l'API Gemini considère les images 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.

Si vous appelez count_tokens avec une entrée texte et image, il 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 sur le texte et le fichier séparément.

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

  • Nombres 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)

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 audio ou vidéo

L'audio et la vidéo sont convertis en jetons aux tarifs 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, il renvoie le 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 vérifier la taille de vos requêtes. Vous pouvez également appeler count_tokens sur le texte et le fichier séparément.

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

  • Nombres 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)
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 et outils système 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 l'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