Tokens: Text aus Sicht des Modells

Sprachmodelle rechnen nach Tokens ab, das Kontextfenster wird in Tokens gemessen, und auch die Ausgabegrenze wird in Tokens gesetzt. In der letzten Lektion hast du prompt_tokens und completion_tokens in usage gesehen. Aber was ist ein Token eigentlich? Ist ein chinesisches Schriftzeichen ein Token? Und ein englisches Wort?

Das ist nicht nur eine Frage der Abrechnung. Modelle haben ein paar seltsame Macken, zum Beispiel können sie manchmal nicht richtig zählen, wie viele Zeichen ein Satz hat, und auch das hat seine Wurzel in den Tokens. In dieser Lektion zerschneiden wir Text und schauen hin.

Das Modell liest keinen Text, nur Zahlen

Ein neuronales Netz kann nur Zahlen verarbeiten. Bevor Text ins Modell gelangt, läuft er daher durch ein Programm namens Tokenizer: Es hat ein festes Vokabular, zerschneidet den Text in Stücke, die im Vokabular vorkommen, und jedem Stück entspricht eine Nummer. Das Modell sieht eine Folge von Nummern, gibt auch Nummern aus, und der Tokenizer übersetzt sie am Ende zurück in Text.

Diese Stücke sind Tokens. Ein Token kann ein Schriftzeichen sein, ein Wort, ein halbes englisches Wort, ein Satzzeichen oder ein paar Leerzeichen. Das Vokabular von DeepSeek hat 129.280 Tokens, das Vokabular o200k_base der GPT-4o-Generation von OpenAI hat 200.019.

Das Vokabular wird vor dem Training des Modells aus großen Textmengen statistisch ermittelt: Zeichenkombinationen, die oft zusammen vorkommen, werden zu einem Token zusammengefasst. Modul 09, Lektion 1 implementiert diesen Algorithmus von Grund auf. Merk dir jetzt nur das Ergebnis: Häufige Kombinationen werden zu einem Token verschmolzen, seltene werden zerstückelt.

Tatsächlich zerlegen

DeepSeek hat seinen Tokenizer veröffentlicht; du kannst ihn herunterladen und lokal nutzen. Download, entpacken, dann hast du ein Verzeichnis deepseek_v4_tokenizer. Dazu zwei Pakete:

uv add tokenizers tiktoken

tokenizers lädt die Tokenizer-Dateien von DeepSeek, tiktoken ist der Tokenizer von OpenAI. Das folgende Skript gibt beiden Tokenizern dieselben Texte und druckt jedes erzeugte Stück aus:

import tiktoken
from tokenizers import Tokenizer

deepseek = Tokenizer.from_file("deepseek_v4_tokenizer/tokenizer.json")
openai_enc = tiktoken.get_encoding("o200k_base")  # GPT-4o 等 OpenAI 模型用的分词器

samples = [
    "人工智能正在改变软件开发的方式，越来越多的程序员开始用大模型写代码。",
    "Artificial intelligence is changing how software is built, and more programmers now write code with large language models.",
    "学而时习之，不亦说乎？有朋自远方来，不亦乐乎？",
    "def add(a, b):\n    return a + b\n",
    "3.1415926535897932384626",
    "😀",
]


def deepseek_pieces(text):
    ids = deepseek.encode(text, add_special_tokens=False).ids
    return [deepseek.decode([i]) for i in ids]


def openai_pieces(text):
    pieces = []
    for i in openai_enc.encode(text):
        raw = openai_enc.decode_single_token_bytes(i)
        # 一个汉字或表情可能被拆成几个字节，单独拿出来不是合法的 UTF-8
        pieces.append(raw.decode("utf-8", errors="replace"))
    return pieces


for text in samples:
    ds, oa = deepseek_pieces(text), openai_pieces(text)
    print(f"原文（{len(text)} 个字符）：{text!r}")
    print(f"  DeepSeek {len(ds):3d} 个词元：{ds}")
    print(f"  OpenAI   {len(oa):3d} 个词元：{oa}")
    print()

Ergebnis:

原文（34 个字符）：'人工智能正在改变软件开发的方式，越来越多的程序员开始用大模型写代码。'
  DeepSeek  15 个词元：['人工智能', '正在', '改变', '软件开发', '的方式', '，', '越来越多的', '程序员', '开始', '用', '大', '模型', '写', '代码', '。']
  OpenAI    21 个词元：['人工', '智能', '正在', '改变', '软件', '开发', '的', '方式', '，', '越来越', '多', '的', '程序', '员', '开始', '用', '大', '模型', '写', '代码', '。']

原文（122 个字符）：'Artificial intelligence is changing how software is built, and more programmers now write code with large language models.'
  DeepSeek  20 个词元：['Artificial', ' intelligence', ' is', ' changing', ' how', ' software', ' is', ' built', ',', ' and', ' more', ' programmers', ' now', ' write', ' code', ' with', ' large', ' language', ' models', '.']
  OpenAI    20 个词元：['Artificial', ' intelligence', ' is', ' changing', ' how', ' software', ' is', ' built', ',', ' and', ' more', ' programmers', ' now', ' write', ' code', ' with', ' large', ' language', ' models', '.']

原文（23 个字符）：'学而时习之，不亦说乎？有朋自远方来，不亦乐乎？'
  DeepSeek  22 个词元：['学', '而', '时', '习', '之', '，', '不', '亦', '说', '乎', '？', '有', '朋', '自', '远方', '来', '，', '不', '亦', '乐', '乎', '？']
  OpenAI    21 个词元：['学', '而', '时', '习', '之', '，不', '亦', '说', '乎', '？', '有', '朋', '自', '远', '方', '来', '，不', '亦', '乐', '乎', '？']

原文（32 个字符）：'def add(a, b):\n    return a + b\n'
  DeepSeek  12 个词元：['def', ' add', '(a', ',', ' b', '):\n', '   ', ' return', ' a', ' +', ' b', '\n']
  OpenAI    12 个词元：['def', ' add', '(a', ',', ' b', '):\n', '   ', ' return', ' a', ' +', ' b', '\n']

原文（24 个字符）：'3.1415926535897932384626'
  DeepSeek  10 个词元：['3', '.', '141', '592', '653', '589', '793', '238', '462', '6']
  OpenAI    10 个词元：['3', '.', '141', '592', '653', '589', '793', '238', '462', '6']

原文（1 个字符）：'😀'
  DeepSeek   2 个词元：['�', '�']
  OpenAI     1 个词元：['😀']

In dieser Bildschirmseite steckt einiges, was einen genaueren Blick lohnt.

Modernes Chinesisch zerlegt DeepSeek gröber. „人工智能“ (künstliche Intelligenz), „软件开发“ (Softwareentwicklung) und „越来越多的“ (immer mehr) sind im Vokabular von DeepSeek jeweils ein einziges Token; derselbe Satz braucht bei DeepSeek 15 Tokens, bei OpenAI 21. Das Vokabular wird aus dem Trainingskorpus ermittelt, und im Korpus von DeepSeek gibt es mehr Chinesisch, also wurden mehr chinesische Wortgruppen verschmolzen. Bei gleichem chinesischem Inhalt heißen weniger Tokens weniger Kosten und mehr Inhalt, der auf einmal in den Kontext passt.

Englisch ist bei beiden identisch. Häufige englische Wörter sind fast immer ein Token, und das Leerzeichen gehört zum folgenden Wort: ' intelligence' hat ein Leerzeichen davor. 122 Zeichen ergeben 20 Tokens, ungefähr ein Wort pro Token.

Klassisches Chinesisch ist fast ein Zeichen pro Token. „学而时习之“ besteht in beiden Vokabularen aus fünf einzelnen Zeichen. Im modernen Chinesisch sind Kombinationen wie „学习“ (lernen) oder „时间“ (Zeit) häufig; Kombinationen wie „时习“ oder „不亦“ sind zu selten und wurden nicht verschmolzen. Bei gleichen 23 Zeichen braucht klassisches Chinesisch doppelt so viele Tokens wie modernes.

Auch Leerzeichen im Code kosten Geld. Von den vier Leerzeichen der Einrückung wurden drei zu einem eigenen Token. Je tiefer Python-Code eingerückt ist, desto mehr Tokens gehen auf Leerzeichen.

Zahlen werden in Dreiergruppen zerlegt. 3.1415926... wird in Blöcke wie 141, 592, 653 zerschnitten. Das Modell sieht keine ganze Zahl, sondern mehrere „dreistellige Fragmente“. Das ist ein Grund, warum Modelle bei mehrstelligen Rechnungen leicht Fehler machen: Schriftliches Rechnen verlangt, Stelle für Stelle auszurichten, aber die Eingabe ist gar nicht stellenweise.

Emojis können in Bytes zerfallen. DeepSeek zerlegt 😀 in zwei Tokens, die einzeln dekodiert beide als � erscheinen, weil jedes Token nur einen Teil der Bytes der Emoji-Kodierung ist; erst zusammen ergeben sie das vollständige Zeichen.

Tokens schätzen, wenn es ums Geld geht

Am genauesten sind zwei Wege: mit dem offiziellen Tokenizer lokal zählen oder direkt auf das usage der API-Antwort schauen.

Wenn das nicht praktisch ist, kann man grob schätzen. Die offizielle Dokumentation von DeepSeek nennt: 1 englisches Zeichen ≈ 0,3 Tokens, 1 chinesisches Zeichen ≈ 0,6 Tokens. Ich habe einige Texte über die API gemessen; die Ergebnisse liegen unter den offiziellen Zahlen:

Gemessen habe ich so: dieselbe Frage mit max_tokens=1, nur auf prompt_tokens schauen. Zuerst eine Nachricht mit nur dem Buchstaben a senden und ihre Eingabe-Tokens als Basis (den Aufwand der Formatmarkierungen) notieren, dann den zu messenden Text senden; die Differenz der beiden plus eins ist die Tokenzahl des Textes selbst.

def count_tokens(text):
    r = client.chat.completions.create(
        model="deepseek-flash",
        messages=[{"role": "user", "content": text}],
        max_tokens=1,
        extra_body={"thinking": {"type": "disabled"}},
    )
    return r.usage.prompt_tokens


base = count_tokens("a")  # 格式标记加上字母 a 本身，我测到的是 5
print(count_tokens("学而时习之，不亦说乎？有朋自远方来，不亦乐乎？") - base + 1)

Die offiziellen Zahlen sind konservativ, was für ein Budget gerade richtig ist, da man sie kaum überschreitet. Denk aber daran, dass die Tokenzahl vom Inhalt abhängt: Klassische Texte, seltene Zeichen, Emojis und wenig verbreitete Sprachen sind „teurer“ als alltägliches Chinesisch.

Warum Modelle schlecht Zeichen zählen

Ein berühmtes Beispiel: Fragt man ein Modell „Wie viele r hat strawberry?“, antworten viele Modelle 2; richtig ist 3.

Schauen wir, wie der Tokenizer mit dem Wort umgeht: DeepSeek zerlegt ein alleinstehendes strawberry in st, raw und berry, das mit Leerzeichen davor geschriebene strawberry (so steht es mitten in einem Satz) ist dagegen ein einziges Token. Das Modell bekommt eine Nummer (79430) und „sieht“ die Buchstaben darin nicht direkt. Dass es weiß, wie viele r darin stecken, kann nur daher kommen, dass es beim Training ähnliche Diskussionen gesehen hat.

Das Beispiel ist aber so berühmt, dass die meisten heutigen Modelle es kennen. Ich habe deepseek-flash einige Varianten beantworten lassen, jede dreimal mit ausgeschaltetem und dreimal mit eingeschaltetem Denken:

Die alte Frage auf Englisch ist inzwischen immer richtig; fragt man auf Chinesisch, nimmt ein anderes Wort oder lässt chinesische Zeichen zählen, gibt es mit ausgeschaltetem Denken gelegentlich Fehler. Mit Denken ist alles richtig, weil das Modell im Denkprozess das Wort Buchstabe für Buchstabe ausschreibt und dann zählt, also die Tokens gewissermaßen selbst aufbricht.

In der Praxis gilt: Alles, was genau gezählt werden muss, etwa Zeichenzahlen, String-Längen oder das Kürzen von Text, gibst du nicht dem Modell, sondern erledigst es im Code. len("秋天的叶子一片片落下") ist immer 10.

Häufige Fragen

Kann man Tokenzahlen verschiedener Modelle direkt vergleichen? Nein. Derselbe chinesische Text ergibt bei DeepSeek und OpenAI drei Zehntel unterschiedlich viele Tokens. Um die Preise zweier Modelle zu vergleichen, nimmst du denselben echten Geschäftstext, ermittelst jeweils die Tokenzahl und multiplizierst mit dem jeweiligen Stückpreis; nur Stückpreise zu vergleichen, reicht nicht.

Kann ich im Code mit tiktoken die Tokens für DeepSeek zählen? Für Englisch und Code ist es ungefähr gleich, für Chinesisch wird es zu viel. Wenn es genau sein soll, nimm den Tokenizer von DeepSeek selbst.

Übungen

1. Gib deinen Namen, den Namen deiner Stadt und einen Satz im Dialekt den beiden Tokenizern in tokens.py und schau, wie sie jeweils zerlegt werden.
2. Miss mit count_tokens: Derselbe Inhalt auf Chinesisch und auf Englisch geschrieben, wo sind es mehr Tokens? Probier es mit einem echten Text aus deiner Arbeit.
3. Nimm ein Stück JSON (etwa die Antwort einer API) und zähl die Tokens. Presse es dann in eine Zeile, entferne alle Leerzeichen und zähl erneut. Wie viel weniger sind es? Das ist nützlich, wenn man dem Modell viele Daten übergeben muss.

Selbsttest

1. Für denselben Satz in modernem Chinesisch braucht DeepSeek weniger Tokens als der Tokenizer von OpenAI. Warum? Was bedeutet das für dich?

Das Vokabular eines Tokenizers wird aus dem Trainingskorpus ermittelt, und der Korpus von DeepSeek hat einen höheren Anteil Chinesisch, also wurden mehr chinesische Wortgruppen zu einem Token verschmolzen. Für dich bedeutet das: Derselbe chinesische Inhalt kostet bei DeepSeek weniger, und auf einmal passt mehr in den Kontext. Beim Preisvergleich von Modellen solltest du mit echtem Text die Tokenzahl ermitteln und dann vergleichen.

2. Warum zählen Modelle leicht falsch, wie oft ein Buchstabe in einem Wort vorkommt?

Das Modell sieht Token-Nummern, keine Buchstaben. Ein häufiges Wort ist oft ein einziges Token; das Modell kann die Buchstaben darin nicht direkt „sehen“ und muss aus der Erinnerung ans Training antworten. Mit eingeschaltetem Denken schreibt das Modell das Wort zuerst Buchstabe für Buchstabe aus und zählt dann, was die Trefferquote stark erhöht. Wo genau gezählt werden muss, sollte Code statt eines Modells ran.

3. Warum ist klassisches Chinesisch „teurer“ als modernes Chinesisch mit gleich vielen Zeichen?

Das Vokabular verschmilzt Zeichenkombinationen, die im Trainingskorpus häufig sind. Häufige Wörter des modernen Chinesisch („人工智能“, „程序员“ Programmierer) wurden zu einem Token verschmolzen; Kombinationen des klassischen Chinesisch („时习“, „不亦“) sind selten, wurden nicht verschmolzen und bleiben ein Zeichen pro Token. Mehr Tokens heißt höhere Kosten.