Die Funktionsweise von Sprachmodellen mit dem kleinen Sprachmodell GuppyLM direkt erleben

 (github.com/arman-bd)
46 Punkte von GN⁺ 23 일 전 | 1 Kommentare | Auf WhatsApp teilen
  • Ein ultrakleines Sprachmodell mit etwa 9 Millionen Parametern, das sich in unter 5 Minuten mit nur einem Colab-Notebook trainieren lässt
  • Vom Erzeugen der Daten über den Tokenizer bis zu Modelltraining und Inferenz läuft der gesamte Prozess in einer einzigen Umgebung ab; unterstützt werden Browser, Colab und lokal
  • Entworfen als Figur „Guppy“, die sich eine Unterwasserumgebung vorstellt, spricht es in kurzen, einfachen Sätzen und legt den Fokus auf didaktische Transparenz
  • Verwendet eine grundlegende Transformer-Architektur und zeigt so auch ohne komplexe Techniken klar die Kernstruktur eines Sprachmodells
  • Ein Open-Source-Projekt mit öffentlichen HuggingFace-Datensätzen und MIT-Lizenz, mit dem jede*r experimentieren und lernen kann

Überblick über GuppyLM

  • GuppyLM ist ein ultrakleines Sprachmodell mit rund 9 Millionen Parametern, das wie die Fischfigur „Guppy“ spricht
  • Es wurde mit dem Ziel entwickelt, ein LLM zu schaffen, das sich in weniger als 5 Minuten direkt in einem einzigen Colab-Notebook trainieren lässt; von der Datenerzeugung über den Tokenizer und die Modellarchitektur bis hin zu Trainingsschleife und Inferenz ist der gesamte Ablauf in einer einzigen Umgebung möglich
  • Es wurde so gebaut, dass man die interne Funktionsweise von Sprachmodellen direkt erleben kann, ganz ohne große GPU-Cluster oder Spezialwissen
  • Es erzeugt keine langen Texte wie große Modelle, ist dafür aber ein Lehrmodell, das den kompletten Weg von Eingabe über Gewichtslernen bis zur Ausgabe transparent zeigt
  • Es läuft in Browser-, Colab- und lokalen Umgebungen, und Datensatz sowie Modell sind über HuggingFace öffentlich verfügbar

Modelleigenschaften

  • GuppyLM ist als Figur angelegt, die rund um eine Unterwasserwelt mit Wasser, Temperatur, Licht, Vibrationen und Futter denkt
  • Es verwendet kurze Sätze in Kleinschreibung und versteht keine abstrakten menschlichen Konzepte wie Geld oder Politik
  • Es hat einen freundlichen, neugierigen und einfachen Charakter
  • Die Trainingsdaten bestehen aus 60 Themen und 60.000 synthetischen Dialogbeispielen; das Training ist auf einer einzelnen GPU in etwa 5 Minuten möglich
  • Durch die geringe Modellgröße ist auch WebAssembly-basierte Inferenz direkt im Browser möglich

Architektur

  • Parameterzahl: 8,7M
  • Anzahl der Layer: 6
  • Hidden-Dimension: 384
  • Attention-Heads: 6
  • FFN-Dimension: 768 (ReLU)
  • Vokabulargröße: 4.096 (BPE)
  • Maximale Sequenzlänge: 128 Token
  • Normalisierung: LayerNorm
  • Positions-Embeddings: trainierbar
  • LM-Head: teilt Gewichte mit dem Embedding
  • Eine grundlegende Transformer-Struktur ohne komplexe Verfahren wie GQA, RoPE, SwiGLU oder early exit

Persönlichkeit und Gesprächsthemen

  • Guppy spricht in kurzen Sätzen, Kleinschreibung und mit sinneszentriertem Denken
  • Es reagiert auf verschiedene Themen wie Futter, Wasser, Licht, Aquarium, Blasen, Reflexionen, Wasseroberfläche und die Außenwelt
  • Zu den 60 Hauptthemen gehören unter anderem Begrüßung, Gefühle, Temperatur, Futter, Licht, Wasser, Aquarium, Lärm, Einsamkeit, Träume, Jahreszeiten, Witze, Liebe, Gesundheit und TV

Ausführung und Verwendung

  • Im Browser ausführen

    • Führt lokale Inferenz auf Basis von WebAssembly aus
    • Ein etwa 10 MB großes quantisiertes ONNX-Modell wird heruntergeladen und kann ohne Server oder API-Schlüssel ausgeführt werden

  • In Colab chatten

    • Lädt ein vortrainiertes Modell von HuggingFace herunter und nutzt es über eine interaktive Oberfläche
    • Nach dem Ausführen aller Zellen kann sofort gechattet werden

  • In Colab trainieren

    • Die Runtime auf T4 GPU setzen und dann alle Zellen ausführen
    • Führt automatisch Datensatz-Download, Tokenizer-Training, Modelltraining und Tests aus
    • Das resultierende Modell kann zu HuggingFace hochgeladen oder lokal gespeichert werden

  • Lokal chatten

    • Nach pip install torch tokenizers mit dem Befehl python -m guppylm chat ausführen
    • Bei längeren Gesprächen sinkt die Qualität wegen der Grenze von 128 Token
    • Unterstützt auch einen Modus, bei dem nach einer einzelnen Prompt-Eingabe nur eine Antwort zurückgegeben und das Programm beendet wird

Datensatz

  • Verwendet den HuggingFace-Datensatz arman-bd/guppylm-60k-generic
  • Anzahl der Beispiele: 60.000 (Training 57K / Test 3K)
  • Format: {"input": "...", "output": "...", "category": "..."}
  • Anzahl der Kategorien: 60
  • Erzeugungsmethode: templatebasierte synthetische Daten
    • Mit etwa 60 Templates, 30 Aquarium-Objekten, 17 Futterarten und 25 Aktivitätskombinationen werden rund 16.000 einzigartige Ausgaben erzeugt

Projektstruktur

  • guppylm/

    • config.py: Modell- und Trainings-Hyperparameter
    • model.py: grundlegendes Transformer-Modell
    • dataset.py: Laden der Daten und Batch-Verarbeitung
    • train.py: Trainingsschleife (cosine LR, AMP)
    • generate_data.py: Erzeugung von Dialogdaten für 60 Themen
    • eval_cases.py: Testfälle
    • prepare_data.py: Datenvorbereitung und Tokenizer-Training
    • inference.py: Chat-Oberfläche

  • tools/

    • make_colab.py: Erzeugt ein Colab-Notebook
    • export_onnx.py: Export als ONNX-Modell (uint8-Quantisierung)
    • export_dataset.py: Lädt den Datensatz zu HuggingFace hoch
    • dataset_card.md: Datensatzbeschreibung für HuggingFace

  • docs/

    • index.html: Browser-Demo (ONNX + WASM)
    • download.sh: Download von Modell und Tokenizer
    • model.onnx: quantisiertes Modell (~10MB)
    • tokenizer.json: BPE-Tokenizer
    • guppy.png: Logo-Bild

Designentscheidungen

  • Entfernung des System-Prompts: Ein 9M-Modell kann bedingten Anweisungen nur schwer folgen; statt in allen Beispielen denselben Prompt zu verwenden, wurde die Persönlichkeit direkt in die Gewichte eingebettet

    • Dadurch werden bei der Inferenz etwa 60 Token eingespart
    • Single-Turn-Gespräche: Wegen der Grenze von 128 Token sinkt die Qualität nach 3–4 Turns
    • Das passt zwar zum Konzept von Guppys „Goldfisch-Gedächtnis“, dennoch sind Single-Turn-Eingaben am stabilsten
    • Beibehaltung des grundlegenden Transformers: GQA, SwiGLU, RoPE und early exit bringen bei einer Größe von 9M keine Qualitätsverbesserung und erhöhen nur die Komplexität
    • Mit der Kombination aus Standard-Attention + ReLU-FFN + LayerNorm wird ausreichend Leistung erreicht
    • Verwendung synthetischer Daten: Um eine konsistente Persönlichkeit beizubehalten, wurde ein templatebasierter Ansatz zur Datengenerierung gewählt

Lizenz

  • MIT-Lizenz

Verwandte Beiträge

1 Kommentare

 
GN⁺ 23 일 전
Hacker-News-Kommentare

  • Ich frage mich, ob es eine Dokumentation zu diesem Projekt gibt.
    Der Code selbst wirkt wie eine der einfachsten Implementierungen eines (Not So) Large Language Model, aber für Entwickler, die mit Multi-Head Attention, ReLU-FFN, LayerNorm, Positional Embedding usw. nicht vertraut sind, ist er nicht leicht zu verstehen.
    Dieses Projekt hat einen pädagogischen Charakter ähnlich wie Minix. So wie Minix als Werkzeug zum Erlernen von Betriebssystemdesign genutzt wurde, ist es auch ein guter Ansatz, wenn Studierende durch das Hinzufügen von Funktionen zu GuppyLM den Entwurf von LLMs lernen.

    • Es wäre vermutlich auch eine gute Methode, den Code in ein LLM einzugeben und darüber zu sprechen.

  • Ich frage mich, worin sich dieses Projekt von Andrej Karpathys microgpt oder minGPT unterscheidet.

    • Ich habe es noch nicht verglichen, bin aber dankbar für den Hinweis. Ich werde mir beide Projekte ansehen.
    • Der Vergleich ist nicht entscheidend. Das hier ist kein Produkt, sondern ein cooles experimentelles Projekt.

  • Auf bbycroft.net/llm gibt es ein Beispiel für eine 3D-Visualisierung kleiner LLM-Layer. Das hilft sehr dabei, die interne Funktionsweise zu verstehen.
    Eine zugehörige Diskussion gibt es auch hier.

    • Ziemlich cool! Ich werde es mir noch genauer ansehen.
    • Nicht direkt relevant, aber das Projekt ist wirklich großartig. Es wäre vielleicht gut, noch etwas mehr UI hinzuzufügen.
    • Eine interessante Visualisierung.

  • Wirklich hervorragend als Einstieg in LLMs.
    Ich habe früher einmal mein eigenes Modell auf Basis von Miltons Paradise Lost gebaut.
    Siehe: wvrk.org/works/milton

  • Das liegt vermutlich daran, dass die Trainingsdaten komplett kleingeschrieben sind.

    You> hello
Guppy> hi. did you bring micro pellets.
You> HELLO
Guppy> i don't know what it means but it's mine.
    • Gute Beobachtung! Offenbar gibt es im Tokenizer überhaupt keine Tokens für Großbuchstaben.
      Trotzdem kommt die Reaktion des Charakters noch klar rüber.

  • Ich frage mich, ob es möglich wäre, ein LLM zu bauen, das nur mit Toki Pona trainiert wurde.
    Siehe Toki-Pona-Wiki.

    • Dafür gibt es aber nicht genug Trainingsdaten. Der Kern von LLMs sind gewaltige Datenmengen und Rechenressourcen.

  • Ich arbeite an einem Projekt, in dem mehrere LLM-Agenten sich eine gemeinsame virtuelle Welt teilen und autonom miteinander interagieren.
    Das Überraschende ist, dass die Existenz einer „Welt“ einen großen Einfluss auf das Verhalten des Modells hat.
    Selbst bei demselben Modell und demselben Prompt fällt das Ergebnis völlig anders aus, wenn sich Umgebungsfaktoren wie Ressourcenbeschränkungen, andere Agenten oder persistenter Speicher ändern.
    Wir konzentrieren uns nur auf die Optimierung des Modells selbst und denken viel zu wenig über seine Betriebsumgebung nach.

  • Endlich fühlt es sich so an, als gäbe es ein ehrliches LLM über die Welt.
    Die Antwort „Der Sinn des Lebens ist Essen“ scheint weniger falsch zu sein als das, was Modelle liefern, die 10.000-mal größer sind.

    • Vielleicht ist das sogar eine bessere Deutung als die berühmte Antwort.
    • Der Zweck des Lebens ist Fortpflanzung. Essen ist nur das Mittel dazu, und alle Ressourcen und Eigenschaften existieren, um die Paarung zu unterstützen.

  • Die Idee ist gut, aber die Beispiele wirken, als seien sie direkt aus den Trainingsdaten kopiert.
    Ich frage mich, wie es mit unbekannten Anfragen umgeht.

    • Kaum. Mit 9M Parametern ist die Kapazität sehr begrenzt.
      Der Zweck dieses Projekts ist es, die Funktionsweise von LLMs zu demonstrieren.

  • Tolle Arbeit. Danke fürs Teilen.
    Ich frage mich aber, ob sich LLMs jetzt wirklich so anfühlen, als seien sie „entzaubert“.
    Es ist immer noch erstaunlich, dass allein aus einfacher Statistik und gewaltiger Rechenleistung solche Ergebnisse entstehen.