Lokale LLM auf 12 Jahre altem Raspberry Pi (Es funktioniert wirklich!)

DeutschالعربيةEnglishEspañolFrançaisहिन्दीBahasa Indonesia日本語한국어PortuguêsРусский中文
BBetter Stack
Computing/SoftwareConsumer Electronics

Transcript

00:00:00Das hier ist der Raspberry Pi der ersten Generation, der bereits 2014 erschien.
00:00:05Er hat einen 700-MHz-Single-Core-Prozessor und 512 MB RAM.
00:00:12Nach heutigen Standards ist das im Grunde ein Taschenrechner.
00:00:16Aber heute werden wir sehen, ob wir diese 12 Jahre alte Hardware
00:00:21an ihre absoluten Grenzen bringen können, indem wir ein LLM lokal darauf ausführen.
00:00:26In diesem Video zeige ich euch, welches winzige Modell auf einem Raspberry Pi läuft,
00:00:30wir sehen uns die Performance an, und ich zeige euch die Installation aller Abhängigkeiten,
00:00:35damit ihr es selbst ausprobieren könnt.
00:00:37Es wird ein Riesenspaß, also legen wir direkt los.
00:00:40Ehrlich gesagt dachte ich nicht, dass es möglich wäre, ein Modell zu finden,
00:00:47das schlank genug für diese Architektur ist.
00:00:49Aber nach einiger Recherche habe ich tatsächlich einen Kandidaten gefunden.
00:00:52Darf ich vorstellen: Falcon H1 Tiny.
00:00:54Es ist ein unglaublich kompaktes Modell mit nur 90 Millionen Parametern.
00:00:59Entwickelt wurde es vom Technology Innovation Institute in Abu Dhabi,
00:01:03speziell um die extremen Untergrenzen der Sprachmodellierung zu erforschen.
00:01:08Aber wie konnten sie ein Modell so klein machen?
00:01:10Gibt es irgendeine magische technische Geheimzutat dahinter?
00:01:13Nun, nicht wirklich.
00:01:14Sie nutzen im Grunde dieselbe Hybrid-Architektur aus Transformer und Mamba,
00:01:19die Firmen wie IBM für ihre winzigen Granite-4-Modelle verwenden.
00:01:24Dazu habe ich auch ein Video gemacht, falls ihr es euch ansehen wollt.
00:01:27Aber hier ist der Punkt:
00:01:28Um dieses Modell erfolgreich in den Speicher zu quetschen, müssen wir über Quantisierung sprechen.
00:01:33Die Falcon-Modelle sind in 2-Bit-, 4-Bit- und 8-Bit-Versionen verfügbar.
00:01:38Man könnte versucht sein, die ultra-schlanke IQ oder Importance Quantization zu nutzen.
00:01:43Doch da gibt es einen Haken.
00:01:45Diese neueren Methoden beruhen auf einer komplexen Bit-Manipulation,
00:01:49die moderne CPU-Instruktionen benötigt, um effizient zu sein.
00:01:52Auf unserem betagten ARMv6-Chip im Raspberry Pi reicht das nicht aus.
00:01:57Stattdessen müssen wir auf die klassischen Q4-Modelle setzen,
00:02:01was in unserem Fall der Goldstandard ist.
00:02:04Sie nutzen eine mittelgroße Legacy-Quantisierungsmethode,
00:02:07die der Prozessor des Pi tatsächlich ohne Probleme verarbeiten kann.
00:02:11Das liefert uns das beste Intelligenz-pro-Megabyte-Verhältnis bei intakter Logik.
00:02:17Aber dieses Modell auf einem Raspberry Pi der ersten Generation zum Laufen zu bringen, ist keine leichte Aufgabe.
00:02:22Da der Pi die ARMv6-Architektur nutzt,
00:02:26fehlen ihm die modernen Neon-Instruktionen, auf die fast alle AI-Bibliotheken angewiesen sind.
00:02:31Glücklicherweise gibt es llama.cpp, das wir für unsere Inferenz nutzen können.
00:02:36Dazu müssen wir jedoch das Binary speziell für ARMv6 kompilieren.
00:02:42Würde man versuchen, es direkt auf dem Pi zu kompilieren,
00:02:45würde der Compiler wahrscheinlich 18 Stunden dafür brauchen.
00:02:49Vorausgesetzt, er stürzt nicht vorher wegen Speichermangels ab.
00:02:53Um das zu umgehen, müssen wir ein wenig kreativ werden.
00:02:56Wir müssen diese Binaries vorab auf unserem Laptop mittels dock_cross cross-kompilieren,
00:03:02wobei wir gezielt den ARMv6-Befehlssatz mit aktivierter VFP-Matheinheit ansprechen,
00:03:08und sie dann per SSH übertragen, um direkt mit der Inferenz starten zu können.
00:03:13Genau das werden wir jetzt tun.
00:03:15Zuerst flashen wir das schlankste OS mittels Raspberry Pi Imager auf unseren Pi.
00:03:22Bei einem Board mit nur 512 MB RAM zählt wirklich jedes Megabyte.
00:03:28Ich entscheide mich für Raspberry Pi OS Lite in der 32-Bit-Version,
00:03:32da es keine Desktop-Oberfläche hat und im Leerlauf nur einen winzigen Bruchteil
00:03:38des Speichers des Standard-OS belegt, sodass fast der gesamte RAM für das Modell bleibt.
00:03:44Ein weiterer wichtiger Hinweis: Nutzt die erweiterten Einstellungen,
00:03:47um das WLAN vorkonfigurieren und SSH zu aktivieren.
00:03:51Bei diesen alten Boards ist es viel einfacher, alles remote zu verwalten,
00:03:55anstatt sich mit dem trägen lokalen Terminal herumzuschlagen.
00:03:58Sobald der Pi gebootet hat und wir per SSH verbunden sind, widmen wir uns dem ARMv6-Problem.
00:04:05Würden wir versuchen, llama CPP direkt hier zu kompilieren,
00:04:08würde der Pi buchstäblich anderthalb Tage lang nur Header-Dateien wälzen.
00:04:13Stattdessen nutzen wir einen normalen Laptop, um die Rechenzeit zu verkürzen.
00:04:18Klonen wir also den Quellcode von llama CPP und erstellen ein dediziertes
00:04:23Build-Verzeichnis für die Version, die wir auf dem Raspberry Pi nutzen werden.
00:04:28Und hier ist das nächste Problem.
00:04:29Mein Mac nutzt ARMv8, also die 64-Bit-Version, nicht das 32-Bit ARMv6.
00:04:37Und sie haben unterschiedliche Befehlssätze.
00:04:40Um das Binary für den Pi zu kompilieren, benötigen wir dockcross,
00:04:45ein Cross-Compiler-Toolchain, das auf meinem Mac läuft,
00:04:48aber Binaries speziell für die veraltete Architektur des Pi generiert.
00:04:53Als Nächstes müssen wir den Build konfigurieren.
00:04:55Und dabei müssen wir extrem präzise vorgehen.
00:04:58Wir müssen einige sehr spezifische Flags übergeben.
00:05:00Zuerst schalten wir Shared Libs aus, um ein einzelnes, portables Binary zu erhalten.
00:05:05Dann deaktivieren wir Neon, da unserem Pi diese modernen Mathe-Befehle fehlen.
00:05:10Und wir schalten OpenMP aus, um den Speicherbedarf so gering wie möglich zu halten.
00:05:15Wir streichen im Grunde jeden modernen Luxus,
00:05:18damit das Binary mit unserem alten Pi-Board kompatibel ist.
00:05:22Wenn wir jetzt den Build starten, sollten wir in etwa zwei Minuten ein fertig
00:05:26kompiliertes, optimiertes llama-completion Binary für unseren Pi haben.
00:05:31Nun verbinde ich mich per SSH direkt über das Netzwerk mit meinem Pi,
00:05:35erstelle ein neues Verzeichnis und kopiere unser Custom Binary mittels SCP darauf.
00:05:42Eine letzte Sache müssen wir noch tun.
00:05:44Laden wir die 2-Bit-, 4-Bit- und 8-Bit-Legacy-quantisierten Falcon-Modelle herunter,
00:05:50da wir sie alle nacheinander testen werden.
00:05:53Diese kopieren wir dann einzeln über das Netzwerk in den Models-Ordner auf dem Pi.
00:05:58Jetzt kommt der spannende Teil.
00:05:59Wechseln wir zum Pi und führen unseren ersten Inferenz-Test durch.
00:06:03Wir beginnen mit der stärksten Kompression, dem 2-Bit-quantisierten Modell.
00:06:07Dazu müssen wir diesen langen Befehl ausführen.
00:06:10Im Grunde gebe ich ihm einen einfachen Prompt wie
00:06:13„Hallo, wie geht es dir?“ und begrenze die Ausgabe auf 32 Token.
00:06:18Wir geben genau einen Thread an, denn mehr haben wir schlichtweg nicht.
00:06:22Die Kontextgröße halten wir mit 128 Token winzig, um jedes Byte RAM zu sparen.
00:06:29Das wichtigste Flag hier ist jedoch „no M map“.
00:06:32Normalerweise nutzt llama CPP Memory Mapping, was super für High-End-GPUs ist,
00:06:38aber ein Albtraum für unser Pi-Board.
00:06:41Auf einem 32-Bit-System mit nur 512 MB RAM
00:06:45kann M map scheitern, wenn kein zusammenhängender Adressblock frei ist.
00:06:50Indem wir es deaktivieren, erzwingen wir das Laden direkt in den Heap,
00:06:55was uns stabilere Kontrolle über den begrenzten Speicher gibt.
00:06:58Und damit: Führen wir den Befehl aus.
00:07:00Und da sind sie, unsere ersten Token.
00:07:03Wie wir sehen, hat die 2-Bit-Version große Schwierigkeiten.
00:07:08Erstens dauert die Verarbeitung eines einzelnen Tokens etwa alle drei Sekunden,
00:07:14was bei einem alten Raspberry Pi zu erwarten war.
00:07:18Aber noch wichtiger: Die Antwort ist kompletter Unsinn.
00:07:21Bei einem 90-Millionen-Parameter-Modell sind die Gewichte so stark komprimiert,
00:07:25dass die linguistische Logik im Grunde kollabiert ist.
00:07:28Es ist kaum kohärent, aber technisch gesehen funktioniert es.
00:07:32Mal sehen, was passiert, wenn wir zum 4-Bit-Modell wechseln.
00:07:35Und siehe da, jetzt erhalten wir eine kohärente Begrüßung zurück.
00:07:40Das ist also ein Erfolg.
00:07:42Wir haben nun ein echtes KI-Modell, das lokal auf dem Pi läuft
00:07:47und logisch auf unsere Prompts reagiert.
00:07:49Juhu!
00:07:50Gehen wir noch einen Schritt weiter.
00:07:53Mal sehen, ob der Pi ein 8-Bit-Modell schafft.
00:07:56Diesmal frage ich etwas Anspruchsvolleres,
00:07:59zum Beispiel: Was ist die Hauptstadt von Albanien?
00:08:02Nun, das ist schlichtweg falsch, denn die Hauptstadt von Albanien ist Tirana,
00:08:08und das hier ist eindeutig faktisch inkorrekt.
00:08:10Frage ich jedoch nach der Hauptstadt von Belgien, antwortet es korrekt.
00:08:15Das zeigt uns etwas sehr Interessantes.
00:08:17Es scheint, dass die Reduktion auf 90 Millionen Parameter ihren Preis hat.
00:08:22Es mag akkurates Wissen über größere, bekanntere Länder haben,
00:08:26aber es fehlt Wissen über weniger bekannte Länder und Themen.
00:08:31Das liegt einfach in der Natur der Sache.
00:08:33In 90 Millionen Parameter passt eben nur eine begrenzte Menge an Wissen.
00:08:38Nichtsdestotrotz ist das Ergebnis extrem cool.
00:08:41Es ist die Bestätigung, dass es tatsächlich KI-Modelle gibt, die klein
00:08:46und schlank genug für einen 12 Jahre alten Raspberry Pi sind.
00:08:50Ist es schnell?
00:08:51Sicher nicht.
00:08:52Ist es präzise?
00:08:53Vielleicht nicht immer.
00:08:54Sollte man es produktiv nutzen?
00:08:55Wahrscheinlich eher nicht.
00:08:57Es sei denn, man will einen sehr, sehr, sehr, sehr langsamen Roboter bauen.
00:09:02Aber am wichtigsten ist: Wir wissen jetzt, dass es theoretisch möglich ist.
00:09:06Das war im Grunde alles, was ich in diesem Video beweisen wollte.
00:09:09Und um ehrlich zu sein, hat dieses Experiment eine Menge Spaß gemacht.
00:09:13Da habt ihr es also, Leute.
00:09:14Das sind die Falcon H1 Tiny-Modelle.
00:09:17Wahrscheinlich die kleinsten KI-Modelle, die es derzeit gibt.
00:09:20Und jetzt wissen wir, dass sie tatsächlich klein genug sind, um auf einem Raspberry Pi der ersten Generation zu laufen,
00:09:25was super cool ist.
00:09:27Ich kann gar nicht aufhören zu feiern, wie cool diese Tatsache ist.
00:09:30Auch wenn die praktische Umsetzung nutzlos ist, bleibt es dennoch cool.
00:09:35Lasst mich also wissen, falls ihr irgendwelche amüsanten Gedanken,
00:09:37Kommentare oder Anmerkungen zu dem Gesehenen habt.
00:09:40Postet sie unten in die Kommentare.
00:09:42Und Leute, wenn euch diese Art von technischen Analysen gefällt,
00:09:45dann zeigt es mir bitte, indem ihr den Like-Button unter dem Video drückt.
00:09:49Vergesst auch nicht, unseren Kanal zu abonnieren.
00:09:51Das war Andris von Better Stack, und wir sehen uns in den nächsten Videos.

Key Takeaway

Die lokale Ausführung eines Large Language Models ist auf einem 12 Jahre alten Raspberry Pi der ersten Generation durch die Kombination des 90-Millionen-Parameter-Modells Falcon H1 Tiny, klassischer Q4-Quantisierung und einer ARMv6-spezifischen Cross-Kompilierung von llama.cpp ohne Memory Mapping technisch möglich.

Highlights

  • Der Raspberry Pi der ersten Generation besitzt lediglich einen 700-MHz-Single-Core-Prozessor und 512 MB RAM.

  • Das Sprachmodell Falcon H1 Tiny umfasst nur 90 Millionen Parameter und nutzt eine Hybrid-Architektur aus Transformer und Mamba.

  • Moderne Quantisierungsmethoden wie die Importance Quantization (IQ) scheitern am ARMv6-Chip des alten Raspberry Pi mangels moderner CPU-Instruktionen.

  • Die Cross-Kompilierung von llama.cpp mittels dockcross auf einem Laptop verringert die Build-Zeit von geschätzten 18 Stunden auf zwei Minuten.

  • Das Deaktivieren von Memory Mapping via “no M map” verhindert Speicherabstürze auf dem 32-Bit-System mit 512 MB RAM durch direktes Laden in den Heap.

  • Die Inferenz des 2-Bit-quantisierten Modells erzeugt alle drei Sekunden ein Token, liefert jedoch aufgrund zu starker Kompression unbrauchbare Logikfehler.

  • Das 4-Bit-Modell antwortet logisch kohärent, zeigt jedoch bei Detailwissen wie kleineren Hauptstädten faktische Wissenslücken.

Timeline

Hardwarelimitierungen des Raspberry Pi 1 und die Suche nach einem passenden Modell

  • Der Raspberry Pi der ersten Generation läuft mit einem 700-MHz-Single-Core-Prozessor und verfügt über 512 MB RAM.
  • Das für diesen Test gewählte Modell Falcon H1 Tiny besitzt eine extrem geringe Größe von 90 Millionen Parametern.
  • Die Entwickler des Technology Innovation Institute nutzen eine Hybrid-Architektur aus Transformer und Mamba für die Kompression.

Die veraltete Hardware des Ur-Raspberry Pi setzt extrem enge Grenzen für die Ausführung moderner KI. Normalerweise reichen 512 MB Arbeitsspeicher nicht für Sprachmodelle aus. Das Falcon H1 Tiny wurde gezielt für die Erforschung der Untergrenzen von Sprachmodellen konzipiert. Ähnliche minimale Architekturen kommen auch bei Modellen wie IBM Granite-4 zum Einsatz.

Die Wahl der Quantisierungsmethode für die ARMv6-Architektur

  • Moderne IQ-Quantisierungsmethoden setzen für die Bit-Manipulation aktuelle CPU-Instruktionen voraus.
  • Der ARMv6-Chip des alten Modells erfordert den Rückgriff auf klassische Q4-Modelle als Legacy-Quantisierung.
  • Die Q4-Methode bietet auf dieser Plattform das effizienteste Verhältnis zwischen Intelligenz und Speicherplatzbedarf.

Neue, ultra-schlanke Kompressionsverfahren überfordern die alte CPU-Architektur des Raspberry Pi. Die komplexen Berechnungen moderner Algorithmen verlangsamen das System ohne die passenden Instruktionen massiv. Klassische 4-Bit-Verfahren belasten die Recheneinheit weniger. Sie erhalten die logische Struktur des Modells aufrecht, ohne den Prozessor zu blockieren.

Betriebssystem-Konfiguration und Cross-Kompilierung über dockcross

  • Das Betriebssystem Raspberry Pi OS Lite in der 32-Bit-Version spart durch den Verzicht auf eine Desktop-Oberfläche maximalen RAM.
  • Eine direkte Kompilierung von llama.cpp auf dem Pi scheitert am RAM-Mangel oder dauert bis zu 18 Stunden.
  • Das Toolchain-Werkzeug dockcross ermöglicht die zweiminütige Cross-Kompilierung für ARMv6 auf einem modernen Laptop.

Jedes Megabyte RAM entscheidet über den Erfolg des Projekts im Leerlauf. Die Aktivierung von SSH und WLAN im Vorfeld verhindert die Nutzung des trägen lokalen Terminals. Da der Laptop auf ARMv8 (64-Bit) läuft, erzeugt erst dockcross den passenden Binärcode für die alte 32-Bit-Architektur. Beim Kompilieren werden spezifische Flags gesetzt: Shared Libs, Neon-Mathe-Befehle und OpenMP werden komplett deaktiviert, um das Binary schlank und kompatibel zu halten.

Inferenz-Tests und Performance-Analyse von 2-Bit- bis 8-Bit-Modellen

  • Das Flag “no M map” erzwingt das Laden direkt in den Heap und verhindert das Fehlschlagen zusammenhängender Adressblock-Zuweisungen.
  • Das 2-Bit-Modell generiert alle drei Sekunden ein Token, produziert jedoch durch den Verlust linguistischer Logik nur unzusammenhängenden Unsinn.
  • Das 4-Bit-Modell antwortet kohärent, zeigt jedoch bei anspruchsvollen Wissensabfragen wie geografischen Fakten klare Kapazitätsgrenzen.

Die Testparameter sind minimal angesetzt: Es wird genau ein Thread genutzt und die Kontextgröße liegt bei winzigen 128 Token. Während die 2-Bit-Version durch die zu starke Kompression der Gewichte unbrauchbar ist, liefert die 4-Bit-Variante korrekte Begrüßungen. Bei komplexeren Fragen wie nach der Hauptstadt von Albanien versagt das System faktisch, während bekanntere Fakten wie die Hauptstadt von Belgien korrekt ausgegeben werden. In 90 Millionen Parameter passt physikalisch nur eine begrenzte Menge an Weltwissen, wodurch die praktische Nutzung für produktive Zwecke entfällt.

Community Posts

No posts yet. Be the first to write about this video!

Write about this video