Gemini y otros modelos de IA generativa procesan entradas y salidas con un nivel de detalle que se denomina token.
En esta guía, se explica cómo obtener el ventanas de contexto de modelos específicos, además de cómo count tokens para casos de uso como entrada de texto, chat, multimodal del sistema de texto, las instrucciones y herramientas del sistema.
Información acerca de los tokens
Los tokens pueden ser caracteres individuales, como z, o palabras completas, como cat. Palabras largas
se dividen en varios tokens. El conjunto de todos los tokens que usa el modelo es
denominado vocabulario, y el proceso de dividir texto en tokens se denomina
asignación de token.
En los modelos de Gemini, un token equivale a unos 4 caracteres. 100 tokens equivalen a entre 60 y 80 palabras en inglés.
Cuando la facturación está habilitada, el costo de una llamada a la API de Gemini es el siguiente: determinada en parte por la cantidad de tokens de entrada y salida, por lo que saber cómo los tokens de count pueden ser útiles.
 Ver en ai.google.dev
|
 Ejecutar en Google Colab
|
 Ver el código fuente en GitHub
|
Ventanas de contexto
Los modelos disponibles a través de la API de Gemini tienen ventanas de contexto que son medidas en tokens. La ventana de contexto define cuánta entrada puedes proporcionar y cuántos resultados puede generar el modelo. Puedes determinar el tamaño ventana de contexto usando la API o consultando models.
En el siguiente ejemplo, puedes ver que el modelo gemini-1.0-pro-001 tiene un
límite de entrada de aproximadamente 30,000 tokens y un límite de salida de alrededor de 2,000, lo que
una ventana de contexto
de unos 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 )
Otro ejemplo sería si en su lugar solicitas los límites de tokens para un modelo como
gemini-1.5-flash-001, verás que tiene una ventana de contexto de 2 millones.
Contar tokens
Se asignan tokens a todas las entradas y salidas de la API de Gemini, incluidos los textos y las imágenes archivos y otras modalidades que no son de texto.
Puedes contar tokens de las siguientes maneras:
Contar tokens de texto
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 )
Contar tokens de varios turnos (chat)
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 )
Contar tokens multimodales
Se asignan tokens a todas las entradas a la API de Gemini, incluidos los archivos de texto, de imagen y otros modalidades no textuales. Ten en cuenta los siguientes puntos clave de alto nivel sobre la asignación de token de entrada multimodal durante el procesamiento de la API de Gemini:
Se considera que las imágenes tienen un tamaño fijo, por lo que consumen una cantidad fija de (actualmente, hay 258), independientemente del tamaño de visualización o del archivo.
Los archivos de video y audio se convierten en tokens a las siguientes tasas fijas: video a 263 tokens por segundo y audio a 32 tokens por segundo.
Archivos de imagen
Durante el procesamiento, la API de Gemini considera que las imágenes tienen un tamaño fijo, por lo que consumir una cantidad fija de tokens (actualmente 258 tokens), independientemente de su de visualización o el tamaño del archivo.
Ejemplo en el que se usa una imagen subida desde la API de File:
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 )
Ejemplo que proporciona la imagen como datos intercalados:
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 )
Archivos de audio o video
El audio y el video se convierten en tokens a las siguientes tasas fijas:
- Video: 263 tokens por segundo
- Audio: 32 tokens por segundo
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 )
Instrucciones y herramientas del sistema
Las instrucciones y herramientas del sistema también se tienen en cuenta en el recuento total de tokens del entrada.
Si usas las instrucciones del sistema, el recuento de total_tokens aumenta para reflejar
la adición 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 )
Si usas las llamadas a función, el recuento de total_tokens aumenta para reflejar el
suma 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 )