KRR Chat: Ein Sprachmodell aus Eigenwerten

Im Beitrag Eigenwerte & KI haben wir eine Kette gebaut: von linearer Regression über Kernel-Methoden bis zu neuronalen Netzen – alles verbunden durch Eigenwerte. Am Ende stand eine Live-Demo: der KRR Chat, ein Sprachmodell, das ohne neuronales Netz auskommt.

Dieser Beitrag ist der technische Deep-Dive. Wir schauen uns jede Komponente des KRR Chats an: die Architektur, die Pipeline, den vollständigen Quellcode – und die ehrlichen Grenzen. Wenn du den Hauptbeitrag gelesen hast, wirst du hier die Theorie in laufendem Code wiederfinden. Wenn nicht – kein Problem: Dieser Beitrag funktioniert auch eigenständig.

Kapitel 1

Das Dual-Modell: Retrieval + Generation

Der KRR Chat besteht aus zwei unabhängigen Systemen, die zusammenarbeiten – ähnlich wie ein Mensch, der zuerst in einem Buch nachschlägt und dann in eigenen Worten antwortet.

Warum zwei Systeme?

Ein einzelnes KRR-Modell auf allen 805 Sätzen scheitert an der Kapazitätsgrenze: 1820 verschiedene Wörter auf 256 Hash-Buckets bedeuten durchschnittlich 7 Kollisionen pro Bucket. Das Modell kann „eigenvalue“ nicht von „convergence“ unterscheiden, wenn beide auf denselben Hash fallen.

Die Lösung: Arbeitsteilung. Das Retrieval-System liefert den thematisch passenden Kontext (breites Wissen, 805 Sätze). Das Generationsmodell erzeugt flüssige Fortsätzungen (tiefes Wissen, 104 Sätze, aber mit nur 4 Kollisionen pro Bucket). In der KI-Forschung heißt dieses Muster RAG – Retrieval-Augmented Generation. Auch große Sprachmodelle wie GPT-4 und Claude nutzen RAG, um aktuelles Wissen einzubinden.

Kapitel 2

Die Pipeline: Von der Frage zur Antwort

Wenn du „What are eigenvalues?“ fragst, passiert Folgendes:

1. Keyword-Extraktion: Stoppwörter (what, are, the, is, ...) werden entfernt. Übrig bleibt: ["eigenvalues"]
2. Retrieval: Alle 805 Sätze werden nach diesem Keyword durchsucht. Exakter Match = 5 Punkte, Teilmatch (z.B. „eigenvalue“ in „eigenvalues“) = 2 Punkte. Duplikate werden entfernt. Die besten 2 Sätze werden cyan angezeigt.
3. Unsichtbares Seeding: Die letzten 5 Wörter des letzten Retrieval-Satzes werden als Kontext für das Generationsmodell übernommen. Das ist der entscheidende Übergang: Retrieval liefert den Startpunkt, Generation führt weiter.
4. KRR-Generation, Wort für Wort: Aus dem 5-Wort-Kontext berechnet das Modell:
   • Feature-Vektor \(\mathbf{x}\) durch Wort-Hashing (128 Buckets × 5 Positionen + 3 Bigram-Hashes = 1024 Dimensionen)
   • Random Fourier Features: \(\mathbf{z} = \sqrt{2/D}\,\cos(\mathbf{x}\boldsymbol{\omega} + \mathbf{b})\) mit \(D = 1536\)
   • Nächstes Wort: \(\hat{y} = \arg\max_w\, \mathbf{z}^\top \mathbf{W}_{:,w}\)
   Dieses Wort wird angehängt, der Kontext verschiebt sich um eine Position, und der Prozess wiederholt sich.

Gesprächsgedächtnis

Der KRR Chat hat ein einfaches Gedächtnis: Bei Folgefragen (z.B. „Tell me more“ ohne neues Keyword) wird kein neues Retrieval ausgelöst. Stattdessen generiert das Modell ab dem letzten Wort der vorherigen Antwort weiter. So entsteht ein natürlicher Fluss – die Antwort knüpft dort an, wo sie aufgehört hat.

Kapitel 3

Die drei Farben: Memorieren vs. Generalisieren

Jedes Wort in der Antwort wird farblich markiert – und genau hier wird es spannend. Die Farben zeigen ehrlich, woher jedes Wort kommt:

Was die Farben verraten

Typischerweise sind 60–80% der generierten Wörter grün (verbatim) und 20–40% orange (generalisiert). Was bedeutet das?

Ein KRR-Modell mit 505 Wörtern Vokabular memoriert hauptsächlich. Es hat die 104 Trainingsätze weitgehend auswendig gelernt und kann sie reproduzieren. Aber an den Nahtstellen – dort, wo ein Retrieval-Satz endet und die Generation übernimmt, oder wo das Modell zwischen zwei gelernten Sätzen navigiert – entstehen orange Wörter. Das sind Momente, in denen der Kernel-Raum interpoliert: Der aktuelle Kontext liegt zwischen zwei Trainingspunkten, und das Modell wählt ein Wort, das in dieser exakten Kombination nie trainiert wurde.

Diese Ehrlichkeit ist Absicht. Große Sprachmodelle wie GPT-4 generalisieren elegant – aber man sieht nicht, wann sie memorieren und wann sie interpolieren. Der KRR Chat macht diesen Unterschied sichtbar.

Kapitel 4

Der Quellcode: Drei Funktionen

Der gesamte KRR Chat besteht aus drei Funktionen. Hier ist der vollständige Inferenz-Code – lesbar, kommentiert, ohne Tricks. Der komplette Quellcode umfasst ~120 Zeilen JavaScript.

1. encode() – Wörter in Zahlen verwandeln

Die Feature-Abbildung \(\phi(x)\): Jedes Wort wird per Hash-Funktion auf einen Index abgebildet. Die Position im Kontext bestimmt das Gewicht – spätere Wörter zählen stärker, weil sie näher am vorherzusagenden Wort liegen.

// Wort → Hash-Index (0..127). Jedes Wort bekommt einen "Fingerabdruck".
function hash(word) {
  var h = 0;
  for (var i = 0; i < word.length; i++)
    h = (h * 31 + word.charCodeAt(i)) >>> 0;
  return h % 128;  // 128 Buckets
}

// Kontext (5 Wörter) → Feature-Vektor (1024 Dimensionen)
// Jedes Wort belegt eine Position × Hash-Bucket.
// Positionsgewichtung: spätere Wörter zählen stärker.
function encode(context) {
  var features = new Float32Array(1024);  // 5×128 + 3×128
  for (var pos = 0; pos < 5; pos++) {
    var weight = 0.4 + 0.6 * (pos / 4);  // 0.4 → 1.0
    features[pos * 128 + hash(context[pos])] += weight;
  }
  return features;
}

Mathematik: Das ist \(\phi(x)\) – eine Feature-Abbildung, die Wörter in einen hochdimensionalen Raum einbettet. Statt jedes Wort als One-Hot-Vektor darzustellen (was bei 505 Wörtern Vokabular 505 Dimensionen pro Position bräuchte), komprimieren wir per Hash auf 128 Dimensionen. Hash-Kollisionen sind unvermeidlich (505 Wörter auf 128 Buckets ≈ 4 Kollisionen/Bucket), aber das Modell lernt trotzdem – solange die Kollisionsrate niedrig genug ist.

2. rff() – Den Kernel approximieren

Die Random Fourier Features nach Rahimi & Recht (2007): Eine Cosinus-Transformation, die das Skalarprodukt im transformierten Raum zum Gauß-Kernel macht.

// φ(x) → z(x) mittels Random Fourier Features
// z(x) = √(2/D) · cos(x·ω + b)
// Danach gilt: z(x)ᵀz(x') ≈ k(x,x') = exp(-‖x-x'‖²/2σ²)
function rff(features) {
  var z = new Float32Array(1536);   // D = 1536
  var scale = Math.sqrt(2.0 / 1536);
  for (var j = 0; j < 1536; j++) {
    var dot = 0;
    for (var k = 0; k < 1024; k++)
      dot += features[k] * omega[k * 1536 + j]; // ω: zufällig, fixiert
    z[j] = Math.cos(dot + bias[j]) * scale;
  }
  return z;  // Kernel-Raum-Vektor
}

Mathematik: Die Matrix \(\boldsymbol{\omega}\) enthält Zufallswerte aus \(\mathcal{N}(0, 1/\sigma^2)\). Sie wird einmal gezogen (mit festem Random Seed für Reproduzierbarkeit) und nie verändert – sie ist kein gelernter Parameter. Der Cosinus sorgt dafür, dass \(\mathbf{z}(x)^\top\mathbf{z}(x')\) den Gauß-Kernel \(k(x,x') = \exp(-\|x-x'\|^2/2\sigma^2)\) approximiert. Je größer \(D\), desto besser die Approximation.

Warum \(\sigma = 1{,}5\) und \(\lambda = 10^{-6}\)? Der Kernel-Parameter \(\sigma\) steuert die „Schärfe“ der Ähnlichkeit: kleines \(\sigma\) bedeutet nur sehr nahe Kontexte gelten als ähnlich (Memorisierung), großes \(\sigma\) bedeutet auch entfernte Kontexte beeinflussen sich (Generalisierung). \(\sigma = 1{,}5\) ist ein empirisch gewählter Kompromiss – gefunden durch Testen auf dem Trainingskorpus mit dem Ziel, die Top-1 Accuracy zu maximieren. Der Regularisierungsparameter \(\lambda = 10^{-6}\) ist bewusst klein: unser Trainingsset ist dicht genug, dass starke Regularisierung die Vorhersagequalität verschlechtern würde. In größeren Modellen wäre eine systematische Kreuzvalidierung üblich – bei 2000+ handkuratierten Paaren genügt empirisches Tuning.

3. predict() – Das nächste Wort bestimmen

Die Vorhersage: Eine einzige Matrix-Vektor-Multiplikation. Kein Softmax, kein Attention, kein Feedforward-Netz.

// Kontext → nächstes Wort
// scores = z(x)ᵀ · W   (W wurde offline per KRR gelernt)
function predict(contextWords) {
  var z = rff(encode(contextWords));
  var scores = new Float32Array(505);  // ein Score pro Wort

  // Matrix-Vektor-Multiplikation: scores = zᵀW
  for (var j = 0; j < 1536; j++)
    for (var v = 0; v < 505; v++)
      scores[v] += z[j] * W[j * 505 + v];

  return argmax(scores);  // Wort mit höchstem Score
}

Mathematik: Die Gewichtsmatrix \(\mathbf{W}\) wurde offline berechnet durch das Ridge-Regression-System: \(\mathbf{W} = (\mathbf{Z}^\top\mathbf{Z} + \lambda\mathbf{I})^{-1}\mathbf{Z}^\top\mathbf{Y}\). Dabei ist \(\mathbf{Z}\) die Matrix aller RFF-Vektoren der Trainingsdaten, \(\mathbf{Y}\) die One-Hot-Matrix der Zielwörter und \(\lambda\) der Regularisierungsparameter. Im Browser findet nur noch die Multiplikation \(\mathbf{z}^\top\mathbf{W}\) statt – eine einzige Matrixoperation pro Wort.

Das Zusammenspiel

Die drei Funktionen bilden eine Pipeline:

Der gesamte Chatbot ist diese Pipeline in einer Schleife – plus eine Keyword-Suche, die den Startpunkt bestimmt. Jede Iteration läuft in unter einer Millisekunde, WebGPU-beschleunigt sogar in Mikrosekunden.

Kapitel 5

Warum Float64? Die Präzisions-Lektion

Ein natürlicher erster Ansatz: ein einziges KRR-Modell auf dem gesamten 805-Satz-Corpus trainieren – direkt im Browser. Das haben wir versucht. Und es scheitert lehrreich.

Das Browser-Training-Desaster

Drei Probleme türmen sich auf:

Die Lösung: Offline trainieren, online vorhersagen

Training findet offline mit Float64 (NumPy) statt – volle 15 Dezimalstellen Präzision. Die Gewichtsmatrix \(\mathbf{W}\) wird dann als Float16 komprimiert gespeichert und im Browser geladen.

Inferenz läuft im Browser mit Float32 – für eine einzige Matrix-Vektor-Multiplikation reicht das völlig aus. Die numerische Instabilität entsteht nur beim Lösen des linearen Systems, nicht beim Anwenden der Lösung.

Kapitel 6

Was das Modell kann – und was nicht

Ehrlichkeit ist eine der wichtigsten Tugenden in der KI-Forschung. Hier ist eine nüchterne Einschätzung:

Das kann der KRR Chat

• Gelernte Sätze reproduzieren: Fragen zu Eigenwerten, Kernel-Methoden, PageRank, Quantenmechanik – alle Themen, die in den 104 Trainingsätzen abgedeckt sind, werden flüssig und korrekt beantwortet.
• Zwischen Themen navigieren: Durch das Retrieval-System kann der Chat thematisch passende Startpunkte finden und dann per Generation weiterführen.
• Transparenz zeigen: Die Farbcodierung macht sichtbar, was ein Sprachmodell tut – eine pädagogische Qualität, die kein großes LLM bietet.

Das kann der KRR Chat nicht

• Wirklich neuen Inhalt generieren: Das Modell interpoliert im Kernel-Raum zwischen gelernten Punkten. Es kann keine Erklärungen erfinden, die nicht (zumindest in Fragmenten) in den Trainingsdaten enthalten sind.
• Out-of-Distribution-Fragen beantworten: Frage nach „Pythagoras“ oder „Shakespeare“ – das Retrieval findet nichts, und die Generation hat keinen sinnvollen Startpunkt.
• „Ich weiß nicht“ sagen: Statt Unwissenheit einzugestehen, generiert das Modell immer weiter – auch wenn der Kontext keinen Sinn mehr ergibt.

Das Stoppwort-Problem

An Übergängen zwischen Themen – wenn das Modell einen gelernten Satz beendet hat und keinen passenden Folgesatz findet – kippt die Ausgabe manchmal in Stoppwort-Kauderwelsch: „the the of and the is a...“. Das passiert, weil Stoppwörter die häufigsten Wörter im Vokabular sind und bei unsicherem Kontext den höchsten Score bekommen.

Der Fix: Sobald das Modell drei aufeinanderfolgende Stoppwörter generiert, wird die Generation gestoppt und ein neues Retrieval ausgelöst (Re-Seeding). Das unterbricht das Kauderwelsch und findet einen neuen thematischen Ankerpunkt.

Kapitel 7

Die Verbindung zurück zur Theorie

Jede Komponente des KRR Chats entspricht einem Konzept aus dem Eigenwerte & KI-Beitrag. Hier die vollständige Zuordnung:

Der KRR Chat ist damit nicht nur eine Demo – er ist ein lebendes Lehrbuch, in dem jede Zeile Code einem mathematischen Konzept entspricht. Die Feature-Abbildung ist Kapitel 6. Die Regularisierung ist Kapitel 5. Die numerische Instabilität ist Kapitel 3. Alles hängt zusammen.

Und das ist die eigentliche Pointe: Ob ein Modell 505 Wörter Vokabular hat oder 50.000 – die mathematische Struktur ist dieselbe. Eigenwerte, Kernels, Regularisierung. Die Kette hält.

Vom Prototyp zum Chatbot: Der KRR Chat wird Kalle

Der KRR Chat oben ist ein Prototyp: 104 englische Sätze, reine Fließtext-Generation, keine Dialogstruktur. Er beweist, dass KRR Sprache modellieren kann. Aber ein Prototyp ist noch kein Chatbot.

Also haben wir die Frage gestellt: Was passiert, wenn man dasselbe mathematische Prinzip auf einen echten Dialog anwendet? Das Ergebnis heißt Kalle – ein deutschsprachiger Chatbot mit denselben drei Gleichungen (RFF, KRR, BoW+IDF), aber einem völlig anderen Corpus: 2113 kuratierte Dialog-Paare statt 104 Fachtext-Sätze. Die Unterschiede zeigen, welche Parameter bei Sprachmodellen wirklich zählen:

Die Schlüssel-Erkenntnis: Kalle hat eine radikale Architektur-Transformation durchgemacht – und die Lektionen sind lehrreich für jeden der über KI-Systeme nachdenkt.

Häufige Fragen

Was ist der Unterschied zwischen dem KRR Chat und ChatGPT?

ChatGPT nutzt ein neuronales Netz mit Milliarden von Parametern und Attention-Mechanismen. Der KRR Chat nutzt Kernel Ridge Regression mit einer einzigen Gewichtsmatrix (1536 × 505 = ~780.000 Parameter). Beide lösen dieselbe Aufgabe – „gegeben Kontext, sage das nächste Wort vorher“ – aber mit völlig unterschiedlichen mathematischen Werkzeugen. Der KRR Chat macht durch die Farbcodierung sichtbar, was das Modell memoriert und was es generalisiert.

Warum antwortet der KRR Chat auf Englisch?

Die 104 Trainingsätze und der Retrieval-Corpus von 805 Sätzen sind in Englisch verfasst, weil die mathematische Fachsprache überwiegend englisch ist. Das Modell hat kein Verständnis von „Sprache“ – es hat nur gelernt, welches englische Wort nach welchem Kontext wahrscheinlich folgt. Eine deutsche Version würde einfach deutsche Trainingsätze erfordern.

Kann man den KRR Chat mit mehr Daten trainieren?

Ja – und Kalle beweist es: von 57 auf 2113 Dialog-Paare. Aber die Reise hat gezeigt: Qualität schlägt Quantität. Mit 4301 programmatisch generierten Paaren fiel die Accuracy auf 35%. Erst radikale Kuratierung (weniger Paare, dafür jedes mit Zweck) brachte die Qualität zurück. Der Wechsel von Hash-Encoding zu Word2Vec-Embeddings löste das Kollisions-Problem. Der Schlüssel ist nicht „mehr Daten“ sondern „bessere Daten“ – eine Lektion die auch für große Sprachmodelle gilt.