Was sind Modellgewichte?

Ein modernes KI-Modell kann Python schreiben, einen Hund erkennen, Japanisch übersetzen, einen Vertrag zusammenfassen, Shakespeare nachahmen und dir gelegentlich etwas völlig Falsches erzählen — mit der Selbstsicherheit eines Mannes, der noch nie auf die Idee gekommen ist, etwas bei Google nachzuprüfen.

Unter all dieser Raffinesse steckt etwas überraschend Gewöhnliches:

Zahlen.

Milliarden davon.

Wenn ein Modell als 8B, 30B oder 70B bezeichnet wird, steht das B für Milliarden Parameter.

Diese Parameter sind gelernte Zahlenwerte innerhalb des neuronalen Netzes. Die meisten befinden sich in riesigen mathematischen Strukturen, den Gewichtsmatrizen.

Diese Zahlen sind gewöhnlich gemeint, wenn von den Gewichten eines Modells die Rede ist.

Es sind keine kleinen Sätze, die irgendwo im Computer gespeichert sind.

Es gibt keine versteckte Zeile mit:

Frankreich → Paris

Es gibt keinen Ordner namens:

Dinge, die ich über Hunde weiß

Und kein einzelnes Gewicht trägt einen Titel wie:

Leitender Vizepräsident für Sarkasmus.

Wissen ist in einem neuronalen Netz über gewaltige Zahlenmuster verteilt.

Das klingt geheimnisvoll.

Die Grundidee ist es nicht.

Tatsächlich beginnt die Geschichte vor mehr als achtzig Jahren.

Bevor KI cool war — oder überhaupt elektronisch

1943 veröffentlichten der Neurophysiologe Warren McCulloch und der Mathematiker Walter Pitts ein einflussreiches mathematisches Modell eines künstlichen Neurons.

Das war vor der modernen KI.

Vor GPUs.

Vor Python.

Noch vor der Erfindung des Transistors.

Ihre Frage war kühn und einfach:

Könnte man etwas, das von einem biologischen Neuron inspiriert ist, mathematisch als Recheneinheit darstellen?

Nach heutigen Maßstäben war ihr künstliches Neuron äußerst primitiv. Es empfing Eingaben und erzeugte nach mathematischen Regeln eine Ausgabe.

Doch eine wichtige Idee war geboren:

Vielleicht könnte komplexes Verhalten aus vielen einfachen, miteinander verbundenen Recheneinheiten entstehen.

Moderne neuronale Netze sind wesentlich ausgefeilter.

Aber unter ihnen ist diese ursprüngliche Idee noch immer erkennbar.

Beginnen wir mit einem künstlichen Neuron

Vergessen wir für einen Moment die acht Milliarden Parameter.

Bauen wir ein einziges winziges künstliches Neuron.

Angenommen, es erhält drei numerische Eingaben:

Der Buchstabe $x$ bedeutet einfach Eingabe.

Diese Eingaben könnten letztlich fast alles darstellen: Zahlen aus einem Finanzdatensatz, Teile eines Bildes oder interne numerische Darstellungen von Sprache.

Jede Eingabe wird mit einer weiteren Zahl multipliziert:

Der Buchstabe $w$ steht für Gewicht.

Ein Gewicht bestimmt, wie stark die jeweilige Eingabe zur Berechnung des Neurons beiträgt.

Das Neuron kombiniert die Werte so:

Die Formel sieht einschüchternder aus als der eigentliche Vorgang.

In Alltagssprache lautet sie:

Multipliziere jede Eingabe mit ihrem Gewicht, addiere die Ergebnisse und addiere dann noch eine verstellbare Zahl, den Bias.

Der Bias ist:

Er erlaubt dem Neuron, sein Ergebnis unabhängig von den eingehenden Werten nach oben oder unten zu verschieben.

Nach der Berechnung der gewichteten Summe leitet ein neuronales Netz das Ergebnis normalerweise durch eine nichtlineare Funktion:

Hier bedeutet $f$ einfach:

Wende eine weitere mathematische Umformung auf das Ergebnis an.

Warum der Aufwand?

Weil sich ohne nichtlineare Funktionen selbst viele aufeinandergestapelte Schichten mathematisch wie eine einzige riesige lineare Transformation verhalten würden.

Nichtlinearität ermöglicht es dem Netz, viel komplexere Zusammenhänge darzustellen.

Der grundlegende Weg lautet also:

Eingaben → Gewichte → gewichtete Summe → nichtlineare Transformation → nächste Schicht

Ein künstliches Neuron wird deinen Quartalsbericht nicht schreiben.

Milliarden gelernter Parameter in ausgefeilten Schichten werden erheblich interessanter.

Das Perzeptron kommt — und mit ihm der KI-Hype

Ende der 1950er-Jahre entwickelte der Psychologe Frank Rosenblatt das Perzeptron, ein frühes trainierbares neuronales Netzsystem.

Das wichtige Wort ist trainierbar.

Statt dass ein Programmierer jeden nützlichen internen Wert ausdrücklich auswählte, konnte die Maschine ihre Verbindungsstärken anhand von Beispielen selbst anpassen.

Diese Verbindungsstärken waren Gewichte.

Die Grundidee klang erstaunlich modern:

Mache eine Vorhersage.
Finde heraus, ob sie falsch war.
Passe die Zahlen an.
Versuche es erneut.

Die Zeitungen waren außerordentlich begeistert.

Das beweist, dass der KI-Hype nicht von sozialen Medien erfunden wurde.

Die Computer waren etwas weniger praktisch.

Heute kannst du Modelle mit Milliarden Parametern auf Hardware unter deinem Schreibtisch ausführen.

Rosenblatt arbeitete in einer Zeit, in der Computer einen beträchtlichen Teil eines Zimmers beanspruchen und dabei deutlich weniger leisten konnten als dein Telefon.

Fortschritt ist manchmal grausam zu alter Hardware.

Das riesige Mischpult

Eine hilfreiche Vorstellung für Gewichte ist ein gewaltiges Audiomischpult.

Ein Signal kommt herein.

Ein Regler verstärkt einen Teil davon.

Ein anderer schwächt etwas ab.

Ein weiterer beeinflusst, wie mehrere Signale zusammenkommen.

Nun stelle dir nicht zwanzig Regler vor.

Auch nicht zwanzigtausend.

Sondern Milliarden.

Das endgültige Verhalten hängt von ihren gemeinsamen Einstellungen ab.

Diese Analogie braucht allerdings einen wichtigen Hinweis.

Ein bestimmtes Gewicht entspricht normalerweise nicht sauber einem menschlichen Begriff.

Du kannst kein 8B-Modell öffnen, Parameter Nummer 4.827.112.391 finden und verkünden:

„Ausgezeichnet. Wir haben das linke Ohr des Hundes gefunden.“

Moderne neuronale Netze verwenden verteilte Repräsentationen.

Ein Begriff wie Hund, Ironie, JavaScript, Schwerkraft oder eine höfliche Art, einem Kunden zu sagen, dass sein Entwurf furchtbar ist, kann von Mustern mit enorm vielen Parametern und vorübergehenden internen Zuständen abhängen.

Die Bedeutung ist verteilt.

Die Intelligenz liegt im Muster.

Nicht in einem magischen Drehknopf.

Vor dem Training: ein sehr teurer Idiot

Bei der ersten Initialisierung eines neuronalen Netzes beginnen seine Gewichte im Allgemeinen als kleine Zahlenwerte, die nach einem Initialisierungsverfahren gewählt werden.

Zu diesem Zeitpunkt hat das Netz eine Architektur.

Es hat Milliarden Stellen, an denen später Wissen dargestellt werden könnte.

Doch nützliche Zusammenhänge hat es noch nicht gelernt.

Du könntest ein riesiges Modell bauen und trotzdem etwas weitgehend Nutzloses erhalten.

Daran sollte man denken, wenn Parameterzahlen Menschen hypnotisieren.

Eine Lagerhalle mit zehn Milliarden leeren Notizbüchern enthält nicht automatisch mehr Wissen als eine Bibliothek.

In den Notizbüchern muss etwas stehen.

Training ist der Prozess, der die Zahlen verändert.

Nicht, indem er Sätze hineinschreibt.

Sondern indem er nützliche numerische Zusammenhänge schafft.

Lassen wir ein Neuron einen Fehler machen

Betrachten wir nun ein winziges Trainingsbeispiel mit Zahlen, die wir von Hand nachvollziehen können.

Angenommen, unser Neuron erhält zwei Eingaben.

Die erste Eingabe ist:

Die zweite ist:

Das erste Signal hat also den Zahlenwert eins, das zweite den Wert ein halb.

Das aktuelle erste Gewicht ist:

Das zweite ist:

Und der Bias ist:

Nun berechnen wir unsere gewichtete Summe:

Statt die Formel anzustarren, zerlegen wir sie.

Die erste Eingabe trägt bei:

Die zweite Eingabe trägt bei:

Und der Bias liefert noch:

Addieren wir die drei Teile:

Unser Neuron liefert also:

Das kleine Dach über $y$ bedeutet:

die Vorhersage des Modells

Nehmen wir nun an, der richtige Zielwert in diesem Trainingsbeispiel lautet:

Das Modell sagte voraus:

Das richtige Ergebnis war:

Die Vorhersage liegt also um diesen Betrag zu niedrig:

Das Neuron liegt falsch.

Das ist eine ausgezeichnete Nachricht.

Fehler sind im Grunde das Bildungssystem neuronaler Netze.

Ohne Fehler fehlt dem Trainingsprozess das Signal, was verbessert werden muss.

Verlust: ein mathematischer Peinlichkeitsmesser

Das Trainingssystem braucht nun eine formale Antwort auf die Frage:

Wie falsch war diese Vorhersage?

Das ist die Aufgabe einer Verlustfunktion.

Für unser Spielzeugbeispiel können wir eine einfache quadratische Fehlerfunktion verwenden:

Übersetzen wir jedes Symbol.

$L$ bedeutet Verlust.

$\hat y$ bedeutet die Vorhersage des Modells.

$y$ bedeutet der richtige Zielwert.

Die Formel sagt also:

Ziehe die richtige Antwort von der Vorhersage ab und quadriere die Differenz.

Unsere Vorhersage ist:

Der Zielwert ist:

Subtrahieren wir:

Nun quadrieren wir das Ergebnis:

Unser Verlust beträgt also:

Warum quadrieren wir den Fehler?

Unter anderem sollen sich Fehler in entgegengesetzte Richtungen nicht gegenseitig aufheben.

Um 0.30 zu niedrig zu liegen, ist trotzdem ein Fehler.

Durch das Quadrieren erhalten wir eine positive Größe, die die Optimierung zu verringern versuchen kann.

Stelle dir den Verlust als mathematischen Peinlichkeitsmesser vor.

Hoher Verlust:

Das ging daneben.

Geringerer Verlust:

Weniger peinlich.

Ein modernes Sprachmodell verwendet für die Vorhersage des nächsten Tokens gewöhnlich eine andere Verlustfunktion, meist eine Form des Kreuzentropieverlusts.

Den lernen wir später kennen.

Für den Moment lautet die entscheidende Idee:

Vorhersage → Fehler messen

Die nächste Frage ist schwieriger.

Unser kleines Beispiel hat nur zwei Gewichte.

Ein echtes Modell kann Milliarden haben.

Welche Gewichte waren für den Fehler verantwortlich?

Und in welche Richtung sollten sie sich bewegen?

1986: Die Mathematik lernt, Schuld zu verteilen

Eines der zentralen Werkzeuge für diese Frage ist die Rückpropagation.

Die mathematischen Ideen dahinter haben eine längere Geschichte. Doch eine einflussreiche Arbeit von David Rumelhart, Geoffrey Hinton und Ronald Williams aus dem Jahr 1986 trug dazu bei, die Rückpropagation zu einem zentralen Verfahren für das Training moderner neuronaler Netze zu machen.

Das Problem ist leicht beschrieben.

Die Ausgabe war falsch.

Aber viele Schichten und viele Parameter waren an ihrer Entstehung beteiligt.

Wie finden wir heraus, welche Änderungen die Ausgabe verbessern würden?

Die Rückpropagation durchläuft das Netz rückwärts und berechnet, wie empfindlich der abschließende Fehler auf jeden trainierbaren Parameter reagiert.

Man könnte sie sich als außergewöhnlich effiziente Buchhaltung vorstellen.

Ein Fehler ist passiert.

Nun wird der Beitrag jedes Beteiligten berechnet.

Niemand kann sagen:

„Das war ziemlich sicher Schicht 17.“

Die Differentialrechnung hat die Belege.

Rückpropagation: Was bedeutet die Formel?

Einer der Ausdrücke, denen du begegnen wirst, lautet:

Wenn du vor zwanzig Jahren Differentialrechnung gelernt und sie seitdem erfolgreich vermieden hast, kann diese Schreibweise unnötigen seelischen Schaden anrichten.

Die Idee ist deutlich einfacher als das Symbol.

Sie fragt:

Wenn ich genau dieses Gewicht um einen winzigen Betrag ändere, wie verändert sich der Verlust?

Dieser Wert ist Teil dessen, was wir den Gradienten nennen.

Angenommen, ein leichtes Erhöhen eines Gewichts vergrößert den Fehler.

Nützliche Information.

Angenommen, es verkleinert den Fehler.

Auch nützlich.

Die Ableitung verrät dem Optimierer somit etwas über Richtung und Empfindlichkeit.

Die Rückpropagation nutzt die Kettenregel der Differentialrechnung, um diese Zusammenhänge effizient über viele Schichten hinweg zu berechnen.

Das Netz denkt nicht:

„Ich habe den Hund mit einer Katze verwechselt, weil ich zu sehr auf das Fell geachtet habe.“

Nichts derart Literarisches geschieht.

Es berechnet, wie Änderungen von Zahlen andere Zahlen beeinflussen.

Sehr viele Zahlen.

Gradientenabstieg: Jetzt geht es bergab

Sobald die Rückpropagation die Gradienten berechnet hat, besitzt der Optimierer eine Handlungsgrundlage.

Eine vereinfachte Gewichtsaktualisierung sieht so aus:

Übersetzen wir wieder, bevor wir sie anwenden.

$w_{\text{old}}$ ist das Gewicht, das wir jetzt haben.

$w_{\text{new}}$ ist das Gewicht nach dem Trainingsschritt.

Der Gradient:

sagt uns, wie sich der Verlust ändert, wenn sich dieses Gewicht ändert.

Und der griechische Buchstabe:

ausgesprochen Eta, ist die Lernrate.

Die Lernrate bestimmt, wie groß der Schritt des Optimierers sein soll.

Die ganze Formel bedeutet also:

Beginne beim aktuellen Gewicht.
Bestimme die Richtung, in der der Fehler wächst.
Gehe eine kontrollierte Strecke in die entgegengesetzte Richtung.

Warum die entgegengesetzte Richtung?

Weil der Verlust sinken soll.

Stelle dir vor, du stehst im dichten Nebel auf einem Berg.

Du kannst das Tal nicht sehen.

Aber du kannst feststellen, in welche Richtung es bergauf geht.

Wenn du absteigen willst, gehe in die andere Richtung.

Das ist die Grundidee des Gradientenabstiegs.

Die wirkliche Optimierungslandschaft eines modernen neuronalen Netzes kann Milliarden Dimensionen haben.

Dadurch lässt sich der Berg etwas schwer auf einer Serviette skizzieren.

Wenn du dir eine Landschaft mit siebzig Milliarden Dimensionen mühelos vorstellen kannst, hast du möglicherweise andere Probleme.

Modernes Training verwendet häufig ausgefeiltere Optimierer wie Adam oder AdamW, die zusätzliche Informationen verfolgen und den Aktualisierungsprozess intelligent anpassen.

Die zentrale Idee bleibt jedoch:

Berechne, wie die Parameter den Fehler beeinflussen, und bewege sie dann in eine Richtung, die ihn voraussichtlich verringert.

Tun wir das jetzt tatsächlich.

Eine winzige Aktualisierung — mit der wirklichen Rechnung

Unser Spielzeugneuron erhielt zuvor:

und:

Seine Gewichte waren:

und:

Der Bias war:

Das Neuron sagte voraus:

Das gewünschte Ergebnis war:

Für diese Demonstration verwenden wir die gewichtete Summe direkt als Vorhersage, damit jeder Rechenschritt sichtbar bleibt. Ein echtes Netz kann außerdem eine Aktivierungsfunktion enthalten, deren Ableitung Teil der Rückpropagation wird.

Unser Vorhersagefehler mit Vorzeichen lautet:

Das Minuszeichen sagt uns:

Die Vorhersage des Modells liegt unter dem Zielwert.

Unser quadratischer Verlust war:

also:

Nun berechnen wir, wie dieser Verlust auf jedes Gewicht reagiert.

Den Gradienten für das erste Gewicht finden

Für dieses einfache Neuron ist der Gradient des Verlusts bezüglich des ersten Gewichts:

Das sieht technisch aus.

Aber alle Werte sind bereits bekannt.

Der Fehler ist:

Die erste Eingabe ist:

Setzen wir diese Werte ein:

Multiplizieren wir:

Was bedeutet minus 0.60?

Es sagt uns, dass an dieser Stelle eine Erhöhung von $w_1$ den Verlust verringern sollte.

Der Gradient zeigt in Richtung des wachsenden Fehlers.

Der Gradientenabstieg bewegt sich in die entgegengesetzte Richtung.

Den Gradienten für das zweite Gewicht finden

Nun machen wir dasselbe für das zweite Gewicht:

Der Fehler beträgt weiterhin:

Die zweite Eingabe beträgt jedoch nur:

Einsetzen:

ergibt:

Beachte etwas Nützliches.

Der Betrag des zweiten Gradienten ist nur halb so groß wie der des ersten.

Warum?

Weil die zweite Eingabe:

halb so groß ist wie die erste:

In diesem winzigen Beispiel beeinflusst eine Änderung des ersten Gewichts das Endergebnis stärker.

Genau solche Abhängigkeiten berechnet die Rückpropagation automatisch.

Eine Lernrate wählen

Nun kennen wir die Richtung.

Wir müssen noch entscheiden, wie groß der Schritt sein soll.

Für unsere Demonstration wählen wir:

Das bedeutet, dass sich der Optimierer in diesem vereinfachten Schritt um ein Zehntel des Gradientenbetrags bewegt.

Das ist eine praktische runde Zahl zum Erklären.

Echte Trainingssysteme wählen und planen Lernraten viel sorgfältiger.

Sind sie zu klein, kann das Lernen quälend langsam werden.

Sind sie zu groß, springt der Optimierer womöglich über gute Lösungen hinweg und hüpft durch die Landschaft wie jemand, der in Skischuhen einen Berg hinuntersteigen möchte.

Das erste Gewicht aktualisieren

Die Aktualisierungsregel lautet:

Für das erste Gewicht:

Zuerst multiplizieren wir Lernrate und Gradient:

Also:

Eine negative Zahl abzuziehen bedeutet zu addieren:

Jetzt wissen wir genau, woher 0.26 kommt.

Niemand hat die Zahl ausgewählt, weil sie hübsch aussah.

Kein Ingenieur tippte:

Versuchen wir es mit 0.26.

Gradient und Lernrate haben sie ergeben.

Das zweite Gewicht aktualisieren

Nun wiederholen wir genau denselben Vorgang für $w_2$:

Multiplizieren:

Also:

und damit:

Daher kommt 0.43.

Für dieses Lehrbeispiel lassen wir den Bias unverändert bei:

In einem echten Netz hätte ein trainierbarer Bias normalerweise seinen eigenen Gradienten und könnte nach demselben allgemeinen Verfahren aktualisiert werden.

Das Neuron erneut ausführen

Die Eingaben haben sich nicht geändert.

Die erste ist weiterhin:

Ihr Gewicht beträgt jetzt jedoch:

Ihr Beitrag ist daher:

Die zweite Eingabe bleibt:

Ihr neues Gewicht ist:

Ihr Beitrag wird damit:

Der Bias bleibt:

Alles addieren:

Die neue Vorhersage des Neurons lautet:

Vor dem Trainingsschritt sagte es voraus:

Nun sagt es voraus:

Der Zielwert bleibt:

Es liegt noch immer falsch.

Aber beachte, was geschehen ist.

Vor der Aktualisierung war der Abstand zum Zielwert:

Nach der Aktualisierung:

Der Fehler wurde kleiner.

Wir können auch den neuen quadratischen Verlust berechnen:

Zuerst:

Dann quadrieren:

Der Verlust ist also gesunken von:

auf:

In diesem absichtlich einfachen Beispiel verringerte ein einziger Gradientenabstiegsschritt den Verlust deutlich.

Das bedeutet nicht, dass sich ein echtes großes Sprachmodell mit jedem Trainingsschritt um denselben Prozentsatz verbessert.

Echte Optimierung ist verrauscht, kompliziert und hat ungeheuer viel mehr Dimensionen.

Unser winziges Beispiel hat nun aber einen vollständigen Lernschritt gezeigt, ohne etwas zu verstecken:

In Worten:

Das Neuron machte eine Vorhersage.
Der Verlust maß den Fehler.
Die Differentialrechnung bestimmte, wie die Gewichte zum Fehler beitrugen.
Der Optimierer veränderte die Gewichte.
Die neue Vorhersage rückte näher an den Zielwert.
Der Verlust wurde kleiner.

Es geschah nichts Magisches.

Die Mathematik veränderte die Zahlen.

Dann macht das System es wieder.

Und wieder.

Und wieder.

Unser Beispiel verwendet zwei Gewichte, weil zwei Gewichte noch bequem auf eine Seite passen.

Ein echtes neuronales Netz kann Millionen oder Milliarden trainierbarer Parameter anpassen.

Hier kommen Berechnungen im industriellen Maßstab ins Spiel.

Wie lernt ein Sprachmodell daraus?

Ein großes Sprachmodell wird normalerweise nicht mit einer riesigen Tabelle ausdrücklicher Regeln trainiert wie:

Paris = Hauptstadt von Frankreich

Hund = Säugetier

Python = Einrückung ist wichtig

Stattdessen nutzt ein großer Teil des modernen Sprachmodell-Vortrainings ein täuschend einfaches Ziel:

Sage das nächste Token voraus.

Bleiben wir also bei Paris und verfolgen das Beispiel bis zum Ende.

Angenommen, der Trainingstext enthält:

Die Hauptstadt von Frankreich ist Paris.

An einer Stelle des Trainings erhält das Modell:

Die Hauptstadt von Frankreich ist

und muss das nächste Token vorhersagen.

Der Einfachheit halber nehmen wir an, dass Paris durch ein Token dargestellt wird. Echte Tokenisierung kann manche Wörter in mehrere Tokens zerlegen, aber am Prinzip ändert das nichts.

Früh im Training könnte das Modell ungefähr folgende Wahrscheinlichkeiten ausgeben:

London — 18%
Paris — 5%
Lyon — 4%
Rom — 3%
Berlin — 2%

Die restliche Wahrscheinlichkeit verteilt sich auf Tausende weitere mögliche Tokens.

Der Trainingstext sagt uns jedoch, dass das tatsächliche nächste Token lautet:

Paris

Das Modell hat also eine schlechte Vorhersage gemacht.

Es gab Paris nur fünf Prozent Wahrscheinlichkeit und bevorzugte London.

Nun muss das Training messen, wie schlecht diese Vorhersage war.

Kreuzentropie: der Verlust des Sprachmodells

Zur Vorhersage des nächsten Tokens verwenden Sprachmodelle häufig eine Form des Kreuzentropieverlusts.

Für ein einzelnes richtiges Token lässt sich der vereinfachte Ausdruck so schreiben:

Wieder übersetzen wir vor dem Rechnen.

$P_{\text{correct}}$ bedeutet:

die Wahrscheinlichkeit, die das Modell dem tatsächlich folgenden Token zugewiesen hat

In unserem Beispiel:

Fünf Prozent als Dezimalzahl:

Einsetzen:

Das Ergebnis beträgt ungefähr:

Du musst dir 2.996 nicht merken.

Wichtig ist, was der Logarithmus bewirkt.

Eine geringe Wahrscheinlichkeit für die richtige Antwort erzeugt einen vergleichsweise hohen Verlust.

Nehmen wir nun an, dass viel später im Training derselbe Kontexttyp Paris eine Wahrscheinlichkeit von siebzig Prozent gibt:

Dann gilt:

also ungefähr:

Somit:

Paris bei 5% → vergleichsweise hoher Verlust

Paris bei 70% → viel geringerer Verlust

Die Verlustfunktion weiß nicht, was Paris ist.

Sie weiß nicht, was Frankreich ist.

Sie versteht das politische Konzept einer Hauptstadt nicht.

Sie sagt lediglich:

Die Wahrscheinlichkeit für das richtige Token hätte höher sein sollen.

Dieses numerische Signal genügt.

Die Rückpropagation kann nun dieselbe Art von Arbeit erledigen wie bei unserem Spielzeugneuron.

Wie gelangt „Paris“ tatsächlich zu den Gewichten?

Die Vorhersage kam nicht von einem einzigen Gewicht.

Die Wörter:

Die Hauptstadt von Frankreich ist

wurden zunächst in numerische Tokendarstellungen umgewandelt.

Diese Darstellungen durchliefen viele Transformer-Schichten.

In diesen Schichten wandelten Aufmerksamkeitsmechanismen und vorwärtsgerichtete Netze die Zahlen mithilfe gelernter Gewichtsmatrizen wiederholt um.

Schließlich erzeugte das Modell Rohwerte für mögliche nächste Tokens.

Diese Rohwerte heißen Logits.

Stelle dir eine stark vereinfachte Version vor:

Das sind noch keine Wahrscheinlichkeiten.

Es sind rohe Präferenzwerte.

Eine mathematische Operation namens Softmax wandelt die Logits in eine Wahrscheinlichkeitsverteilung um, deren Werte sich zu hundert Prozent addieren.

Nach Softmax erhalten wir vielleicht:

London — 18%
Paris — 5%
Lyon — 4%
Rom — 3%

Die Trainingsdaten sagen uns:

Paris hätte gewinnen sollen.

Die Kreuzentropie liefert den Verlust.

Dann geht die Rückpropagation rückwärts durch das Netz und berechnet, wie kleine Änderungen an den beteiligten Parametern diesen Verlust beeinflussen würden.

Der Optimierer aktualisiert sie.

Keine einzelne riesige Änderung.

Enorm viele mikroskopische Änderungen.

Dann kommt das nächste Textstück.

Ein Satz lehrt noch keine Geografie

Das Modell sieht nicht einmal:

Die Hauptstadt von Frankreich ist Paris.

und verkündet sofort:

„Geografie abgeschlossen.“

Seine Trainingsdaten könnten auch enthalten:

Paris ist die Hauptstadt von Frankreich.

Frankreichs Hauptstadt ist Paris.

Die französische Regierung sitzt in Paris.

Paris ist eine große europäische Stadt.

Frankreich ist ein Land in Westeuropa.

Die Seine fließt durch Paris.

Und gewaltige Mengen weiterer Kontexte über Frankreich, Paris, Städte, Regierungen, Länder, Sprachen, Reisen, Geschichte und Geografie.

Jedes Beispiel erzeugt Vorhersagen.

Jede Vorhersage erzeugt einen Verlust.

Jeder Verlust erzeugt Gradienten.

Jeder Trainingsschritt verändert die Parameter ein wenig.

Mit der Zeit werden überlappende Zusammenhänge nach und nach in das Netz eingewebt.

Dieses Wort — eingewebt — ist hilfreich.

Die Tatsache wird nicht in eine Schachtel gelegt, auf der steht:

Frankreich → Paris

Sie wird Teil eines verteilten mathematischen Gewebes.

Nach genügend Training

Irgendwann sieht das Modell:

Die Hauptstadt von Frankreich ist

und seine Ausgabeverteilung sieht vielleicht eher so aus:

Paris — 92%
Lyon — 1.2%
Marseille — 0.7%
London — 0.3%

Paris gewinnt jetzt mühelos.

Wo ist die Tatsache also gespeichert?

Nicht in einem Gewicht.

Nicht in einem Neuron.

Nicht in einem versteckten Texteintrag.

Der Zusammenhang ist über das Netz verteilt.

Deshalb kann das Modell auch antworten auf:

Welche Stadt dient als Hauptstadt von Frankreich?

oder:

Wie heißt Frankreichs Hauptstadt?

Der genaue Satz hat sich geändert.

Aber die zugrunde liegenden Zusammenhänge zwischen den Begriffen sind weiterhin nützlich.

Das Modell sucht nicht einfach den exakten Trainingssatz.

Es rechnet durch ein gelerntes Netz numerischer Beziehungen.

Deshalb kann auch die scheinbar einfache Aufgabe der nächsten Tokenvorhersage zu erstaunlich vielfältigem Verhalten führen.

Um Sprache gut vorherzusagen, hilft es, Grammatik zu lernen.

Bedeutung.

Fakten.

Zusammenhänge.

Stil.

Struktur.

Denkmuster.

Das Ziel ist einfach:

Sage voraus, was als Nächstes kommt.

Was das Modell lernen muss, um darin außergewöhnlich gut zu werden, ist es nicht.

Letztlich spiegeln sich diese gelernten Zusammenhänge in seinen Gewichten wider.

Hunde, Katzen und warum „Merkmalswichtigkeit“ irreführen kann

Eine verbreitete Erklärung neuronaler Gewichte verwendet Bildklassifikation.

Angenommen, ein Modell wird darauf trainiert, Hunde von Katzen zu unterscheiden.

Es könnte entdecken, dass bestimmte visuelle Muster der Schnauzenform, Ohren, Gesichtsstruktur oder Körperform nützlicher sind als andere.

Das ist eine hilfreiche Vorstellung.

Man sollte sie aber nicht wörtlich nehmen.

Ein modernes Netz enthält normalerweise nicht:

Ohrengewicht = 0.84

Fellfarbengewicht = 0.17

Frühe Schichten können auf relativ einfache Muster wie Kanten ansprechen.

Spätere Schichten können daraus Texturen und Formen kombinieren.

Noch spätere Darstellungen können auf zunehmend komplexe Strukturen reagieren.

Die endgültige Klassifikation entsteht aus dem Zusammenspiel vieler Schichten und Parameter.

Wenn wir also sagen:

Das Modell hat gelernt, dass die Ohrenform wichtig ist

übersetzen wir einen komplexen verteilten Zahlenprozess in menschliche Sprache.

Es gibt keinen Regler mit der Aufschrift OHR.

2012: Die GPU betritt die Bühne

Neuronale Netze gab es seit Jahrzehnten.

Warum wuchsen ihre Fähigkeiten plötzlich so schnell?

Ein wichtiger Grund war die Hardware.

2012 präsentierten Alex Krizhevsky, Ilya Sutskever und Geoffrey Hinton das später als AlexNet bekannte tiefe Bilderkennungsnetz mit ungefähr sechzig Millionen Parametern.

Ein entscheidender Bestandteil war der Einsatz von Grafikprozessoren, den GPUs.

GPUs hatten sich hauptsächlich entwickelt, weil Computergrafik gewaltige Mengen ähnlicher mathematischer Operationen parallel benötigt.

Videospiele mussten Pixel, Dreiecke, Beleuchtung und Texturen schnell verarbeiten.

Neuronale Netze sahen sich diese Hardware an und sagten gewissermaßen:

„Diese Multiplikationsmaschine sieht nützlich aus.“

Die Spieleindustrie hatte versehentlich jahrelang an der Infrastruktur für maschinelles Lernen mitgearbeitet.

Irgendwo verdient ein virtueller Drache einen Teil der Anerkennung für moderne KI.

Von einzelnen Gewichten zu Tensoren

Unser winziges Neuron verwendete einzelne Werte wie:

und:

Ein echtes Netz kann Milliarden Parameter nicht bequem auf diese Weise verwalten.

Stattdessen werden die Zahlen in Strukturen namens Tensoren organisiert.

Eine einfache Zahlenliste kann man sich als eindimensionalen Tensor vorstellen.

Eine rechteckige Zahlentabelle ist ein zweidimensionaler Tensor, gewöhnlich Matrix genannt.

Sammlungen mit noch mehr Dimensionen sind ebenfalls Tensoren.

Große Teile neuronaler Berechnungen lassen sich kompakt ausdrücken, etwa so:

Übersetzen wir auch das.

$X$ steht für eine Sammlung von Eingabezahlen.

$W$ steht für eine Matrix gelernter Gewichte.

Die Multiplikation:

kombiniert viele Eingabewerte mit vielen gelernten Gewichten nach den Regeln der Matrixmultiplikation.

Das Ergebnis:

ist eine neue Sammlung umgewandelter Zahlenwerte.

Die Schreibweise sieht winzig aus.

Die eigentliche Berechnung kann Millionen oder Milliarden einzelner Multiplikationen und Additionen enthalten.

Deshalb sind GPUs so wertvoll.

Sie können enorme Mengen dieser Rechenoperationen parallel ausführen.

Während die KI scheinbar gelassen über Dostojewski spricht, multipliziert die GPU im industriellen Maßstab.

Das Gespräch wirkt intellektuell.

Die Hardware sieht Arithmetik.

2017: Aufmerksamkeit verändert die Architektur

2017 stellte die Arbeit „Attention Is All You Need“ die Transformer-Architektur vor.

Transformer wurden zur Grundlage der meisten modernen großen Sprachmodelle.

Die Architektur führte eine leistungsfähige Möglichkeit ein, verschiedene Teile einer Sequenz durch Aufmerksamkeit miteinander interagieren zu lassen.

Doch die Aufmerksamkeit schaffte die Gewichte nicht ab.

Ganz im Gegenteil.

Transformer enthalten überall in ihrer Architektur große gelernte Matrizen.

Aufmerksamkeit verwendet gelernte Projektionsmatrizen.

Vorwärtsgerichtete Schichten verwenden gelernte Matrizen.

Embedding-Systeme enthalten gelernte Parameter.

Die Architektur wurde dramatisch ausgefeilter.

Die grundlegende Währung blieben Zahlen.

2020: 175 Milliarden werden zur Schlagzeile

Dann kam die Größe.

2020 wurde GPT-3 vorgestellt mit:

175 Milliarden Parametern.

Vergleiche das mit den ungefähr sechzig Millionen Parametern von AlexNet nur acht Jahre zuvor.

Das Gebiet war von Millionen gelernter Werte zu Hunderten Milliarden übergegangen.

Die Grundidee blieb erkennbar:

Lerne nützliche numerische Parameter aus Daten.

Forscher verbesserten die Architektur.

Trainingsmethoden wurden besser.

Datensätze wuchsen.

GPU-Cluster wurden riesig.

Dann fügten wir, wie so oft in der Informatik, eine unvernünftige Anzahl Nullen hinzu.

Was enthält ein 8B-Modell physisch?

Nun werden Parameterzahlen konkret.

Sie werden zu einem physischen Speicherproblem.

Angenommen, ein Modell enthält:

Parameter.

Das bedeutet ungefähr acht Milliarden gelernte Zahlenwerte.

Angenommen, jeder Parameter wird mit sechzehn Bit gespeichert.

Sechzehn Bit entsprechen:

Der ungefähre reine Parameterspeicher beträgt damit:

Das ergibt:

oder ungefähr:

Woher kommen diese sechzehn Gigabyte?

Nichts Geheimnisvolles.

Wir haben acht Milliarden Zahlen.

Jede benötigt zwei Byte.

Acht Milliarden mal zwei ergeben ungefähr sechzehn Milliarden Byte.

Betrachte nun ein Modell mit siebzig Milliarden Parametern bei derselben Genauigkeit.

Die Rechnung lautet:

Das ergibt ungefähr:

nur für die Speicherung der Parameter selbst.

Plötzlich ist:

„70B-Modell“

nicht mehr bloß ein Modellname.

Es ist ein Hardwareproblem.

Deine GPU wird aufmerksam.

Dein System-RAM könnte aufmerksam werden.

Irgendwann wird dein Geldbeutel aufmerksam.

Quantisierung: Was verkleinern wir eigentlich?

Angenommen, sechzehn Bit pro Parameter benötigen zu viel Speicher.

Können wir dieselben gelernten Werte mit weniger Bit darstellen?

Das ist die Grundidee der Quantisierung.

Nehmen wir unser hypothetisches 8B-Modell.

Bei sechzehn Bit pro Parameter beträgt sein idealisierter reiner Parameterspeicher ungefähr:

Nun stellen wir viele Gewichte stattdessen mit ungefähr vier Bit dar.

Vier Bit sind ein halbes Byte:

Also ergibt:

ungefähr:

Wichtig ist, was nicht passiert ist.

Wir haben aus einem Modell mit acht Milliarden Parametern kein Modell mit zwei Milliarden gemacht.

Das Modell besitzt noch ungefähr dieselbe Parameterzahl.

Wir haben geändert, mit welcher numerischen Genauigkeit sie dargestellt werden.

Eine einfache Vorstellung ist das Runden von Zahlen.

Du könntest speichern:

oder:

Die zweite Zahl ist weniger genau.

Echte Quantisierung neuronaler Netze ist deutlich ausgefeilter als das bloße Runden von Nachkommastellen. Praktische Verfahren verwenden Skalierungsfaktoren, Gruppen, spezielle Kodierungen und weitere Techniken, um bei geringerem Speicherbedarf nützliches Verhalten zu erhalten.

Der zentrale physische Zusammenhang bleibt jedoch:

weniger Bit pro Gewicht → weniger Speicher

Deshalb verbringen Nutzer lokaler KI erstaunliche Teile ihres Lebens mit Debatten über Q4, Q5, Q6 und Q8.

Aus der Ferne klingt es nach Motoröl.

Meist geht es darum, Milliarden Zahlen in eine Grafikkarte zu bekommen.

Gewichte sind keine Aktivierungen

Beim Thema Hardware ist eine weitere Unterscheidung enorm wichtig.

Gewichte bleiben erhalten.

Sie werden als Teil des Modells gespeichert.

Schalte den Rechner aus.

Lade morgen dasselbe Modell.

Die gelernten Gewichte bleiben.

Aktivierungen sind vorübergehend.

Wenn eine Eingabe durch das Netz läuft, erzeugt jede Schicht numerische Zwischenzustände.

Diese Werte hängen von der aktuellen Eingabe ab.

Ändere den Prompt, und die Aktivierungen ändern sich.

Denke an eine Fabrik.

Die Gewichte sind die installierten Maschinen.

Die Aktivierungen sind das Material, das gerade durch diese Maschinen läuft.

Das erklärt, warum das Laden der Modellgewichte in den GPU-Speicher nicht den gesamten Speicherbedarf abdeckt.

Auch die Berechnung selbst braucht Arbeitsraum.

Sprachmodelle können außerdem beträchtlichen Speicher für einen Schlüssel-Wert-Cache, den KV-Cache, verwenden. Er speichert nützliche Zwischeninformationen aus bereits verarbeiteten Tokens.

Mit wachsendem Kontext kann auch dieser Cache wachsen.

Daher bedeutet:

Die Gewichte passen in den VRAM

nicht automatisch:

Das Modell kann in diesem VRAM bequem arbeiten.

Das Sofa passt vielleicht durch die Wohnungstür.

Du möchtest trotzdem noch irgendwo stehen können.

Ändern sich die Gewichte, während du mit dem Modell chattest?

Normalerweise:

Nein.

Wenn ein trainiertes Modell einen Prompt beantwortet, führt es Inferenz aus.

Inferenz bedeutet:

Verwende die vorhandenen gelernten Parameter, um eine Ausgabe zu berechnen.

Die Gewichte werden gelesen.

Sie werden normalerweise nicht umgeschrieben, weil du eine Frage gestellt hast.

Zum Glück.

Sonst könnte ein einziges hinreichend seltsames Gespräch das Netz dauerhaft umgestalten.

Ein Gespräch erzeugt vorübergehenden Zustand: Kontext, Aktivierungen, KV-Cache, Werkzeugergebnisse und andere Arbeitsinformationen.

Diese unterscheiden sich von den dauerhaft gespeicherten trainierten Parametern.

Die einfachste Zusammenfassung lautet:

Training verändert Gewichte. Inferenz verwendet Gewichte.

Dieser Satz erklärt unglaublich viel über KI.

Feinabstimmung: Die Zahlen erneut verändern

Ein vortrainiertes Modell kann später zusätzlich trainiert werden.

Dieser Vorgang heißt Feinabstimmung.

Stelle dir ein allgemeines Modell vor, das Sprache bereits versteht.

Du könntest es feinabstimmen auf:

juristische Texte,

medizinische Fachbegriffe,

Programmierbeispiele,

Kundendienstgespräche,

Finanzanalysen,

oder ein anderes Fachgebiet.

Das Training verändert erneut Parameter, damit das Modell besser zur neuen Aufgabe passt.

Vollständige Feinabstimmung kann riesige Parametermengen aktualisieren und erhebliche Rechenressourcen erfordern.

Andere Methoden wie Low-Rank Adaptation, kurz LoRA, trainieren viel kleinere zusätzliche Parameterstrukturen und lassen den Großteil des ursprünglichen Modells unverändert.

Die praktische Unterscheidung ist wichtig.

Dem Modell während eines Gesprächs ein PDF zu geben, verändert normalerweise seinen Kontext.

Feinabstimmung verändert gelernte Parameter.

Das eine liefert vorübergehende Informationen.

Das andere verändert das trainierte Modell.

Das Modell ist nicht das ganze System

Angenommen, zwei Menschen laden genau dasselbe Modell herunter.

Derselbe Checkpoint.

Dieselben Gewichte.

Dieselbe Quantisierung.

Einer baut ein hervorragendes Recherchesystem.

Der andere erzeugt unzuverlässige Antworten mit wunderschöner Formatierung.

Wie ist das möglich?

Weil das Modell nur eine Komponente ist.

Drumherum können Prompts, Suchsysteme, Datenbanken, Speicher, Werkzeuge, Browser, Weiterleitung, Berechtigungen, Prüfungen und Anwendungscode liegen.

Diese umgebende Software wird manchmal Harness oder Agentenumgebung genannt.

Der Harness schreibt normalerweise nicht bei jeder neuen Anfrage die Modellgewichte um.

Er steuert, welche Informationen das Modell erreichen, welche Werkzeuge es benutzen kann und was mit dem Ergebnis geschieht.

Dieselben Gewichte.

Andere Umgebung.

Anderes Verhalten.

Der Motor kann identisch sein.

Das Fahrzeug muss es nicht.

Was ist ein Modell mit offenen Gewichten?

Während des Trainings ändern sich die Parameter ständig.

An sinnvollen Stellen speichern Entwickler ihren aktuellen Zustand.

Dieser gespeicherte Zustand heißt Checkpoint.

Ein Checkpoint ist im Wesentlichen eine Momentaufnahme des gelernten numerischen Modellzustands zu einem bestimmten Zeitpunkt.

Werden diese trainierten Parameterdateien zum Herunterladen bereitgestellt, wird das Modell meist als Open-Weight-Modell bezeichnet.

Je nach Lizenz dürfen Menschen es lokal ausführen, quantisieren, feinabstimmen, untersuchen, in Produkte integrieren oder abgeleitete Versionen weitergeben.

Es gibt jedoch eine wichtige begriffliche Unterscheidung.

Offene Gewichte bedeuten nicht automatisch Open Source.

Ein Entwickler kann Gewichte veröffentlichen und trotzdem Trainingsdaten, Teile des Trainingscodes, das vollständige Trainingsverfahren oder andere Komponenten privat halten.

Auch Lizenzen können Einschränkungen vorsehen.

Das sind also zwei verschiedene Fragen:

Kann ich die trainierten Gewichte herunterladen?

und:

Ist der gesamte Entwicklungsprozess des Modells offen?

Die Antworten müssen nicht dieselben sein.

Wörter sind wichtig.

Besonders, wenn Anwälte dazukommen.

Warum offene Gewichte alles veränderten

Ein leistungsfähiges Basismodell von Grund auf zu trainieren, kann enorme Ressourcen erfordern:

Daten, GPU-Cluster, Strom, Entwicklungsarbeit, Zeit und Geld.

Trainierte Gewichte herunterzuladen erlaubt jemand anderem, erst nach diesem teuren Training anzufangen.

Du erhältst den gelernten numerischen Zustand.

Du wiederholst nicht die gesamte Ausbildung.

Forschern ermöglicht das Untersuchungen.

Entwicklern ermöglicht es lokalen Betrieb und Experimente.

Organisationen kann es mehr Kontrolle geben.

Und für Hobbyanwender und technisch Neugierige entsteht etwas, das vor nicht allzu langer Zeit außergewöhnlich geklungen hätte:

Ein Modell, das auf industrieller Infrastruktur trainiert wurde, kann schließlich als Dateien auf einem Computer bei dir zu Hause landen.

Der Trainingscluster belegt vielleicht ein Rechenzentrum.

Der fertige Checkpoint landet womöglich auf einer SSD unter deinem Schreibtisch neben drei USB-Kabeln, an deren Kauf sich niemand erinnert.

Eine beachtliche Reise für einen Tensor.

Was Gewichte nicht sind

Nach all dem lassen sich mehrere Missverständnisse leichter ausräumen.

Gewichte sind keine Datenbank.

Es gibt keine Zeile mit:

capital_of_france = Paris

Ein einzelnes Gewicht ist normalerweise kein für Menschen lesbarer Begriff.

Wenn du:

in einem Tensor findest, sagt dir das allein fast nichts.

Gewichte ändern sich normalerweise nicht während gewöhnlicher Inferenz.

Training verändert sie.

Inferenz verwendet sie.

Ein Gewicht entspricht im Allgemeinen nicht einem Merkmal.

Bedeutung ist über viele Parameter und Schichten verteilt.

Parameterzahl ist nicht gleich Intelligenz.

Die Architektur zählt.

Die Trainingsdaten zählen.

Die Optimierung zählt.

Das Nachtraining zählt.

Der Umgang mit Kontext zählt.

Die Umgebung zählt.

Ein Idiot mit achtzig Milliarden Parametern wäre immer noch ein Idiot.

Er bräuchte lediglich eine teurere GPU.

Gewichte und Parameter

Die Wörter Gewicht und Parameter werden oft nahezu austauschbar verwendet.

Im normalen Gespräch ist das gewöhnlich in Ordnung.

Technisch ist Parameter der umfassendere Begriff.

Gewichte sind Parameter.

Bias-Werte, Normalisierungswerte und andere trainierbare Werte können ebenfalls Parameter sein.

Wenn jemand also sagt:

„Das ist ein 70B-Modell“,

bedeutet das genauer:

Das Modell enthält ungefähr siebzig Milliarden gelernte Parameter.

Die meisten dieser Parameter befinden sich in großen gelernten Matrizen.

Die Menschen werden sie weiter Gewichte nennen.

Die Zivilisation wird es vermutlich überleben.

Was bedeutet es, wenn ein Modell etwas „weiß“?

Nun berührt die Mathematik die Philosophie.

Ein Sprachmodell enthält keinen Miniaturbibliothekar, der Faktenregale durchsucht.

Im Transformer versteckt sich keine winzige SQL-Datenbank.

Stattdessen formt das Training Milliarden numerischer Beziehungen so, dass bestimmte Eingabemuster tendenziell nützliche Ausgabemuster erzeugen.

Frage:

Die Hauptstadt von Frankreich ist —

und das gelernte Netz bevorzugt deutlich:

Paris.

Bitte um Python-Code, und ein anderes Muster interner Aktivität erscheint.

Frage nach mittelalterlicher Geschichte, und noch ein anderes entsteht.

Dieselben dauerhaft gespeicherten Gewichte wirken an all diesen Verhaltensweisen mit.

Wenn wir sagen, ein Modell weiß etwas, meinen wir mathematisch daher eher:

Seine gelernten Parameter haben eine Konfiguration erreicht, die ein Verhalten erzeugt, das zum Erlernen dieser Information oder Fähigkeit passt.

Ob dafür dasselbe Wort Wissen angemessen ist wie bei Menschen, ist eine viel größere philosophische Frage.

Am besten versucht man das wohl nach dem Abendessen.

Die ganze Geschichte in zwei Diagrammen

Für alle, die das technische Gerüst möchten, ohne die ganze Reise zu wiederholen, lässt sich Inferenz so zusammenfassen:

In Alltagssprache:

Gib dem trainierten Netz eine Eingabe.
Leite sie durch Schichten mit gelernten Gewichten.
Erzeuge vorübergehende interne Zustände.
Erzeuge eine Ausgabe.

Training ergänzt eine zweite Schleife:

In Alltagssprache:

Mache eine Vorhersage.
Miss, wie falsch sie war.
Berechne, welche Parameteränderungen den Fehler verringern sollten.
Aktualisiere diese Parameter.

Dann wiederholen.

Und wiederholen.

Und wiederholen.

Oder in der kürzesten technisch nützlichen Fassung:

Inferenz verwendet die Zahlen. Training verändert die Zahlen.

Alles andere ist Architektur, Daten, Optimierung, Hardware und Maßstab.

Zugegeben, diese vier Themen haben ziemlich vielen Forschern Arbeit verschafft.

Warum dich das interessieren sollte, selbst wenn du nie etwas trainierst

Die meisten Menschen, die lokale KI betreiben, werden nie einen Gradienten von Hand berechnen.

Das ist völlig in Ordnung.

Die meisten Autofahrer fertigen ihre Kurbelwellen auch nicht selbst.

Wer Gewichte versteht, kann jedoch vieles erklären, dem technisch neugierige KI-Nutzer irgendwann begegnen.

Warum umfasst ein 8B-Modell mehrere Gigabyte?

Weil Milliarden gelernter numerischer Parameter physisch gespeichert werden müssen.

Warum braucht Q4 viel weniger Speicher als sechzehn Bit Genauigkeit?

Weil viele dieser Parameter mit weniger Bit dargestellt werden.

Warum kann Quantisierung das Verhalten leicht verändern?

Weil sich die numerische Genauigkeit verändert hat.

Warum kann Feinabstimmung ein Modell verändern?

Weil zusätzliches Training Parameter verändert.

Warum lernt das Modell durch ein hochgeladenes PDF nicht dauerhaft?

Weil das PDF den aktuellen Kontext verändert, nicht die dauerhaft gespeicherten Gewichte.

Warum können sich zwei Systeme mit identischen Modellgewichten ganz unterschiedlich verhalten?

Weil das Modell nur ein Teil seiner Umgebung ist.

Und warum kann man überhaupt ein trainiertes KI-Modell herunterladen?

Weil sich ein großer Teil des Trainingsergebnisses als gewaltige Sammlungen gelernter numerischer Parameter bewahren lässt.

Die Idee begann mit winzigen mathematischen Neuronen.

Dann kamen trainierbare Perzeptronen.

Rückpropagation machte mehrschichtiges Lernen praktikabel.

GPUs lieferten außergewöhnliche Mengen paralleler Arithmetik.

Transformer ordneten die Sprachverarbeitung neu.

Die Parameterzahlen wuchsen von Millionen auf Milliarden und darüber hinaus.

Der Maßstab veränderte sich fast bis zur Unkenntlichkeit.

Die zentrale Schleife blieb erstaunlich vertraut:

Mache eine Vorhersage.

Miss den Fehler.

Berechne, was sich ändern sollte.

Verändere die Zahlen ein wenig.

Versuche es erneut.

Tue das oft genug, mit genügend Daten, Mathematik, Hardware und Strom —

und irgendwann beginnen die Zahlen zu antworten.