W interfejsie Live API jest dostępny nowy model Gemini Native Audio. Wypróbuj bezpłatnie w Google AI Studio

Ta strona została przetłumaczona przez Cloud Translation API.

Zrozumienie i liczenie tokenów

Gemini i inne modele generatywnej AI przetwarzają dane wejściowe i wyjściowe w jednostkach zwanych tokenami.

W przypadku modeli Gemini token odpowiada około 4 znakom. 100 tokenów to około 60–80 słów w języku angielskim.

Informacje o tokenach

Tokeny mogą być pojedynczymi znakami, np. z, lub całymi słowami, np. cat. Długie słowa są dzielone na kilka tokenów. Zbiór wszystkich tokenów używanych przez model nazywa się słownikiem, a proces dzielenia tekstu na tokeny to tokenizacja.

Gdy płatności są włączone, koszt wywołania interfejsu Gemini API zależy częściowo od liczby tokenów wejściowych i wyjściowych, więc wiedza o tym, jak je zliczać, może być przydatna.

Wypróbuj zliczanie tokenów w Colab

Możesz wypróbować zliczanie tokenów za pomocą Colab.

Wyświetl na ai.google.dev

Wypróbuj notatnik Colab

Wyświetl notatnik w GitHubie

Okna kontekstu

Modele dostępne w Gemini API mają okna kontekstu mierzone w tokenach. Okno kontekstu określa, ile danych wejściowych możesz podać i ile danych wyjściowych może wygenerować model. Rozmiar okna kontekstu możesz określić, wywołując punkt końcowy getModels lub sprawdzając dokumentację modeli.

W tym przykładzie widać, że model gemini-2.0-flash ma limit danych wejściowych wynoszący około 1 000 000 tokenów i limit danych wyjściowych wynoszący około 8000 tokenów, co oznacza, że okno kontekstu ma 1 000 000 tokenów.

from google import genai

client = genai.Client()
model_info = client.models.get(model="gemini-2.0-flash")
print(f"{model_info.input_token_limit=}")
print(f"{model_info.output_token_limit=}")
# ( e.g., input_token_limit=30720, output_token_limit=2048 )count_tokens.py

Liczba tokenów

Wszystkie dane wejściowe i wyjściowe interfejsu Gemini API są tokenizowane, w tym tekst, pliki obrazów i inne formaty nietekstowe.

Tokeny możesz zliczać na te sposoby:

Wywołaj funkcję count_tokens, podając dane wejściowe żądania.
Zwraca łączną liczbę tokenów tylko w danych wejściowych. Możesz wykonać to wywołanie przed wysłaniem danych wejściowych do modelu, aby sprawdzić rozmiar żądań.
Użyj atrybutu usage_metadata w obiekcie response po wywołaniu funkcji generate_content.
Zwraca łączną liczbę tokenów zarówno wejściowych, jak i wyjściowych: total_token_count.
Zwraca też oddzielnie liczbę tokenów wejściowych i wyjściowych: prompt_token_count (tokeny wejściowe) i candidates_token_count (tokeny wyjściowe).

Jeśli używasz modelu myślącego, takiego jak modele 2.5, tokeny użyte w procesie myślenia są zwracane w thoughts_token_count. Jeśli używasz pamięci podręcznej kontekstu, liczba tokenów w pamięci podręcznej będzie podana w cached_content_token_count.

Zliczanie tokenów tekstowych

Jeśli wywołasz funkcję count_tokens z wejściem tekstowym, zwróci ona liczbę tokenów tekstu tylko w danych wejściowych (total_tokens). Możesz wywołać tę funkcję przed wywołaniem funkcji generate_content, aby sprawdzić rozmiar żądań.

Inną opcją jest wywołanie generate_content, a następnie użycie atrybutu usage_metadata w obiekcie response, aby uzyskać te informacje:

Osobne liczby tokenów dla danych wejściowych (prompt_token_count), treści w pamięci podręcznej (cached_content_token_count) i danych wyjściowych (candidates_token_count).
Liczba tokenów w procesie myślowym (thoughts_token_count)
Łączna liczba tokenów zarówno wejściowych, jak i wyjściowych (total_token_count)

from google import genai

client = genai.Client()
prompt = "The quick brown fox jumps over the lazy dog."

# Count tokens using the new client method.
total_tokens = client.models.count_tokens(
    model="gemini-2.0-flash", contents=prompt
)
print("total_tokens: ", total_tokens)
# ( e.g., total_tokens: 10 )

response = client.models.generate_content(
    model="gemini-2.0-flash", contents=prompt
)

# The usage_metadata provides detailed token counts.
print(response.usage_metadata)
# ( e.g., prompt_token_count: 11, candidates_token_count: 73, total_token_count: 84 )count_tokens.py

Zliczanie tokenów w przypadku promptów wieloetapowych (czat)

Jeśli wywołasz count_tokens z historią czatu, zwróci ona łączną liczbę tokenów tekstu z każdej roli na czacie (total_tokens).

Inną opcją jest wywołanie send_message, a następnie użycie atrybutu usage_metadata w obiekcie response, aby uzyskać te informacje:

Osobne liczby tokenów dla danych wejściowych (prompt_token_count), treści w pamięci podręcznej (cached_content_token_count) i danych wyjściowych (candidates_token_count).
Liczba tokenów w procesie myślowym (thoughts_token_count)
Łączna liczba tokenów zarówno wejściowych, jak i wyjściowych (total_token_count)

Aby dowiedzieć się, jak duża będzie kolejna tura rozmowy, musisz dodać ją do historii, gdy wywołujesz funkcję count_tokens.

from google import genai
from google.genai import types

client = genai.Client()

chat = client.chats.create(
    model="gemini-2.0-flash",
    history=[
        types.Content(
            role="user", parts=[types.Part(text="Hi my name is Bob")]
        ),
        types.Content(role="model", parts=[types.Part(text="Hi Bob!")]),
    ],
)
# Count tokens for the chat history.
print(
    client.models.count_tokens(
        model="gemini-2.0-flash", contents=chat.get_history()
    )
)
# ( e.g., total_tokens: 10 )

response = chat.send_message(
    message="In one sentence, explain how a computer works to a young child."
)
print(response.usage_metadata)
# ( e.g., prompt_token_count: 25, candidates_token_count: 21, total_token_count: 46 )

# You can count tokens for the combined history and a new message.
extra = types.UserContent(
    parts=[
        types.Part(
            text="What is the meaning of life?",
        )
    ]
)
history = chat.get_history()
history.append(extra)
print(client.models.count_tokens(model="gemini-2.0-flash", contents=history))
# ( e.g., total_tokens: 56 )count_tokens.py

Zliczanie tokenów multimodalnych

Wszystkie dane wejściowe do Gemini API są tokenizowane, w tym tekst, pliki graficzne i inne formaty nietekstowe. Podczas przetwarzania danych wejściowych multimodalnych przez interfejs Gemini API weź pod uwagę te kluczowe informacje o tokenizacji:

W przypadku Gemini 2.0 dane wejściowe w postaci obrazów, których oba wymiary są mniejsze lub równe 384 pikselom, są liczone jako 258 tokenów. Obrazy większe w jednym lub obu wymiarach są przycinane i skalowane w razie potrzeby do rozmiaru 768 x 768 pikseli. Każdy taki fragment jest liczony jako 258 tokenów. Przed wprowadzeniem Gemini 2.0 obrazy wykorzystywały stałą liczbę 258 tokenów.
Pliki wideo i audio są konwertowane na tokeny według tych stałych stawek: wideo – 263 tokeny na sekundę, audio – 32 tokeny na sekundę.

Rozdzielczości multimediów

Wersja podglądowa Gemini 3 Pro wprowadza szczegółową kontrolę nad przetwarzaniem obrazu multimodalnego za pomocą parametru media_resolution. Parametr media_resolution określa maksymalną liczbę tokenów przydzielonych na obraz wejściowy lub klatkę filmu. Wyższe rozdzielczości zwiększają zdolność modelu do odczytywania drobnego tekstu lub rozpoznawania małych szczegółów, ale zwiększają zużycie tokenów i opóźnienie.

Więcej informacji o tym parametrze i jego wpływie na obliczenia tokenów znajdziesz w przewodniku rozdzielczość multimediów.

Pliki graficzne

Jeśli wywołasz funkcję count_tokens z tekstem i obrazem, zwróci ona łączną liczbę tokenów tekstu i obrazu tylko w danych wejściowych (total_tokens). Możesz wywołać tę funkcję przed wywołaniem funkcji generate_content, aby sprawdzić rozmiar żądań. Opcjonalnie możesz też wywołać funkcję count_tokens osobno w przypadku tekstu i pliku.

Inną opcją jest wywołanie generate_content, a następnie użycie atrybutu usage_metadata w obiekcie response, aby uzyskać te informacje:

Osobne liczby tokenów dla danych wejściowych (prompt_token_count), treści w pamięci podręcznej (cached_content_token_count) i danych wyjściowych (candidates_token_count).
Liczba tokenów w procesie myślowym (thoughts_token_count)
Łączna liczba tokenów zarówno wejściowych, jak i wyjściowych (total_token_count)

Przykład, który korzysta z przesłanego obrazu z interfejsu File API:

from google import genai

client = genai.Client()
prompt = "Tell me about this image"
your_image_file = client.files.upload(file=media / "organ.jpg")

print(
    client.models.count_tokens(
        model="gemini-2.0-flash", contents=[prompt, your_image_file]
    )
)
# ( e.g., total_tokens: 263 )

response = client.models.generate_content(
    model="gemini-2.0-flash", contents=[prompt, your_image_file]
)
print(response.usage_metadata)
# ( e.g., prompt_token_count: 264, candidates_token_count: 80, total_token_count: 345 )count_tokens.py

Przykład, w którym obraz jest podany jako dane w treści:

from google import genai
import PIL.Image

client = genai.Client()
prompt = "Tell me about this image"
your_image_file = PIL.Image.open(media / "organ.jpg")

# Count tokens for combined text and inline image.
print(
    client.models.count_tokens(
        model="gemini-2.0-flash", contents=[prompt, your_image_file]
    )
)
# ( e.g., total_tokens: 263 )

response = client.models.generate_content(
    model="gemini-2.0-flash", contents=[prompt, your_image_file]
)
print(response.usage_metadata)
# ( e.g., prompt_token_count: 264, candidates_token_count: 80, total_token_count: 345 )count_tokens.py

pliki wideo lub audio,

Dźwięk i obraz są przeliczane na tokeny według tych stałych stawek:

Wideo: 263 tokeny na sekundę
Audio: 32 tokeny na sekundę

Jeśli wywołasz funkcję count_tokens z tekstowym i wideo/audio danymi wejściowymi, zwróci ona łączną liczbę tokenów tekstu i pliku wideo/audio tylko w danych wejściowych (total_tokens). Możesz wywołać tę funkcję przed wywołaniem funkcji generate_content, aby sprawdzić rozmiar żądań. Możesz też opcjonalnie wywołać funkcję count_tokens na tekście i pliku osobno.

Inną opcją jest wywołanie generate_content, a następnie użycie atrybutu usage_metadata w obiekcie response, aby uzyskać te informacje:

Osobne liczby tokenów dla danych wejściowych (prompt_token_count), treści w pamięci podręcznej (cached_content_token_count) i danych wyjściowych (candidates_token_count).
Liczba tokenów w procesie myślowym (thoughts_token_count)
Łączna liczba tokenów zarówno wejściowych, jak i wyjściowych (total_token_count)

from google import genai
import time

client = genai.Client()
prompt = "Tell me about this video"
your_file = client.files.upload(file=media / "Big_Buck_Bunny.mp4")

# Poll until the video file is completely processed (state becomes ACTIVE).
while not your_file.state or your_file.state.name != "ACTIVE":
    print("Processing video...")
    print("File state:", your_file.state)
    time.sleep(5)
    your_file = client.files.get(name=your_file.name)

print(
    client.models.count_tokens(
        model="gemini-2.0-flash", contents=[prompt, your_file]
    )
)
# ( e.g., total_tokens: 300 )

response = client.models.generate_content(
    model="gemini-2.0-flash", contents=[prompt, your_file]
)
print(response.usage_metadata)
# ( e.g., prompt_token_count: 301, candidates_token_count: 60, total_token_count: 361 )count_tokens.py

Instrukcje i narzędzia systemowe

Instrukcje i narzędzia systemowe są również wliczane do łącznej liczby tokenów wejściowych.

Jeśli używasz instrukcji systemowych, liczba total_tokens wzrośnie, aby odzwierciedlić dodanie system_instruction.

Jeśli używasz wywoływania funkcji, liczba total_tokens wzrośnie, aby odzwierciedlić dodanie tools.