Eigenwerte & KI

Kapitel 1

Das Glasperlenspiel

Jedes Mal, wenn du eine Google-Suche startest, löst ein Computer ein Eigenwertproblem. Er berechnet, welche Webseite die wichtigste ist – und die Antwort ist ein Eigenvektor.

Jedes Mal, wenn ein neuronales Netz ein Bild erkennt oder einen Text schreibt, steuern Eigenwerte, was das Netz lernt und was es ignoriert.

Und in der Quantenmechanik? Die erlaubten Energien eines Atoms – die diskreten Spektrallinien, die Niels Bohr 1913 nicht erklären konnte – sind ebenfalls Eigenwerte. Schrödinger betitelte seine berühmte Arbeit von 1926 schlicht: „Quantisierung als Eigenwertproblem.“

Drei verschiedene Welten. Dieselbe Mathematik. Das ist kein Zufall – und in diesem Beitrag wirst du sehen, warum.

Wir bauen eine Kette: Von der einfachsten linearen Regression über Kernel-Methoden und Google PageRank bis zu neuronalen Netzen. Jedes Glied wächst aus dem vorherigen. Am Ende steht die Einsicht: Künstliche Intelligenz ist ein Eigenwertproblem.

Kapitel 2

Der kürzeste Weg

Ein Schatten auf dem Boden

Stell dir vor, du stehst in der Mittagssonne. Dein Schatten fällt senkrecht auf den Boden – ein flaches Abbild deiner dreidimensionalen Gestalt. Das ist eine Projektion: die bestmögliche Darstellung von dir in einer niedrigeren Dimension.

Was heißt „bestmöglich“? Der kürzeste Abstand von einem Punkt zu einer Fläche ist immer senkrecht. Das ist die Grundlage von allem, was in diesem Beitrag folgt.

Das Skalarprodukt: Zwei Vektoren, eine Zahl

Um „senkrecht“ mathematisch auszudrücken, brauchen wir das Skalarprodukt: \(\langle \mathbf{a}, \mathbf{b} \rangle = a_1 b_1 + a_2 b_2 + \ldots + a_n b_n\). Zwei Vektoren stehen senkrecht aufeinander, wenn ihr Skalarprodukt null ist. Ist es positiv, zeigen sie in ähnliche Richtungen. Negativ = entgegengesetzt.

Projektion auf eine Gerade

Gegeben: ein Vektor \(\mathbf{y}\) und eine Richtung \(\mathbf{a}\). Der Punkt auf der Geraden durch \(\mathbf{a}\), der \(\mathbf{y}\) am nächsten liegt, ist:

Der Fehler \(\mathbf{y} - \hat{y}\) steht senkrecht auf \(\mathbf{a}\). Das ist die ganze Idee.

Der allgemeine Fall: Die Normalengleichung

In der Praxis projiziert man nicht auf eine Gerade, sondern auf einen Unterraum, aufgespannt durch die Spalten einer Matrix \(X\). Die Bedingung „Fehler steht senkrecht auf allen Spalten“ wird zur Normalengleichung:

Konkretes Beispiel: \(X = (1,\; 0{,}5)^T\), \(\mathbf{y} = (3,\; 4)^T\). Dann \(X^TX = 1{,}25\), \(X^T\mathbf{y} = 5\), also \(c = 4\). Die Projektion ist \(\hat{\mathbf{y}} = (4,\; 2)^T\). Der Fehler \((-1,\; 2)^T\) steht senkrecht auf \(X\): \(1 \cdot (-1) + 0{,}5 \cdot 2 = 0\). ✓

Schöne Formel. Aber in der Mitte steht \((X^TX)^{-1}\) – eine Matrixinversion. Die kostet \(O(n^3)\) Rechenoperationen, ist numerisch instabil, und – wie wir gleich sehen werden – unnötig.

Kapitel 3

Geduld statt Genialität

Was wäre, wenn wir die Inverse nie berechnen müssten? Wenn es einen Weg gäbe, der nichts weiter tut, als immer wieder den eigenen Fehler zu korrigieren?

Projiziere. Fehler. Wiederhole.

Schritt 1: Berechne eine grobe erste Approximation: \(\hat{\mathbf{y}}_1 = X \cdot X^T \mathbf{y}\).

Schritt 2: Berechne den Fehler (das Residuum): \(\mathbf{r}_1 = \mathbf{y} - \hat{\mathbf{y}}_1\).

Schritt 3: Projiziere den Fehler selbst und addiere ihn: \(\hat{\mathbf{y}}_2 = \hat{\mathbf{y}}_1 + X \cdot X^T \mathbf{r}_1\).

Und weiter. Und weiter. Jede Iteration bringt uns näher an die exakte Lösung.

Das Muster in den Residuen

Nach \(n\) Schritten hat das Residuum die Form:

Wenn die Matrix \((I - XX^T)\) „schrumpft“ – alle ihre Eigenwerte betragskleiner als 1 sind – dann konvergiert \(\mathbf{r}_n \to \mathbf{0}\). Der Fehler verschwindet. (Das setzt voraus, dass die Daten passend skaliert sind. In der Praxis fügt man eine Lernrate \(\eta\) ein, die genau das sicherstellt – wir halten es hier einfach.)

Die mathematische Struktur hinter dieser Konvergenz heißt Neumann-Reihe:

Das ist die Matrixversion der geometrischen Reihe \(\sum q^k = 1/(1-q)\). Und sie bedeutet: Unsere Iteration konvergiert gegen \((X^TX)^{-1}X^T\mathbf{y}\) – exakt die geschlossene Lösung aus Kapitel 2.

Konkretes Beispiel: Zahlen statt Symbole

Für \(X = (1,\; 0{,}5)^T\) und \(\mathbf{y} = (3,\; 4)^T\) mit exakter Lösung \(\hat{\mathbf{y}}^* = (4,\; 2)^T\):

Beobachte: Die Approximation wandert Iteration für Iteration näher an (4, 2). Und der Fehler im Grenzfall – \((-1, 2)\) – steht senkrecht auf \(X\): \(1 \cdot (-1) + 0{,}5 \cdot 2 = 0\). Genau wie es sein muss.

Halt. Stop. Lies den letzten Satz nochmal. Die Iteration konvergiert nicht zu irgendeiner Näherung. Sie konvergiert zur exakten Lösung – derselben, die man durch Matrixinversion bekommt. Ohne je eine Matrix zu invertieren. Nur durch geduldiges Korrigieren des eigenen Fehlers.

Der elegante Beweis

Im Gleichgewicht ändert sich die Lösung nicht mehr: \(\hat{\mathbf{y}}' = X^T\mathbf{y} + (I - X^TX)\,\hat{\mathbf{y}}'\). Umstellen: \(\hat{\mathbf{y}}' - (I - X^TX)\,\hat{\mathbf{y}}' = X^T\mathbf{y}\), also \(X^TX\,\hat{\mathbf{y}}' = X^T\mathbf{y}\), also \(\hat{\mathbf{y}}' = (X^TX)^{-1}X^T\mathbf{y}\). Die Normalengleichung. Q.E.D.

Kapitel 4

Was Matrizen wirklich tun

Eine Matrix ist eine Maschine: Vektor rein, Vektor raus. Die meisten Vektoren werden dabei sowohl gestreckt als auch gedreht. Aber es gibt Spezialisten – Vektoren, deren Richtung sich nicht ändert:

So ein \(\mathbf{v}\) heißt Eigenvektor, das \(\lambda\) sein Eigenwert. Die Matrix tut nichts weiter, als den Eigenvektor mit \(\lambda\) zu skalieren – kein Drehen, kein Kippen.

Ein Beispiel von Hand

Nehmen wir \(A = \bigl(\begin{smallmatrix} 2 & 1 \\ 0 & 3 \end{smallmatrix}\bigr)\). Das charakteristische Polynom: \(\det(A - \lambda I) = (2-\lambda)(3-\lambda) = 0\). Eigenwerte: \(\lambda_1 = 2\), \(\lambda_2 = 3\).

Eigenvektoren: Für \(\lambda_1 = 2\) löse \((A-2I)\mathbf{v} = 0\): \(\mathbf{v}_1 = (1, 0)^T\). Für \(\lambda_2 = 3\): \(\mathbf{v}_2 = (1, 1)^T\). Probe: \(A \cdot (1,1)^T = (3,3)^T = 3 \cdot (1,1)^T\). ✓

Was bedeutet das konkret?

Wenn du die Matrix 10 Mal hintereinander anwendest: \(\lambda_1^{10} = 2^{10} = 1024\), aber \(\lambda_2^{10} = 3^{10} = 59\,049\). Der größere Eigenwert dominiert. Nach 20 Anwendungen: \(2^{20} \approx 10^6\), \(3^{20} \approx 3{,}5 \times 10^9\). Die Richtung von \(\mathbf{v}_2\) überlagert alles andere.

Warum Eigenwerte über Konvergenz entscheiden

Die Schlüsselformel: \(A^n = V\,\Lambda^n\,V^{-1}\), wobei \(\Lambda\) die Diagonalmatrix der Eigenwerte ist. Das heißt:

• Wenn \(|\lambda| < 1\): \(\lambda^n \to 0\) – die Komponente verschwindet.
• Wenn \(|\lambda| = 1\): bleibt konstant.
• Wenn \(|\lambda| > 1\): \(\lambda^n \to \infty\) – Explosion.

Jetzt die Verbindung zu Kapitel 3: Wenn \(\mu\) ein Eigenwert von \(X^TX\) ist, dann ist \((1 - \mu)\) ein Eigenwert von \((I - X^TX)\). Die Iteration konvergiert, wenn \(|1 - \mu| < 1\) für alle \(\mu\). Die Eigenwerte von \(X^TX\) bestimmen alles – ob die Iteration konvergiert und wie schnell.

Symmetrische Matrizen (und \(X^TX\) ist immer symmetrisch) haben nur reelle Eigenwerte und orthogonale Eigenvektoren. Große Eigenwerte = Richtungen mit viel Variation (Signal). Kleine = wenig Variation (Rauschen).

Kapitel 5

Früh aufhören lohnt sich

Stell dir einen Schüler vor, der 20 Übungsaufgaben auswendig lernt. Jede Zahl, jedes Komma, jede Formulierung – perfekt im Gedächtnis. In der Übung: 20 von 20. Dann kommt die Prüfung. Neue Aufgaben, die er noch nie gesehen hat. Ergebnis: 8 von 20. Er hat die Aufgaben gelernt, nicht die Prinzipien. Das nennt man Overfitting – Überanpassung.

Was das mit unserer Iteration zu tun hat

Nach \(n\) Iterationen wird die Komponente entlang des \(i\)-ten Eigenvektors um den Faktor \(1 - (1-\mu_i)^n\) beibehalten. Klingt abstrakt – aber schau dir die Zahlen an:

Große Eigenwerte (starkes Signal): Sofort bei 100%. Kleine Eigenwerte (oft Rauschen): Brauchen Hunderte von Iterationen. Wenige Iterationen = nur das Signal wird gelernt. Viele = auch das Rauschen. Frühes Aufhören ist ein natürlicher Rauschfilter.

Die Äquivalenz zu Ridge Regression

Die klassische Lösung gegen Overfitting – Ridge Regression – addiert \(\lambda\) zur Diagonale: \(\mathbf{c}_\lambda = (X^TX + \lambda I)^{-1}X^T\mathbf{y}\). Der Filterfaktor ist \(\mu_i/(\mu_i + \lambda)\).

Vergleiche mit unserem Iterationsfaktor \(1 - (1-\mu_i)^n\). Beide haben dieselbe Wirkung: große \(\mu_i\) durchlassen, kleine dämpfen. Als Faustregel (für moderate \(n\) und kleine \(\mu_i\)):

Mehr Iterationen = kleineres \(\lambda\) = weniger Regularisierung. Weniger Iterationen = größeres \(\lambda\) = glattere Lösung. (Die Beziehung ist nicht exakt, aber die Filterkurven beider Verfahren haben für praktische Zwecke dieselbe Form.)

Halt. Stop. In jedem Lehrbuch wird Ridge Regression als künstlicher Strafterm eingeführt: „Wir bestrafen große Koeffizienten.“ Aber in Wirklichkeit ist Regularisierung die natürlichste Sache der Welt: Hör auf, wenn es gut genug ist. Der Ridge-Parameter fällt nicht vom Himmel. Er ist die Konsequenz einer einfachen Entscheidung: Wie oft korrigiere ich meinen Fehler?

Diese Äquivalenz lässt sich als formaler Satz schreiben. In der Sprache der Spektralfilter besagt Theorem 1 im Kalle-Paper (Leonhardt, 2026):

Theorem 1 (Early Stopping ≈ Ridge Regression). Der iterative Filter \(f_i^{\mathrm{iter}}(n) = 1 - (1-\mu_i)^n\) und der Ridge-Filter \(f_i^{\mathrm{ridge}}(\lambda) = \mu_i/(\mu_i + \lambda)\) erzeugen bei \(\lambda \approx 1/n\) übereinstimmende Spektralfilterungen. Beide trennen Signal (große \(\mu_i\)) von Rauschen (kleine \(\mu_i\)) über das Eigenwertspektrum.

Konkrete Zahlen für \(\lambda = 0{,}01\) und \(n = 10\) (Tabelle 1 des Papers):

Die zwei Spalten sind nicht identisch – aber ihre Rangordnung über das Spektrum ist dieselbe. Große Eigenwerte lassen beide passieren; kleine unterdrücken beide. Frühes Aufhören ist also kein Trick, sondern implizite Regularisierung – und der Ridge-Parameter ist keine Hilfsvariable, sondern der geschlossene Ausdruck desselben Spektralfilters.

Kapitel 6

Der Kernel-Trick

Bisher war alles linear: Geraden, Ebenen, Polynome. Aber die Welt ist nicht linear. Daten folgen Parabeln, Sinuskurven, chaotischen Mustern. Brauchen wir eine neue Theorie?

Nein. Wir brauchen einen neuen Blick auf die Daten.

Features erweitern

Wenn Daten nicht linear in \(x\) sind, mach sie linear in \((1, x, x^2)\). Erweitere die Designmatrix durch eine Feature-Abbildung \(\phi(x)\). Im neuen Raum ist das Problem linear – unsere gesamte Maschinerie funktioniert wieder.

Die entscheidende Beobachtung

In der Iteration taucht überall \(X^TX\) auf – die Matrix der paarweisen Skalarprodukte. Eintrag \((i,j)\) ist \(\langle \phi(x_i), \phi(x_j) \rangle\). Wir brauchen die Features \(\phi(x_i)\) nie einzeln. Nur ihre Skalarprodukte.

Eine Kernel-Funktion \(k(x_i, x_j) = \langle \phi(x_i), \phi(x_j) \rangle\) berechnet dieses Skalarprodukt direkt, ohne den Umweg über die Features. Konkretes Beispiel: \((1 + xz)^2 = 1 + 2xz + x^2z^2\). Das ist das Skalarprodukt der Features \(\phi = (1, \sqrt{2}\,x, x^2)\) – eine einzige Multiplikation statt drei.

Der Gauß-Kernel \(k(x,z) = \exp(-\|x-z\|^2/(2\sigma^2))\) hat einen unendlich-dimensionalen Feature-Raum. Aber die Kernel-Matrix \(K\) bleibt endlich: \(n \times n\) für \(n\) Datenpunkte.

Der Übergang: Nichts ändert sich

Ersetze \(X^TX\) durch \(K\). Die Iteration wird: \(\hat{\mathbf{y}}_{n+1} = \hat{\mathbf{y}}_n + K(\mathbf{y} - \hat{\mathbf{y}}_n)\). Residuen: \(\mathbf{r}_n = (I - K)^n \mathbf{y}\). Konvergenz: bestimmt durch Eigenwerte von \(K\). Regularisierung: \(\lambda \approx 1/n\). Derselbe Algorithmus. Andere Sprache. Unendliche Ausdruckskraft.

Die Vorhersage für einen neuen Punkt \(x_*\) ist \(f(x_*) = \sum_{i=1}^n \alpha_i\,k(x_i, x_*)\) – jeder Trainingspunkt „stimmt ab“, gewichtet nach seiner Ähnlichkeit zum neuen Punkt.

Halt dir das vor Augen: Es gibt keine abstrakten Parameter, keine Gewichtsmatrizen, keine versteckten Schichten. Die Trainingsdaten sind das Modell. Die Funktion \(f\) ist vollständig durch die Datenpunkte und ihre Kernel-Ähnlichkeiten bestimmt. Das ist das Representer Theorem – und es gilt für jede Verlustfunktion, nicht nur für die quadratische.

Kapitel 7

Die große Vereinigung

Licht, das von Wänden springt

Stell dir einen weißen Raum vor mit einer tiefroten Wand. Eine Lampe an der Decke. Was siehst du? Nicht nur rote und weiße Flächen – sondern einen sanften rötlichen Schimmer auf dem weißen Boden neben der roten Wand. Color Bleeding: Licht springt von der roten Wand zum Boden und trägt Farbe mit.

In der Computergrafik beschreibt die Radiosity-Gleichung, wie Licht zwischen Flächen springt: \(\mathbf{B} = \mathbf{E} + \rho F \mathbf{B}\). Hier ist \(\mathbf{E}\) das Eigenleuchten (Lampen), \(\rho\) die Reflektivität (wie viel Licht jede Fläche zurückwirft) und \(F\) die Formfaktormatrix (wer „sieht“ wen). Die Lösung?

Dieselbe Neumann-Reihe wie in Kapitel 3! Nur die Bedeutung hat sich geändert:

• \(k=0\): Direktes Licht – die Lampe strahlt.
• \(k=1\): Erster Bounce – Licht reflektiert einmal von einer Wand.
• \(k=2\): Zweiter Bounce – das reflektierte Licht reflektiert nochmal.
• Typischerweise genügen 3–5 Bounces, bevor 99% der Energie absorbiert ist.

Licht, das zwischen Wänden springt, ist iterative Fehlerkorrektur – angewendet auf Energie statt auf Daten.

Die Matrix \(\rho F\) ist substochastisch (Zeilen summieren sich zu weniger als 1, weil Energie absorbiert wird). Füge eine zusätzliche „Absorber-Dimension“ hinzu – und die Matrix wird stochastisch (alle Zeilen = 1). Eine stochastische Matrix ist eine Markov-Kette. Deren Gleichgewicht ist der dominante Eigenvektor – der Eigenvektor zum Eigenwert 1.

Der Surfer, der nie aufhört

Wo im echten Leben gibt es ein riesiges Eigenwertproblem für eine stochastische Matrix? Jedes Mal, wenn du Google benutzt.

Stell dir einen zufälligen Surfer vor, der auf einer Webseite startet und bei jedem Schritt zufällig auf einen der ausgehenden Links klickt. Die Übergangsmatrix \(M\) beschreibt diesen Random Walk. Beispiel mit 4 Seiten:

A hat 2 Links (→ B, → D), also gibt A je \(1/2\) seiner „Stimme“ an B und D. Die Google-Matrix ergänzt einen Dämpfungsfaktor: mit \(d \approx 0{,}85\) folgt der Surfer einem Link; mit \(1-d \approx 0{,}15\) teleportiert er zu einer zufälligen Seite:

Die Power Iteration \(\mathbf{r}^{(k+1)} = G\,\mathbf{r}^{(k)}\) konvergiert zum dominanten Eigenvektor – dem PageRank. Für unser Mini-Web: B hat den höchsten Rang (34%), gefolgt von A (28%), D (24%), C (14%). Google berechnet das für Milliarden Webseiten in ~50 Iterationen.

Warum die Matrix stochastisch zu machen nicht nur elegant ist – sondern ein Performance-Trick

In der Absorber-Konstruktion steckt ein algorithmischer Gewinn, den man explizit benennen sollte. Vergleiche die zwei Wege, dieselbe Gleichung zu lösen:

Naiver Ansatz (Neumann-Summation): Berechne die Reihe $\mathbf{x} = \mathbf{b} + T\mathbf{b} + T^2\mathbf{b} + T^3\mathbf{b} + \ldots$ Term für Term. Jeder Schritt erfordert eine Matrix-Vektor-Multiplikation und eine Vektor-Addition, plus einen Akkumulator für die laufende Summe. Du kannst die vorherigen Terme nicht verwerfen – die gesamte Partialsumme muss bis zum Stopp-Zeitpunkt gehalten werden.

Stochastischer Ansatz (Power-Iteration): Sobald $T$ über die Absorber-Konstruktion zu einer stochastischen Matrix $P$ gemacht wurde, kollabiert die Iteration zu $\mathbf{x}_{k+1} = P\mathbf{x}_k$. Kein Akkumulator. Keine Additionen zwischen den Schritten. Nur eine Matrix-Vektor-Multiplikation, Vektor überschreiben, wiederholen. Der Speicherbedarf bleibt bei $O(n)$ über die gesamte Laufzeit.

Warum spielt das in der Praxis eine Rolle?

• GPU-Eignung: Matrix-Vektor-Produkte sind genau die Operation, für die GPUs optimiert sind. Power-Iteration ist im Wesentlichen ein BLAS-gemv-Aufruf pro Schritt. Neumann-Summation verschachtelt gemv mit axpy (Vektor-Addition) und verlangt, dass der Akkumulator resident bleibt – das erhöht die Speicherbandbreiten-Last.
• Kein Zwischenspeicher: Bei Neumann muss die Partialsumme $\sum_{k=0}^{N-1} T^k\mathbf{b}$ separat vom nächsten Term $T^N\mathbf{b}$ gehalten werden. Bei Power-Iteration existiert nur der aktuelle Vektor. Bei einem Web-Graphen mit einer Milliarde Seiten macht das den Unterschied.
• Konvergenz über Spectral Gap: Die Konvergenzrate der Power-Iteration ist direkt $|\lambda_2(P)|^k$. Googles Damping-Faktor $d$ ist genau so konstruiert, dass eine nutzbare Spektrallücke garantiert wird: $|\lambda_2(G)| \leq d = 0{,}85$. Das ist kein Detail – es ist der numerische Stabilisator.

Diese Einsicht überträgt sich auf Kernel Ridge Regression: der Ridge-Parameter \(\lambda\) übernimmt die Rolle des Damping-Faktors \(d\). Beide stabilisieren die Iteration, indem sie eine Spektrallücke erzeugen. Die algorithmische Konsequenz – dass man \((K + \lambda I)\boldsymbol{\alpha} = \mathbf{y}\) über GPU-freundliche Matrix-Vektor-Iteration lösen kann statt über einen \(O(D^3)\)-Direct-Solve – ist Gegenstand von Kalle v2, in dem wir die Absorber-Konstruktion formal für KRR herleiten und Direct Solve gegen Block Preconditioned Conjugate Gradient (Block-PCG) benchmarken.

Die überraschende Einsicht aus den Benchmarks. Für Kalle's reale Trainingsmatrix (\(D = 6144\), \(V = 2977\)) zeigt Tabelle 4 des Papers:

Man erwartet, dass Block-PCG nur bei großem \(D\) lohnt – die naive Intuition ist, dass Krylov-Methoden erst ab vielen tausend Dimensionen schneller werden als Gauß-Elimination. Tatsächlich liegt der Kipp-Punkt deutlich früher: mit einem modernen BLAS-Backend ist Block-PCG schon bei \(D = 6144\) rund 4× schneller als Direct Solve. Der zusätzliche Gewinn durch die Apple-GPU beträgt gerade einmal 5 % – denn bei dieser Größe deckt die Host-zu-Device-Transfer-Latenz noch nicht ihre Compute-Ersparnis. Die GPU wird erst ab \(D \geq 20\,000\) dominant, und dort ist der \(O(D^3)\)-Direct-Solve ohnehin nicht mehr praktikabel.

Die Lehre: der Hebel für Skalierung in KRR ist nicht in erster Linie die Hardware, sondern die algorithmische Umformulierung – die Absorber-Konstruktion, die das System in eine Form bringt, die moderne Matrixbibliotheken effizient lösen können. Das ist dieselbe intellektuelle Bewegung, die Google vor 25 Jahren mit PageRank gemacht hat: nicht durch größere Server, sondern durch die Umformulierung in ein Eigenwertproblem einer stochastischen Matrix.

Halt. Stop. Regression (Kapitel 3), Radiosity, PageRank – drei verschiedene Probleme, dreimal derselbe Algorithmus. Iterative Matrixmultiplikation, gesteuert durch Eigenwerte. Dreimal Neumann-Reihe. Dreimal Konvergenz zum dominanten Eigenvektor.

So mächtig wie ein Gehirn

Jetzt die letzte Verbindung. Wie mächtig ist Kernel Ridge Regression wirklich?

Das Representer Theorem (Kimeldorf & Wahba, 1970) sagt: Die optimale KRR-Lösung hat immer die Form \(f^*(x) = \sum_{i=1}^n \alpha_i\,k(x_i, x)\). Endlich viele Koeffizienten, egal wie hochdimensional der Kernel-Raum ist.

Das Universal Approximation Theorem (Cybenko, 1989) sagt: Ein neuronales Netz mit einer versteckten Schicht kann jede stetige Funktion beliebig genau approximieren.

Und der Gauß-Kernel ist universell (Micchelli et al., 2006): KRR mit Gauß-Kernel kann ebenfalls jede stetige Funktion beliebig genau approximieren.

Beide Funktionenklassen – neuronale Netze und KRR – sind dicht in \(C(K)\). Sie sind gleich mächtig. Und der Neural Tangent Kernel (Jacot et al., 2018) zeigt: Im idealisierten Grenzfall unendlicher Breite und geeigneter Initialisierung wird ein neuronales Netz zu KRR. Die Verbindung ist nicht metaphorisch – sie ist ein Theorem (wenn auch ein Grenzfall-Theorem).

Natürlich ist moderne KI – Transformer, Attention, stochastisches Gradientenverfahren in nicht-konvexen Landschaften – mehr als ein Eigenwertproblem. Aber die Eigenwertstruktur ist der mathematische Kern, der sich durch alle Schichten zieht. Sie erklärt nicht alles – aber sie erklärt, warum das Fundament hält.

Unter der Haube: Wie der KRR-Chatbot funktioniert

Der KRR-Chat ist nicht simuliert – er ist ein echtes, funktionierendes Sprachmodell, allerdings bewusst minimal gehalten, um die mathematische Struktur sichtbar zu machen. Er ist ein vollständiges Sprachmodell, das die gesamte Kette dieses Beitrags in einer einzigen Anwendung vereint: Wort-Hashing (\(\phi(x)\)), Random Fourier Features (Kernel-Approximation), Ridge Regression (Regularisierung) – alles in drei JavaScript-Funktionen.

Die Antwort des Modells wird farblich markiert: Grün für Wörter die exakt so in den Trainingsdaten vorkommen (Memorisierung), Orange für Wörter die das Modell neu kombiniert (Generalisierung). Typischerweise sind 60–80% grün – das zeigt ehrlich: ein KRR-Modell mit 505 Wörtern memoriert hauptsächlich, generalisiert aber an den Nahtstellen zwischen gelernten Sätzen.

Epilog

K = K: Das Glasperlenspiel

Am Anfang dieses Beitrags stand eine Formel aus der Quantenmechanik. Am Ende steht eine Formel aus dem maschinellen Lernen. Stell sie nebeneinander:

Derselbe Buchstabe \(K\). Dasselbe Muster: Eine Summe über Eigenfunktionen \(\psi_n\), gewichtet durch Eigenwerte. Der Propagator beschreibt, wie ein Quantenteilchen von A nach B reist. Der Kernel beschreibt, wie ähnlich zwei Datenpunkte sind. Verschiedene Bühnen, dieselbe Mathematik. (Die \(\psi_n\) sind hier die Mercer-Eigenfunktionen des Kernels – verwandt mit, aber verschieden von der Feature-Abbildung \(\phi\) aus Kapitel 6.)

Im Quantenbeitrag hast du gesehen, wie stehende Wellen zu diskreten Energieniveaus führen – die Töne, die ein Quantensystem gerne spielt. Hier hast du gesehen, wie die Eigenwerte einer Kernel-Matrix bestimmen, was ein Algorithmus lernt und was er ignoriert. Dasselbe Prinzip. Andere Bühne.

Erwin Schrödinger betitelte seine Arbeit von 1926: „Quantisierung als Eigenwertproblem.“

Vielleicht sollten wir ergänzen: Intelligenz als Eigenwertproblem.

Die Natur ist reicher als jede einzelne Beschreibung. Aber manchmal teilen verschiedene Beschreibungen denselben mathematischen Kern. Eigenwerte sind dieser Kern.

Verwandter Beitrag: Im Deepfakes-Post wird PCA — mathematisch eine Eigenwertzerlegung der Kovarianzmatrix — zur Bildkomprimierung eingesetzt. Und die Latent-Space-Arithmetik der Autoencoder ist im Grunde ein nichtlineares Pendant zur Hauptkomponentenanalyse.

Auch passend: Im Quantencomputer-Post sind Quantengatter unitäre Matrizen — ihre Eigenwerte liegen alle auf dem Einheitskreis. Daher sind sie reversibel: sie strecken nichts, sie rotieren nur.

Häufige Fragen

Was sind Eigenwerte einfach erklärt?

Ein Eigenwert beschreibt, wie stark eine bestimmte Richtung unter einer Transformation gestreckt oder gestaucht wird. Die stabilen Richtungen sind die Eigenvektoren, der Faktor ist der Eigenwert. Eigenwerte tauchen überall auf: in der Quantenmechanik, bei PageRank, in neuronalen Netzen.

Warum braucht man Eigenwerte in der künstlichen Intelligenz?

Die Kernel-Matrix in Machine-Learning-Verfahren hat Eigenwerte. Große Eigenwerte entsprechen Signal, kleine Eigenwerte entsprechen Rauschen. Regularisierung dämpft die kleinen Eigenwerte – das ist der mathematische Kern der Überanpassungsvermeidung.

Was hat PageRank mit Eigenwerten zu tun?

PageRank berechnet die Wichtigkeit von Webseiten als den dominanten Eigenvektor der Link-Matrix des Internets. Die Webseite mit dem größten Eigenwert-Anteil ist die wichtigste.