Einführung in Large Language Models

Einleitung

Was genau ist ein Large Language Model? Um diese Frage zu beantworten, beginnen wir mit etwas Vertrautem. Stellen Sie sich vor, Sie verfassen eine Textnachricht auf Ihrem Telefon. Nach Eingabe einiger Wörter schlägt Ihr Telefon das nächste Wort vor — und manchmal ist es so genau, dass Sie einfach auf den Vorschlag tippen, um weiterzuschreiben. Diese Funktion zur Wortvorhersage ist eine sehr einfache Form eines Sprachmodells. Ein Large Language Model (LLM) arbeitet nach der gleichen grundlegenden Idee, jedoch in einem unvergleichlich größeren Maßstab.

Ein LLM ist ein neuronales Netz, das mit enormen Textmengen trainiert wurde — Bücher, Artikel, Websites, Code und mehr. Während dieses Trainingsprozesses liest das Modell Milliarden von Sätzen und lernt die statistischen Beziehungen zwischen Wörtern und Phrasen. Es entdeckt Muster wie: wenn bestimmte Wörter erscheinen, welche Wörter tendenziell folgen; wie Sätze strukturiert sind; wie Kontext die Bedeutung verändert; und wie verschiedene Informationen miteinander zusammenhängen. Nach Abschluss des Trainings kann das Modell kohärente, kontextuell angemessene Texte als Antwort auf eine von Ihnen bereitgestellte Eingabeaufforderung generieren.

Das „Large" in Large Language Model bezieht sich gleichzeitig auf zwei Dinge. Erstens auf den Umfang der Trainingsdaten — moderne LLMs werden auf Datensätzen mit Hunderten von Milliarden bis Billionen von Tokens trainiert (wobei ein Token ungefähr ein Wort oder ein Teil eines Wortes ist). Zweitens auf das Modell selbst — diese Modelle enthalten Milliarden von Parametern, das sind die internen numerischen Werte, die alles kodieren, was das Modell gelernt hat. Ein Modell mit 7 Milliarden Parametern hat beispielsweise 7 Milliarden einstellbare Zahlen, die zusammen sein Wissen über Sprache repräsentieren.

Warum ist das für Sie als Jetson-Entwickler wichtig? Bis vor kurzem erforderte das Ausführen eines Modells dieser Größe teure Cloud-Server mit mehreren High-End-GPUs. Der große Durchbruch in den letzten zwei Jahren ist, dass Techniken wie Quantisierung — Komprimierung der numerischen Präzision des Modells — es nun ermöglichen, leistungsfähige LLMs auf Edge-Geräten wie dem NVIDIA Jetson Orin Nano und Orin NX auszuführen. Das bedeutet, Sie können KI-gestützte Anwendungen erstellen, die vollständig offline laufen, Ihre Daten privat halten und die Abhängigkeit von Internetverbindungen eliminieren.

Wie LLMs funktionieren

Jetzt, da Sie verstehen, was ein LLM ist, stellt sich die natürliche Frage: Wie erzeugt es tatsächlich Text? Die Antwort dreht sich um eine Kernoperation — das nächste Token in einer Sequenz vorherzusagen.

Tokens: Die Bausteine

Bevor wir diskutieren, wie das Modell Text generiert, müssen wir klären, was es bedeutet, Text als „Tokens" zu verarbeiten. Ein LLM liest keinen rohen Text so wie Menschen. Stattdessen zerlegt ein Tokenizer Ihre Eingabe in kleinere Einheiten, die als Tokens bezeichnet werden. Ein Token kann ein ganzes Wort wie „computer", ein häufiges Wortfragment wie „the" oder sogar ein einzelnes Zeichen in einer unbekannten Sprache sein. Zum Beispiel:

"The reComputer runs Linux"
→ ["The", " re", "Computer", " runs", " Linux"]   (5 Tokens)

Das Vokabular des Tokenizers enthält typischerweise zwischen 30.000 und 100.000 Tokens. Jeder Text, den das Modell sieht, wird vor jeder Verarbeitung in eine Sequenz dieser Tokens konvertiert.

Der Trainingsprozess

Das Training eines LLM umfasst drei Schlüsselphasen, die jeweils auf der vorherigen aufbauen:

Phase 1 — Pre-Training auf Rohdaten. Das Modell wird mit enormen Textmengen gefüttert (häufige Quellen umfassen Common Crawl, Wikipedia, GitHub-Repositories und veröffentlichte Bücher). In dieser Phase ist die Aufgabe des Modells trickreich einfach: Gegeben eine Sequenz von Tokens, sage das nächste Token vorher. Wenn das Modell beispielsweise „The Eiffel Tower is located in" sieht, lernt es, dass „Paris" das wahrscheinlichste nächste Token ist. Durch Wiederholung dieser Übung über Milliarden von Beispielen baut das Modell schrittweise eine interne Repräsentation von Grammatik, Fakten, Reasoning-Mustern und sogar Programmierlogik auf.

Phase 2 — Supervised Fine-Tuning (SFT). Nach dem Pre-Training verfügt das Modell über breites Wissen, weiß aber nicht, wie es sich als nützlicher Assistent verhalten soll. In dieser Phase erstellen menschliche Annotatoren Beispiele für hochwertige Prompt-Antwort-Paare. Das Modell wird auf diesen Beispielen trainiert, um das Format und den Stil hilfreicher Antworten zu lernen.

Phase 3 — Alignment (RLHF oder ähnlich). In der letzten Phase bewerten menschliche Bewerter mehrere Modellantworten von der besten zur schlechtesten. Dieses Feedback trainiert ein Belohnungsmodell, das wiederum das LLM dazu anleitet, Antworten zu produzieren, die hilfreicher, harmloser und ehrlicher sind. Deshalb produzieren moderne Chat-Modelle kohärentere und nützlichere Antworten, als es die Pre-Training-Phase allein vermuten lassen würde.

Inferenz: Text Token für Token generieren

Sobald das Training abgeschlossen ist, generiert das Modell Text durch einen Prozess, der als Inferenz bezeichnet wird. Folgendes passiert genau, wenn Sie eine Eingabeaufforderung eingeben:

Der Tokenizer konvertiert dies in Token-IDs. Das Modell verarbeitet diese Tokens und erzeugt eine Wahrscheinlichkeitsverteilung über alle Tokens in seinem Vokabular. Das Token „Paris" erhält die höchste Wahrscheinlichkeit, wird ausgewählt und an die Ausgabe angehängt. Die aktualisierte Sequenz lautet nun „The capital of France is Paris", und das Modell wiederholt den Prozess — es sagt erneut das nächste Token vorher. Dies setzt sich fort, bis das Modell ein spezielles Sequenzende-Token ausgibt oder eine maximale Längenbegrenzung erreicht wird.

Schritt 1: "The capital of France is"         → "Paris" vorhersagen
Schritt 2: "The capital of France is Paris"    → "and" vorhersagen
Schritt 3: "The capital of France is Paris and"→ " the" vorhersagen
Schritt 4: ...fortfahren bis zur Fertigstellung

Ein kritischer Punkt, den es zu verstehen gilt: Das Modell „kennt" die Antwort nicht so, wie eine Datenbankabfrage funktioniert. Es produziert Text, der statistisch wahrscheinlich ist, basierend auf seinen Trainingsdaten. Deshalb können LLMs manchmal plausibel klingende, aber falsche Aussagen generieren — eine Einschränkung, die Sie beim Erstellen von Anwendungen beachten sollten.

Der gesamte Prozess — von Ihrer Eingabeaufforderung zur vollständigen Antwort — ist das, was bei jeder Interaktion mit einem LLM passiert. Im nächsten Abschnitt werden wir die spezifische neuronale Netzwerkarchitektur betrachten, die all dies ermöglicht.

_{Wie Large Language Models Text verarbeiten und generieren}

Die Transformer-Architektur

Nahezu alle modernen LLMs basieren auf der Transformer-Architektur, die im wegweisenden Paper „Attention Is All You Need" (2017) von Forschern bei Google eingeführt wurde. Dieses einzelne Paper veränderte grundlegend die Richtung der KI — und die Modelle, die Sie auf Jetson ausführen werden (Llama, Qwen, DeepSeek, Gemma), sind alle direkte Nachkommen dieser Architektur.

Die Schlüsselinnovation ist der Self-Attention-Mechanismus, der es dem Modell ermöglicht, die Wichtigkeit verschiedener Wörter bei der Textverarbeitung zu gewichten — wodurch es Kontext, Beziehungen und Bedeutung auf beispiellosem Niveau verstehen kann.

_{Der Transformer: Grundlage moderner LLMs}

Von sequenziell zu parallel: Warum Transformer gewannen

Vor Transformern verarbeiteten Modelle wie RNNs (Recurrent Neural Networks) und LSTMs Text ein Wort nach dem anderen, sequenziell von links nach rechts. Dies führte zu zwei großen Problemen:

1. Langsam: Jedes Wort hing von der Berechnung des vorherigen Wortes ab — keine Parallelisierung möglich
2. Vergesslich: Bis das Modell das 100. Wort erreichte, hatte es das 1. Wort größtenteils „vergessen"

RNN (Alt):     "The" → "cat" → "sat" → "on" → "the" → "mat"   (langsam, sequenziell)
Transformer:   ["The", "cat", "sat", "on", "the", "mat"] → alle gleichzeitig!   (schnell, parallel)

Der Transformer löste beide Probleme, indem er alle Wörter gleichzeitig durch Self-Attention verarbeitete. Dies machte das Training dramatisch schneller und ermöglichte es Modellen, auch langreichweitige Beziehungen effektiv zu erfassen.

Wie Self-Attention funktioniert

Self-Attention ist die Schlüsselinnovation des Transformers. Lassen Sie uns das anhand eines konkreten Beispiels verstehen.

Eine praxisnahe Analogie — Der Einstellungsprozess:

Stellen Sie sich vor, Sie stellen für eine Position ein und haben 5 Lebensläufe erhalten. Sie müssen jeden Kandidaten bewerten, indem Sie ihn mit einer „Stellenbeschreibung" vergleichen. So funktioniert Self-Attention:

• Jeder Lebenslauf ist sowohl Kandidat als auch Stellenbeschreibung — klingt seltsam, aber genau so behandelt Self-Attention jedes Wort in einem Satz
• Die „Stellenbeschreibung" zur Bewertung von Kandidat A heißt Query (Q)
• Jeder Lebenslauf hat einen Abschnitt „Qualifikationen" — das sind die Keys (K)
• Der eigentliche Inhalt des Lebenslaufs (Erfahrung, Fähigkeiten, Ausbildung) ist das Value (V)

Stellen Sie sich nun vor, Sie möchten herausfinden, worauf sich das Wort „it" in diesem Satz bezieht:

„The robot picked up the ball because it was heavy."

Hier ist der schrittweise Prozess:

Schritt 1: Q/K/V für jedes Wort generieren

Jedes Wort im Satz erzeugt seinen eigenen Query-, Key- und Value-Vektor. Stellen Sie sich vor, jedes Wort bereitet sowohl eine „Suchfrage" als auch „zu teilende Inhalte" vor:

Schritt 2: Relevanzwerte berechnen — das Skalarprodukt

Für das Wort „it" nehmen wir seinen Query-Vektor und berechnen Skalarprodukte mit den Key-Vektoren ALLER anderen Wörter:

„it" Query × „robot" Key = 0.2 (niedrige Relevanz — Roboter werden in diesem Kontext typischerweise nicht als schwer beschrieben)
„it" Query × „picked" Key = 0.1 (irrelevant — „picked" hat nichts über Gewicht zu sagen)
„it" Query × „ball" Key = 0.9 (hohe Relevanz — Bälle können definitiv schwer sein!)

Schritt 3: Softmax anwenden zur Normalisierung

Diese rohen Werte durchlaufen Softmax, das sie in Wahrscheinlichkeiten umwandelt, die sich zu 1 aufsummieren:

„ball":  0.82 (82% — „it" bezieht sich höchstwahrscheinlich auf „ball")
„robot": 0.15 (15%)
„picked": 0.03 (3%)

Schritt 4: Gewichtete Summe der Values

Nun kombinieren wir alle Value-Vektoren mit diesen Gewichten:

Neue „it"-Repräsentation = 0.82 × ball.Value + 0.15 × robot.Value + 0.03 × picked.Value

Das Ergebnis? Das Wort „it" „weiß" jetzt, dass es sich auf den Ball bezieht, und trägt diese Bedeutung weiter.

Schritt 5: Für JEDES Wort wiederholen

Dieser genaue Prozess passiert für jedes Wort im Satz gleichzeitig. „robot" schaut auf „ball", „picked" usw., um seinen Kontext zu verstehen. „ball" schaut auf „robot" und „picked". Alle schauen gleichzeitig durch den Query-Key-Value-Mechanismus aufeinander.

Die Mathematik:

Dieser Prozess kann so geschrieben werden:

Wobei dₖ die Vektordimension und √dₖ ein Skalierungsfaktor ist, der verhindert, dass Zahlen bei der Skalarproduktberechnung zu groß werden. Die wichtigste Erkenntnis ist nicht die Formel — sondern diese: Jedes Wort berechnet, wie relevant jedes andere Wort für sich selbst ist, und sammelt dementsprechend Informationen.

_{Self-Attention: Wörter, die aufeinander achten}

Multi-Head Attention

Im vorherigen Abschnitt haben Sie gesehen, wie Self-Attention jedes Wort jedes andere Wort betrachten und Relevanzwerte berechnen lässt. Das Ergebnis ist ein neuer Satz von Vektoren, wobei jedes Wort bereits Kontext von den Wörtern gemischt hat, auf die es geachtet hat. Das ist мощьно, aber es hat eine Einschränkung: Ein einzelner Attention-Durchgang kann nur eine Art von Beziehung gleichzeitig erfassen.

Betrachten Sie „The robot picked up the ball because it was heavy." Die Verbindung zwischen „it" und „ball" (Pronomenreferenz) und die Verbindung zwischen „robot" und „picked" (Subjekt-Verb) sind zwei grundlegend verschiedene Arten von Beziehungen. Eine einzelne Attention-Berechnung kann eine entdecken, aber um mehrere Beziehungsarten gleichzeitig zu erfassen, benötigen Sie mehrere Attention-Durchgänge parallel.

Multi-Head Attention macht genau das. Die Idee ist einfach: Anstatt Attention einmal auszuführen, führen Sie sie mehrfach parallel aus, sodass jeder „Kopf" sein eigenes unabhängige Beziehungsmuster lernt.

Konkret hat jeder Kopf seinen eigenen Satz von Q, K, V Gewichtsmatrizen. Das bedeutet, dass für dasselbe Wort jeder Kopf es in andere Q, K, V Vektoren abbildet, wodurch es auf andere Wörter achtet. Vier Köpfe, die denselben Satz verarbeiten, sind wie vier Beobachter, die durch Filter verschiedener Farben schauen, jeder sieht einen anderen „Aspekt" des Satzes:

Satz: [The] [robot] [picked] [up] [the] [ball] [because] [it] [was] [heavy]

Kopf 1 (Grammatik):      robot ↔ picked   picked ↔ up
Kopf 2 (Nähe):          the ↔ robot      picked ↔ up
Kopf 3 (Semantik):      heavy ↔ ball     robot ↔ machine
Kopf 4 (Referenz):       it ↔ ball

Alle vier Köpfe laufen gleichzeitig, jeder erzeugt seine eigene Attention-Ausgabe. Die vier Ausgaben werden dann verkettet und durch eine lineare Transformation zu einer einzigen vereinheitlichten Ausgabe zusammengeführt:

   Kopf 1 (Grammatik)    Kopf 2 (Nähe)    Kopf 3 (Semantik)    Kopf 4 (Referenz)
        ↓                    ↓                  ↓                    ↓
   [Ausgabe 1]         [Ausgabe 2]       [Ausgabe 3]           [Ausgabe 4]
        ↓                    ↓                  ↓                    ↓
                      Verketten + Lineare Transformation
                                   ↓
                [Vereinheitlichte Ausgabe mit allen vier Informationstypen]

Diese vereinheitlichte Ausgabe trägt alle vier Dimensionen von Beziehungsinformationen gleichzeitig, bereit für die nächste Netzwerkschicht. Deshalb verstehen Transformer Sprache so tief — anstatt einen Satz aus einem einzigen Blickwinkel zu betrachten, analysieren sie ihn parallel aus mehreren Dimensionen.

Die Transformer-Blockstruktur

Sie verstehen nun den Kern von Multi-Head Attention: Durch mehrere parallele Attention-Köpfe kann jedes Wort den Satz gleichzeitig aus Grammatik-, Semantik- und Referenzperspektiven verstehen. Aber Attention allein ist nicht das ganze Bild. Ein Transformer-Modell wird durch das Stapeln vieler identischer Blöcke aufeinander aufgebaut — Llama 3.2 3B stapelt beispielsweise 28 davon. Diese Bausteine heißen Transformer-Blöcke, und jeder folgt dem gleichen internen Ablauf.

Phase 1 — Multi-Head Self-Attention. Wie Sie bereits wissen, betrachtet jedes Wort jedes andere Wort, berechnet Relevanzwerte durch Query-Key-Matching und sammelt Informationen von seinen relevantesten Nachbarn. Die Ausgabe ist eine neue Repräsentation für jedes Wort, die nun Kontextinformationen aus dem gesamten Satz enthält.

Phase 2 — Feed-Forward Network (FFN). Nachdem Attention jedes Wort mit Kontext angereichert hat, verarbeitet das FFN jedes Wort unabhängig. Stellen Sie es sich als kleines zweischichtiges neuronales Netz vor, dessen Aufgabe es ist zu fragen: „Jetzt, da ich den Kontext kenne, welche tieferen Merkmale kann ich aus diesem Wort extrahieren?" Das FFN speichert einen überraschenden Teil des tatsächlichen „Wissens" des Modells — es fungiert als Reasoning-Engine pro Wort.

Zwischen und um diese beiden Phasen herum sorgen zwei wichtige Sicherungsmechanismen dafür, dass das tiefe Netz trainierbar bleibt:

• Residual Connection (Add): Nach sowohl der Attention- als auch der FFN-Phase wird die ursprüngliche Eingabe zur Ausgabe hinzuaddiert. Das ist wie eine Sicherung an einem Gerät — selbst wenn ein Zwischenmodul ein unvollkommenes Ergebnis produziert, gehen die ursprünglichen Informationen nie verloren. Ohne diesen Mechanismus würde in einem Stapel von 28 Schichten das Trainingssignal (Gradient) während der Backpropagation auf nahezu Null abfallen, und das Modell würde überhaupt nicht lernen.

• Layer Normalization: Nach der Residualanpassung werden alle Werte auf einen stabilen Bereich neu skaliert. Stellen Sie es sich als Spannungsregler in einem elektrischen Schaltkreis vor — es verhindert, dass das Signal nach dem Durchlaufen von 28 aufeinanderfolgenden Verstärkungsstufen „explodiert".

Die entscheidende Erkenntnis ist, dass jeder aufeinanderfolgende Block eine tiefere Abstraktionsebene aufbaut. Frühe Blöcke erfassen grundlegende Syntax — welche Wörter Nachbarn sind, welche Wörter Subjekte oder Objekte sind. Mittlere Blöcke beginnen, Semantik zusammenzusetzen — „the ball" ist eine Nominalphrase, „was heavy" ist eine Beschreibung. Bei den letzten Blöcken hat das Modell ein reiches, mehrschichtiges Verständnis der gesamten Eingabe aufgebaut, bereit für präzise Next-Token-Vorhersage.

Encoder vs. Decoder

Die ursprüngliche Transformer-Architektur, die in „Attention Is All You Need" (2017) beschrieben wurde, hatte tatsächlich zwei Hälften, jede mit einer anderen Aufgabe. Das Verständnis dieser Aufteilung hilft zu erklären, warum moderne LLMs so aufgebaut sind, wie sie sind.

Der Encoder — der Leser. Die Aufgabe des Encoders ist es, einen gesamten Eingabesatz in einem Durchgang zu lesen und ein tiefes Verständnis jedes Wortes im Kontext aufzubauen. Er verwendet bidirektionale Attention — was bedeutet, dass jedes Wort jedes andere Wort betrachten kann, sowohl links als auch rechts davon. Da er den gesamten Satz auf einmal sieht, excodert der Encoder bei Verständnisaufgaben: Zusammenfassen eines Absatzes, Klassifizieren von Stimmungen oder Extrahieren des Haupthemas eines Dokuments. BERT ist das bekannteste Encoder-only-Modell, und Qwen und Gemma bieten ebenfalls Encoder-Varianten.

Der Decoder — der Schreiber. Die Aufgabe des Decoders ist grundlegend anders: Er generiert Text ein Token nach dem anderen, von links nach rechts. Er verwendet maskierte Self-Attention, was bedeutet, dass beim Vorhersagen des dritten Wortes er nur den ersten und zweiten Wort sehen kann — niemals die Zukunft. Diese erzwungene Blindheit ist unerlässlich: Wenn das Modell beim Blick auf die Antwort „schummeln" könnte, würde es nie lernen, selbst zu generieren. GPT, Llama und DeepSeek verwenden alle diese Decoder-only-Architektur.

Encoder-Decoder — beide zusammen. Einige Aufgaben erfordern sowohl Verständnis als auch Generierung: Das Übersetzen eines Satzes von Englisch nach Chinesisch erfordert beispielsweise zunächst das Lesen des gesamten englischen Satzes (Encoder) und dann die wortweise Generierung der chinesischen Übersetzung (Decoder). Whisper (das Spracherkennungsmodell, das Sie earlier in diesem Kapitel kennengelernt haben) verwendet diese kombinierte Architektur.

Der Grund, warum moderne LLMs wie Llama, GPT, Qwen und DeepSeek sich auf Decoder-only geeinigt haben, ist elegant einfach: Ein Decoder, der auf genügend Daten trainiert ist, lernt sowohl zu verstehen als auch Text zu generieren. Wenn er das nächste Token vorhersagt, muss er implizit alles verstehen, was davor kam — und dieses implizite Verständnis stellt sich als ausreichend für eine bemerkenswert breite Palette von Aufgaben heraus.

Positional Encoding: Die Wortreihenfolge kennen

In den vorherigen Abschnitten haben Sie gesehen, wie Self-Attention jedes Wort jedes andere Wort betrachten und Relevanzwerte berechnen lässt. Aber es gibt eine Feinheit, die leicht zu übersehen ist: Attention hat keine Ahnung, in welcher Reihenfolge die Wörter erscheinen. Es berechnet Relevanz zwischen allen Wortpaaren, aber die Berechnung ist völlig unabhängig von der Position.

Das bedeutet, wenn Sie „The cat chased the dog" und „The dog chased the cat" in das Modell eingeben, wären die Berechnungen aus Attention-Perspektive identisch — beide Sätze enthalten genau dieselben Wörter, nur in einer anderen Reihenfolge. Das ist offensichtlich inakzeptabel: Das Umstellen derselben Wörter ändert die Bedeutung völlig.

Positional Encoding ist genau darauf ausgelegt, dieses Problem zu lösen. Die Idee ist intuitiv: Bevor der Vektor jedes Wortes in die Attention eingeht, fügen Sie einen Positions-Fingerabdruck hinzu — einen mathematisch gestalteten Vektor, dessen einziger Zweck es ist zu sagen: „Dieses Wort befindet sich an dieser Position." Stellen Sie es sich wie eine Sitznummer in einem Kino vor: Die Sitznummer sagt Ihnen nichts über den Film, aber sie lässt Sie immer unterscheiden, ob Sie in Reihe 3 Platz 5 oder Reihe 10 Platz 2 sitzen.

In der Praxis wird der Fingerabdruck jeder Position mit Sinus- und Kosinusfunktionen generiert:

Position 0: "What"   + [0.00, 1.00, 0.00, 1.00, ...]
Position 1: "is"     + [0.84, 0.54, 0.84, 0.54, ...]
Position 2: "Jet"    + [0.91, -0.42, 0.91, -0.42, ...]

Warum Sinus und Kosinus? Weil benachbarte Positionen immer leicht unterschiedliche Fingerabdruckwerte produzieren, und diese Werte kontinuierlich sind (keine einfachen Integer 0, 1, 2). Das bedeutet, selbst wenn das Modell nur auf Sätzen bis zu 100 Positionen trainiert wurde, kann es auf 200-Positionen-Sätze verallgemeinern — der „Rhythmus" des Positional Encoding ist vorhersagbar und regelmäßig.

Moderne Modelle wie Llama und Qwen sind auf RoPE (Rotary Position Embedding) umgestiegen. Anstatt einen Positionswert zu addieren, rotiert RoPE den Vektor jedes Wortes im hochdimensionalen Raum um einen Winkel, der durch seine Position bestimmt wird. Dies bringt einen zusätzlichen Vorteil: der relative Abstand zwischen zwei Wörtern (wie viele Positionen sie voneinander entfernt sind) spiegelt sich direkt im Winkelunterschied ihrer rotierten Vektoren wider, nicht nur in ihren absoluten Positionen. Dies macht das Modell stabiler und flexibler beim Umgang mit Texten unterschiedlicher Länge.

Schritt für Schritt: Wie ein Transformer Text verarbeitet

Jetzt, da Sie alle Kernkomponenten eines Transformers gelernt haben, verfolgen wir ein vollständiges Beispiel, um zu sehen, wie sie zusammenarbeiten. Wir folgen der Frage: „Was ist Jetson?"

Schritt 1 — Tokenisierung Der rohe Eingabetext wird in Tokens zerlegt (typischerweise Subwort-Fragmente):

Schritt 2 — Embedding Jedes Token wird in einen hochdimensionalen numerischen Vektor konvertiert. Llama 3.2 3B erzeugt beispielsweise für jedes Token einen 3072-dimensionalen Vektor:

"What" → [0.23, -0.45, 0.67, ..., 0.12]   (3072 Zahlen)
"is"   → [0.12, 0.89, -0.34, ..., 0.56]
"Jet"  → [0.78, 0.11, 0.56, ..., -0.33]
"son"  → [0.45, -0.23, 0.91, ..., 0.78]
"?"    → [0.67, 0.34, -0.12, ..., 0.45]

Schritt 3 — Positional Encoding hinzufügen Ein Positional-Encoding-Vektor wird zur Embedding jedes Tokens addiert, was dem Modell ein Bewusstsein für die Wortreihenfolge gibt, wie im vorherigen Abschnitt detailliert erklärt.

Schritt 4 — Self-Attention (über N Schichten wiederholt) Das Modell berechnet Attention-Scores zwischen allen Tokens, um Beziehungen zu finden:

"What" achtet am meisten auf:   "?" (0.5), "Jet" (0.4), "is" (0.3)
"is"  achtet am meisten auf:   "What" (0.4), "Jetson" (0.5)
"Jet" achtet am meisten auf:   "son" (0.8), "is" (0.3)

Nach der Attention enthält die Repräsentation jedes Tokens nun Informationen von den Wörtern, auf die es geachtet hat.

Schritt 5 — Feed-Forward Network Die angereicherte Repräsentation jedes Tokens wird unabhängig durch ein kleines neuronales Netz verarbeitet, um höherrangige Merkmale zu extrahieren.

Schritt 6 — Wiederholen (N gestapelte Schichten) Schritte 4 und 5 wiederholen sich viele Male (28 Mal für Llama 3.2 3B). Jede Schicht baut ein tieferes Verständnisniveau auf:

• Frühe Schichten erfassen grundlegende Syntax und lokale Beziehungen (Wortreihenfolge, Kollokationen)
• Mittlere Schichten assemblieren Semantik („Jetson" ist ein Substantiv, das sich auf eine Computing-Plattform bezieht)
• Späte Schichten bilden ein hochrangiges, aufgabenspezifisches Verständnis, bereit für Vorhersagen

Schritt 7 — Ausgabevorhersage Die Repräsentation des letzten Tokens wird auf das gesamte Vokabular projiziert, und das Token mit der höchsten Wahrscheinlichkeit wird als Vorhersage des Modells für das nächste Wort ausgewählt:

{"NVIDIA": 0.92, "AI": 0.03, "a": 0.02, ...}
→ Vorhersage: "NVIDIA" (höchste Wahrscheinlichkeit)

Wichtige Transformer-Konzepte

Skalierungsgesetze: Warum größere Modelle klüger sind

Eine der bemerkenswertesten Entdeckungen in der KI-Forschung ist, dass die Transformer-Leistung Skalierungsgesetzen folgt — vorhersagbare Verbesserungen, wenn Sie den Maßstab des Modells, der Daten oder des Compute-Budgets erhöhen. Diese Entdeckung erklärt den raschen Sprung in der KI-Fähigkeit im letzten Jahrzehnt.

Skalierungsgesetze beinhalten drei Schlüsseldimensionen:

• Mehr Parameter (Modellgröße): Das Erhöhen der Anzahl der Parameter — von 3 Milliarden auf 70 Milliarden — steigert die Tiefe des Verständnisses und die Ausdrucksfähigkeit des Modells erheblich. Größere Modelle können subtilere Muster erfassen und mehr Wissen speichern.

• Mehr Trainingsdaten: Ein größeres Modell, das auf unzureichenden Daten trainiert wurde, ist wie ein Großer Esser mit einer kleinen Mahlzeit — es kann sein Potenzial nicht erreichen. Forschung zeigt, dass Modellgröße und Trainings-Token-Anzahl idealerweise zusammen skalieren sollten, ungefähr im Verhältnis 1:1.

• Mehr Compute: Das Training größerer Modelle erfordert mehr GPU-Zeit und Budget. Große KI-Labore können Hunderte von Millionen Dollar für einen einzigen Trainingslauf ausgeben, weshalb ihre proprietären Modelle weit über das hinausgehen, was Open-Source-Projekte erreichen können.

Da alle drei Dimensionen zusammen skaliert sind, hat sich das Feld vom ursprünglichen Transformer 2017 (nur 110 Millionen Parameter) zu heutigen Modellen mit 70+ Milliarden Parametern entwickelt. Für Ihr Jetson-Gerät ist die wichtigere Implikation diese: Selbst Modelle mit 1 bis 3 Milliarden Parametern besitzen solides Verständnis und Generierungsfähigkeiten — mehr als genug, um praktische KI-Dienste am Edge bereitzustellen.

Modellgrößen und lokale Bereitstellung

Nicht alle LLMs haben dieselbe Größe. Das Verständnis des Modellmaßstabs ist entscheidend für die Wahl des richtigen Modells für Ihre Hardware — die Parameteranzahl bestimmt direkt die Speicheranforderungen und Inferenzgeschwindigkeit:

Für Jetson-Geräte liegt der Sweet Spot bei 1B bis 8B. Modelle im 1B–3B-Bereich liefern sehr reibungslose interaktive Erfahrungen auf dem Orin Nano, während 7B–8B-Modelle zuverlässig auf dem 16GB Orin NX laufen.

Tipp: Nach der Quantisierung (nächster Abschnitt) sinkt die Speichernutzung drastisch. Ein 7B-Modell bei INT4-Quantisierung benötigt nur etwa 3,5GB Speicher — klein genug, um auf praktisch jedem Jetson-Gerät zu laufen.

Beliebte Open-Source LLM-Familien

Hier sind die wichtigsten Open-Source LLM-Familien, die alle Varianten anbieten, die gut auf Jetson laufen:

Llama (Meta)

Metas Open-Source LLM — derzeit die aktivste Community und das reichste Ökosystem.

• Llama 3.2 gibt es in den Größen 1B und 3B, entwickelt für Edge-Geräte mit exzellenter Balance aus Leistung und Fußabdruck
• Unterstützt mehrere Sprachen; die Community bietet eine breite Palette von Fine-Tuning-Varianten
• Bestunterstützte Modellfamilie in den Ollama- und llama.cpp-Ökosystemen

Qwen (Alibaba Cloud)

Alibabas Open-Source LLM, führend bei Open-Source-Modellen in chinesischer Sprachfähigkeit.

• Qwen3.5 erstreckt sich von 0.8B bis 122B Parametern; die 0.8B-Variante ist ideal für ressourcenbeschränkte Edge-Szenarien
• Ausgezeichnete bilinguale Unterstützung in Chinesisch und Englisch
• Unterstützt nativ Tool-Nutzung und Chain-of-Thought-Reasoning

DeepSeek

Eine auf Reasoning spezialisierte Modelfamilie, die in Mathe, Codierung und logischen Aufgaben excodert.

• DeepSeek-R1 bietet destillierte Versionen (1.5B, 7B, 8B), die auf Reasoning-Benchmarks signifikant besser abschneiden als Modelle gleicher Größe
• Gut geeignet für Edge-KI-Anwendungen, die präzise logische Analysen erfordern
• Die 7B-Destillation ist eines der besten Preis-Leistungs-Reasoning-Modelle auf Jetson

Phi (Microsoft)

Die kompakte Modelfamilie von Microsoft, aufgebaut auf der Philosophie „weniger Parameter, höhere Qualität".

• Phi-4-mini hat nur 3,8 Milliarden Parameter, erreicht oder übertrifft aber viele 7B-Modelle bei Standard-Benchmarks
• Speziell für ressourcenbeschränkte Umgebungen entwickelt — eine natürliche Passform für Edge-Bereitstellung
• Trainiert auf hochqualitativen „Lehrbuch-Klasse"-Daten unter Verwendung einer distintken Trainingsmethodik

Gemma (Google)

Googles leichtgewichtige Open-Source-Modellfamilie, von 1B bis 27B Parameter.

• Gemma 4 in seinen 2B- und 4B-Varianten läuft sehr gut auf Jetson
• Starke Leistung sowohl bei Sprachverständnis als auch bei Codegenerierung
• Verfügbar sowohl in vorab trainierten als auch in instruktionsfeinabgestimmten Versionen

Quantisierung: Modelle kleiner machen

Um ein Modell mit 7 Milliarden Parametern auf einem Edge-Gerät wie einem Jetson reibungslos auszuführen, müssen Sie Quantisierung anwenden — Reduzierung der numerischen Präzision der internen Gewichte des Modells, „perfekt aber schwer" hochpräzise Zahlen gegen „grob aber gut genug" niedrigpräzise eintauschen, wodurch die Speichernutzung drastisch sinkt.

Intuitiv ist es wie das Komprimieren eines 4K-Bildes auf 720p: Der Inhalt wird vollständig erhalten, aber die Dateigröße schrumpft vielfach. Für ein 7B-Modell sind die Speicherersparnisse bei verschiedenen Präzisionsstufen erheblich:

INT4-Quantisierung ist das Arbeitspferd der Edge-Bereitstellung: Ein 7B-Modell passt in 3,5GB Speicher, klein genug, um auf den meisten Jetson-Geräten reibungslos zu laufen.

Gängige Quantisierungsformate

Verschiedene Inferenz-Engines unterstützen verschiedene quantisierte Dateiformate, jedes mit eigenen Stärken:

• GGUF (llama.cpp-Ökosystem): Das dominante Format für lokale Inferenz — nativ unterstützt von Ollama und llama.cpp, selbstbeschreibend und sofort einsatzbereit
• SafeTensors (HuggingFace-Ökosystem): Sicherer (führt beim Laden keinen beliebigen Code aus) und das Standardformat für vLLM und HuggingFace-basierte Pipelines
• AWQ (Activation-aware Weight Quantization): Für GPU-Inferenz optimiert, häufig mit vLLM verwendet und der beste performer für hochdurchsatzige Szenarien

Überblick über Inferenz-Frameworks

Sobald ein Modell trainiert ist, benötigen Sie ein Inferenz-Framework, um es tatsächlich auf Ihrem Jetson auszuführen. Dieses Kapitel behandelt drei Mainstream-Frameworks — jedes für eine andere Phase der Reise entwickelt, vom Anfänger bis zur Produktionsbereitstellung.

Ollama — Der einfachste Weg zu beginnen

Ollama ist der schnellste Weg, ein LLM lokal auszuführen. Einzeilige Installation, eingebaute Modelldownloads und -verwaltung — es funktioniert out of the box und ist sehr anfängerfreundlich:

# Ollama installieren
curl -fsSL https://ollama.com/install.sh | sh

# Modell ausführen (erster Start lädt automatisch herunter)
ollama run llama3.2:3b

Am besten für: Erste LLM-Erfahrung, schnelles Prototyping, Lernen und Erkunden

llama.cpp — Die präziseste Kontrolle

llama.cpp ist eine leichtgewichtige C/C++-Implementierung, die Modelle effizient auf CPU und GPU ausführt. Seine Stärken sind minimaler Ressourcenverbrauch und breite Unterstützung für quantisierte Formate — was es zur bevorzugten Wahl für ressourcenbeschränkte Edge-Geräte macht:

# Klonen und bauen
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp && make -j$(nproc)

# Inferenz ausführen
./llama-cli -m model.gguf -p "Hello, how are you?"

Am besten für: Szenarien, die maximale Kontrolle und Leistungsoptimierung erfordern; leichtgewichtige Edge-Bereitstellung

vLLM — Produktionsreife Bereitstellung

vLLM ist ein Hochleistungs-Inferenz-Serving-Framework für Produktionsbereitstellungen. Es unterstützt erweiterte Funktionen wie PagedAttention (Speicherseitenverwaltung, die Nebenläufigkeit drastisch steigert) und kontinuierliches Batching, mit einer OpenAI-kompatiblen API:

# vLLM installieren
pip install vllm

# API-Server starten
vllm serve meta-llama/Llama-3.2-3B --host 0.0.0.0 --port 8000

Am besten für: Produktions-API-Serving, Hochnebenläufigkeit, hochdurchsatzige Szenarien

Vergleichstabelle

Jedes Framework hat seine Stärken. Die richtige Wahl hängt von Ihren spezifischen Anforderungen ab:

Was Sie in diesem Kapitel lernen werden

Der Rest dieses Kapitels führt Sie durch das Einrichten von LLMs auf Ihrem Jetson und den Aufbau einer vollständigen Sprach-KI-Anwendung:

Modul 5.2: Erste Schritte mit Ollama

Installieren Sie Ollama von Grund auf auf Ihrem Jetson, pullen Sie Ihr erstes Modell und führen Sie ein lokales Gespräch mit einer KI — vollständig offline.

Modul 5.3: LLMs mit llama.cpp ausführen

Gehen Sie tiefer unter die Haube: Bauen Sie llama.cpp aus der Quelle, lernen Sie, GGUF-quantisierte Modelle zu laden und auszuführen, und meistern Sie feinkörnige Optimierungstechniken für Edge-Geräte.

Modul 5.4: Hochleistungs-Inferenz mit vLLM

Richten Sie eine produktionsreife LLM-Serving-Infrastruktur mit einer OpenAI-kompatiblen API ein und verwandeln Sie Ihren Jetson in ein lokales KI-Backend.

Modul 5.5: Jetson Examples Schnellstart

Stellen Sie LLMs mit einem einzigen Befehl unter Verwendung von vorab erstellten Docker-Containern aus dem jetson-examples-Repository bereit und überspringen Sie die gesamte mühsame Umgebungseinrichtung.

Modul 5.6: ASR + LLM + TTS-Pipeline

Verketten Sie Spracherkennung (ASR), ein Large Language Model (LLM) und Text-zu-Sprache (TTS) zu einem vollständigen Sprach-KI-Assistenten — alles läuft offline auf Ihrem Jetson.

Übung: Bewerten Sie Ihre Hardware

Bevor Sie zu den Bereitstellungsmodulen übergehen, überprüfen Sie die Hardwarefähigkeiten Ihres Jetson-Geräts, damit Sie das richtige Modell auswählen können:

# Verfügbaren Speicher prüfen
free -h

# GPU-Modell und VRAM prüfen
nvidia-smi

# JetPack-Version prüfen (bestimmt CUDA- und TensorRT-Versionen)
dpkg -l | grep nvidia-jetpack

# Verfügbaren Speicherplatz prüfen
df -h /

Notieren Sie Ihre Ergebnisse:

• Gesamter RAM: ______ GB
• GPU VRAM: ______ MB
• Freier Speicher: ______ GB
• JetPack-Version: ___________

Mit diesen Zahlen können Sie bestimmen, welche Modellgrößen bequem auf Ihrem Gerät laufen werden.

Praxis: Objekterkennung mit einem Vision-Language Model

Jetzt, da Sie verstehen, wie LLMs Text verarbeiten, sehen wir uns ein Vision-Language Model (VLM) in Aktion an — eines, das Bilder sehen und beschreiben kann, was darauf ist. Das folgende Beispiel verwendet Ollama, um ein lokales Bild an ein VLM zu senden, das Objektnamen und Pixelkoordinaten zurückgibt. OpenCV zeichnet dann beschriftete Begrenzungsrahmen auf das Bild.

Voraussetzungen

pip install ollama opencv-python Pillow
ollama pull llava:7b   # nur beim ersten Mal, ~4,7GB

Ausführen

cd code/
python vlm_object_detector.py --image your_photo.jpg
python vlm_object_detector.py --image photo.jpg --model minicpm-v --output results.jpg

VLMs sind keine spezialisierten Detektoren wie YOLO (Kapitel 4) — die Genauigkeit der Begrenzungsrahmen variiert je nach Modell. Der Zweck dieser Übung ist es, Ihnen praktische Erfahrung mit derselben tokenbasierten Reasoning hinter LLMs zu geben, erweitert auf Bilder durch multimodale Modelle — Text und Vision folgen demselben Pfad inside eines Transformers.

Häufige Fragen

Kann ich ChatGPT auf Jetson ausführen?

Nicht genau. ChatGPT ist OpenAIs proprietäres System, das auf massiven Serverclustern läuft. Sie können jedoch Open-Source-Modelle mit ähnlichen Konversationsfähigkeiten lokal auf Ihrem Jetson ausführen, mit dem zusätzlichen Vorteil der vollständigen Datenprivatsphäre.

Brauche ich Internetzugang, um LLMs auf Jetson zu verwenden?

Nach dem initialen Modelldownload können Sie LLMs vollständig offline ausführen. Dies ist einer der Hauptvorteile für Edge-Bereitstellungen in Gebieten mit begrenzter Konnektivität.

Wie lange dauert es, eine Antwort zu generieren?

Die Antwortzeit hängt von der Modellgröße und Ihrer Hardware ab. Auf einem Jetson Orin NX 16GB mit einem 3B-Modell sollten Sie 10-30 Tokens pro Sekunde erwarten — schnell genug für Echtzeit-Konversationen.

Referenzen

• Attention Is All You Need (Original-Transformer-Paper)
• The Illustrated Transformer - Visueller Leitfaden von Jay Alammar
• https://huggingface.co/blog/Esmail-AGumaan/attention-is-all-you-need
• Hugging Face LLM-Kurs - NLP- und LLM-Grundlagen
• Llama 3.2 Modellkarte
• Qwen3-Dokumentation
• NVIDIA Jetson AI Lab - KI-Entwicklungsressourcen für Jetson

Weiter: Fahren Sie mit Modul 5.2: Erste Schritte mit Ollama fort, um Ihr erstes LLM auf Jetson auszuführen!