O Gemini e outros modelos de IA generativa processam entradas e saídas com granularidade chamado de token.
Este guia explica como receber a janelas de contexto de modelos específicos, bem como count tokens para casos de uso como entrada de texto, chat, multimodal entradas e instruções e ferramentas do sistema.
Sobre tokens
Os tokens podem conter caracteres simples, como z, ou palavras inteiras, como cat. Palavras longas
são divididos em vários tokens. O conjunto de todos os tokens usados pelo modelo
chamado de vocabulário, e o processo de dividir o texto em tokens é chamado
tokenização.
Para modelos do Gemini, um token equivale a cerca de quatro caracteres. 100 tokens equivalem a cerca de 60-80 palavras em inglês.
Quando o faturamento está ativado, o custo de uma chamada para a API Gemini é de determinada em parte pelo número de tokens de entrada e saída. Portanto, saber de contagem de tokens pode ser útil.
 Ver em ai.google.dev
|
 Executar no Google Colab
|
 Veja o código-fonte no GitHub
|
Janelas de contexto
Os modelos disponíveis pela API Gemini têm janelas de contexto que são medido em tokens. A janela de contexto define quanta entrada você pode fornecer e quanta saída o modelo pode gerar. É possível determinar o tamanho janela de contexto usando a API ou procurando no models.
No exemplo abaixo, o modelo gemini-1.0-pro-001 tem um
de entrada de cerca de 30.000 tokens e um limite de saída de cerca de 2.000 tokens,
representa uma janela de contexto de cerca de 32 mil 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 )
Como outro exemplo, se você solicitou os limites de token para um modelo como
gemini-1.5-flash-001, você verá que ele tem uma janela de contexto de 2 milhões.
Contar tokens
Todas as entradas e saídas da API Gemini são tokenizadas, incluindo texto, imagem arquivos e outras modalidades não textuais.
É possível contar tokens das seguintes maneiras:
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 várias interações (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 multimodais
Todas as entradas da API Gemini são tokenizadas, incluindo texto, arquivos de imagem e outros modalidades diferentes de texto. Observe estes pontos principais de alto nível sobre a tokenização de entrada multimodal durante o processamento pela API Gemini:
As imagens têm tamanho fixo, portanto, consomem uma quantidade fixa (atualmente 258 tokens), independentemente da exibição ou do tamanho do arquivo.
Os arquivos de vídeo e áudio são convertidos em tokens nas seguintes taxas fixas: vídeo a 263 tokens por segundo e áudio a 32 tokens por segundo.
Arquivos de imagem
Durante o processamento, a API Gemini considera que as imagens têm tamanho fixo. consomem um número fixo de tokens (atualmente 258), não importa o tamanho de exibição ou do arquivo.
Exemplo que usa uma imagem enviada da API 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 )
Exemplo que fornece a imagem como dados inline:
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 )
Arquivos de vídeo ou áudio
Áudio e vídeo são convertidos em tokens nas seguintes taxas fixas:
- Vídeo: 263 tokens por segundo
- Áudio: 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 )
Instruções e ferramentas do sistema
As instruções e ferramentas do sistema também contam para a contagem total de tokens do entrada.
Se você usar as instruções do sistema, a contagem de total_tokens vai aumentar para refletir
a adição 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 )
Se você usar a chamada de função, a contagem de total_tokens vai aumentar para refletir a
adição 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 )