Gemini und andere Modelle für generative KI verarbeiten Eingaben und Ausgaben mit einem Detaillierungsgrad wird als Token bezeichnet.
In diesem Leitfaden erfahren Sie, wie Sie die Kontextfenster bestimmter Modelle und wie Sie Tokens zählen für Anwendungsfälle wie Texteingabe, Chat, multimodales Modell Eingabe-, Systemanweisungen und -tools.
Tokens
Tokens können einzelne Zeichen wie z oder ganze Wörter wie cat sein. Lange Wörter
in mehrere Tokens aufgeteilt werden. Der Satz aller vom Modell verwendeten Tokens ist
wird als Vokabular bezeichnet und
der Vorgang des Aufteilens von Text in Tokens
Tokenisierung
Bei Gemini-Modellen entspricht ein Token etwa 4 Zeichen. 100 Tokens entsprechen etwa 60–80 deutschen Wörtern.
Wenn die Abrechnung aktiviert ist, betragen die Kosten für einen Aufruf der Gemini API: die teilweise durch die Anzahl der Eingabe- und Ausgabetoken bestimmt werden. können hilfreich sein.
 Auf ai.google.dev ansehen
|
 In Google Colab ausführen
|
 Quelle auf GitHub ansehen
|
Kontextfenster
Die über die Gemini API verfügbaren Modelle haben Kontextfenster, die in Tokens gemessen wird. Über das Kontextfenster wird festgelegt, wie viel Eingabe du geben kannst und wie viel Ausgabe das Modell generieren kann. Sie können die Größe der mithilfe der API oder in der models.
Im folgenden Beispiel sehen Sie, dass das Modell gemini-1.0-pro-001
Eingabelimit von etwa 30.000 Tokens und ein Ausgabelimit von etwa 2.000 Tokens, was
bedeutet ein Kontextfenster von etwa 32.000 Tokens.
model_info = genai.get_model("models/gemini-1.0-pro-001")
# 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 )
Wenn Sie stattdessen die Tokenlimits für ein Modell wie
gemini-1.5-flash-001 enthält ein Kontextfenster von 2 Mio.
Anzahl der Tokens
Alle Ein- und Ausgaben von der Gemini API werden tokenisiert, einschließlich Text, Bild und und andere Nicht-Text-Modalitäten.
Sie können Tokens auf folgende Arten zählen:
Texttoken zählen
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 )
Tokens für mehrere Runden (Chat) zählen
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 )
Multimodale Tokens zählen
Alle Eingaben in die Gemini API, einschließlich Text-, Bilddateien und anderer Elemente, werden tokenisiert. nicht textbasierten Modalitäten. Beachten Sie die folgenden wichtigen Punkte zur Tokenisierung: multimodaler Eingaben während der Verarbeitung durch die Gemini API:
Da Images eine feste Größe haben, verbrauchen sie eine feste Anzahl Tokens (derzeit 258 Tokens), unabhängig von ihrer Anzeige- oder Dateigröße.
Video- und Audiodateien werden zu folgenden festen Preisen in Tokens konvertiert: Video mit 263 Tokens pro Sekunde und Audio mit 32 Tokens pro Sekunde.
Bilddateien
Bei der Verarbeitung stuft die Gemini API Bilder als feste Größe ein, sodass sie eine feste Anzahl von Tokens (derzeit 258 Tokens) verbrauchen, oder Dateigröße ändern.
Beispiel für die Verwendung eines hochgeladenen Bilds aus der File API:
model = genai.GenerativeModel("models/gemini-1.5-flash")
prompt = "Tell me about this image"
your_image_file = genai.upload_file(path="image.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 )
Beispiel für die Bereitstellung des Bildes als Inline-Daten:
import PIL.Image
model = genai.GenerativeModel("models/gemini-1.5-flash")
prompt = "Tell me about this image"
your_image_file = PIL.Image.open("image.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 )
Video- oder Audiodateien
Audio und Video werden jeweils zu den folgenden festen Raten in Tokens konvertiert:
- Video: 263 Tokens pro Sekunde
- Audio: 32 Tokens pro Sekunde
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 )
Systemanleitung und Tools
Systemanweisungen und -tools werden ebenfalls auf die Gesamtzahl der Tokens für den Eingabe.
Wenn du eine Systemanweisung verwendest, erhöht sich die Anzahl von total_tokens, um dies zu berücksichtigen
das Hinzufügen von 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 )
Wenn Sie Funktionsaufrufe verwenden, erhöht sich die Anzahl von total_tokens entsprechend der
Hinzufügung von 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 )