So führen Sie ein neuronales Netz mit 744 Milliarden Parametern auf einem normalen Computer aus

Wenn Sie die Seite eines Modells wie GLM-5.2 mit 744 Milliarden Parametern oder Kimi K3 mit 2,8 Billionen Parametern öffnen, ist der erste Gedanke ziemlich klar: Sie brauchen einen Server-Rack mit einem Dutzend H100-GPUs. Wenn Sie diese Ressourcen nicht zur Hand haben, bleibt Ihnen nur die Möglichkeit, für API-Aufrufe zu bezahlen.

Kürzlich bin ich auf das Projekt JustVugg/colibri gestoßen. Der Autor hat eine schlanke Inferenz-Engine in reinem C ohne Abhängigkeiten von Drittanbietern geschrieben. Die Engine schafft es, massive MoE-Modelle auf einem normalen Desktop oder Laptop mit 24 GB RAM auszuführen, indem sie die Gewichte direkt von einer schnellen SSD lädt.

Wo liegt der Trick

Die Mixture-of-Experts-Architektur (MoE) ist so konzipiert, dass für die Generierung eines einzelnen Tokens nicht das gesamte Modell benötigt wird. Bei GLM-5.2 sind beispielsweise von 744 Milliarden Parametern nur etwa 40 Milliarden aktiv. Darüber hinaus ändern sich von Token zu Token nur etwa 11 GB an Gewichten, entsprechend den vom Router ausgewählten Experten.

Statt zu versuchen, 370 GB Modell in den Videospeicher zu quetschen, verteilt die Engine die Daten über eine Speicherhierarchie:

• Der dichte Teil des Modells (Embeddings, Attention, gemeinsame Schichten) wiegt etwa 9,9 GB in int4-Quantisierung und bleibt dauerhaft im RAM.
• Fast 20.000 Experten befinden sich auf einer schnellen NVMe-SSD und werden bei Bedarf über asynchrone E/A geladen.
• Häufig verwendete Experten siedeln sich im LRU-Cache des RAM oder VRAM an.

  

  Im Wesentlichen funktioniert dies wie ein JIT-Compiler, nur für neuronale Netzwerkgewichte. Die Engine verfolgt Zugriffsstatistiken, merkt sich heiße Zweige und cached genau die Experten, die für den aktuellen Kontext benötigt werden.

  So funktioniert die Engine

  Die Codebasis ist kompakt. Der Kern ist in C geschrieben (jede Modellfamilie ist in einer eigenen Datei abgetrennt, zum Beispiel c/colibri.c für GLM) und lässt sich mit gcc oder clang mit OpenMP-Unterstützung kompilieren. Keine riesigen Frameworks oder monströsen Runtimes. Python wird nur für die einmalige Gewichtungskonvertierung und den Web-Interface-Wrapper verwendet.

  

  Bei der Generierung jedes Tokens führt die Engine mehrere Schritte aus:

  1. Berechnet das Routing eine Schicht voraus durch einen separaten Prefetch-Thread. Der Router sagt den benötigten Experten mit etwa 71% Genauigkeit voraus, sodass Festplattenlesungen parallel zu den Berechnungen erfolgen.
  2. Zusammenführung von Anfragen an identische Experten zu einem Batch, um doppelte Lesevorgänge zu eliminieren.
  3. Liest die drei Matrizen jedes Experten in einem einzigen pread Systemaufruf.
  4. Speichert Trefferstatistiken in einer Historiendatei, sodass bei nachfolgenden Ausführungen heiße Schichten vorab im Speicher fixiert werden.

  Die Unterstützung von zwei Speichergeräten ist interessant implementiert. Wenn Sie Gewichtungskopien auf zwei verschiedene SSDs verteilen, verteilt die Engine Expertenanfragen proportional zur Lesegeschwindigkeit jeder Festplatte. Ein Paar Laufwerke mit 9 GB/s und 3 GB/s beschleunigt das Lesen um etwa ein Drittel.

  

  Für die Beschleunigung der Berechnung werden CUDA, Metal auf Apple-Silicon-Chips und Vulkan unterstützt. Die Vulkan-Variante funktioniert sogar mit älteren GPUs wie der AMD RX 580 über den RADV-Treiber, für den der Hersteller schon lange den Support für das neueste ROCm eingestellt hat.

  

  Das Paket enthält ein Web-Dashboard mit Expertenaktivitätsvisualisierung. Auf der Atlas-Seite können Sie eine 3D-Karte von Tausenden von Experten drehen und beobachten, wie verschiedene Gruppen Code, Rechtsthemen oder Fremdsprachen verarbeiten.

  

  Reale Geschwindigkeitszahlen

  Es gibt keine Wunder, daher ist die Geschwindigkeit durch den Festplattendurchsatz und den verfügbaren Speicher begrenzt.

  

  Die Benchmarks des Projekts erfassten folgende Ergebnisse für das GLM-5.2-Modell:

  • Ein Laptop mit 25 GB RAM und einem kalten Cache liefert bescheidene 0,05-0,1 Tokens pro Sekunde. Es ist langsam, aber das Modell antwortet ohne Logikverzerrung.
  • Ein Workstation mit 128 GB RAM ohne dedizierte GPU liefert etwa 1,8 Tokens pro Sekunde bei einem vorgewärmten Cache.
  • Ein Laptop mit einer mobilen RTX 5070 Ti beschleunigt auf 1,07 Tokens pro Sekunde dank der GPU-Pipeline.
  • Ein Server mit sechs RTX-5090-Karten hält Experten vollständig im Videospeicher und zeigt 5,8-6,8 Tokens pro Sekunde.

  Unterstützte Modelle

  Zusätzlich zum Basis-GLM-5.2 hat der Autor Unterstützung für vier weitere Architekturen hinzugefügt:

  • Inkling (975B) — für das Ausführen des dichten Teils in int4 werden etwa 25 GB RAM und 469 GB Festplattenspeicher benötigt.
  • Kimi K3 (2,8T) — ein Gigant mit 1,6 TB, liest MXFP4-native Gewichte direkt aus Original-Shards ohne Vorkonvertierung.
  • DeepSeek V4 Flash (284B) — arbeitet mit 167 GB Gewichten im fp4/fp8-Format und benötigt 16 bis 22 GB RAM.
  • OLMoE (7B) — eine kompakte Variante mit 4 GB Gewichten für schnelle Experimente auf 8 GB RAM.

  So führen Sie es aus

  Die Engine wird als vorkompilierte Binärdateien für Linux, macOS und Windows verteilt oder kann in einer Minute aus dem Quellcode erstellt werden:

  git clone https://github.com/JustVugg/colibri && cd colibri/c
  ./setup.sh
  

  Nach dem Build laden Sie quantisierte Gewichte für das gewünschte Modell von Hugging Face herunter (z.B. GLM-5.2 int4 benötigt etwa 372 GB) und starten den Chat über das Terminal:

  COLI_MODEL=/path/to/glm52_i4 ./coli chat
  

  Wenn Sie einen lokalen Server möchten, der mit der OpenAI-API kompatibel ist, zusammen mit dem Web-Panel, führen Sie aus:

  ./coli web --model /path/to/glm52_i4
  

  Vor dem Start lohnt es sich, die Speicherverteilung mit ./coli plan zu überprüfen und einen schnellen Hardware-Test mit ./coli tune durchzuführen.

  Wem dieses Projekt nützt

  Colibrì ist für Hochlast-Produktionen aufgrund der Festplattenleselatenz auf Consumer-Hardware kaum geeignet. Es ist jedoch ein großartiger Fund für Forscher, Enthusiasten und Entwickler, die das Reasoning von Top-Open-Source-Modellen lokal testen müssen, ohne Server-GPUs für Millionen von Rubeln zu kaufen. Der Kerncode ist kompakt und transparent, was die Engine bequem als Spielplatz für eigene Experimente mit E/A und Quantisierung macht.