Cloud & DevOps

Lokales LLM zu langsam? Diese Einstellungen prüfst du zuerst

Dein lokales KI-Modell rechnet im Schneckentempo? Meist liegt es an einer Software-Einstellung, nicht am Chip. So findest du den Fehler.

Editorial Team / /9 Min. Lesezeit
Ein leuchtender oranger Schieberegler in dunkler Szene, rechts ein Mini-PC, als Hinweis auf eine Einstellung fürs Tempo

Jemand steckt echtes Geld in eine Maschine, um ein Sprachmodell lokal laufen zu lassen, folgt einer Anleitung aus dem Netz – und bekommt am Ende weniger als ein Wort pro Sekunde ausgespuckt. Der erste Reflex: die Hardware ist schuld, also eine größere Grafikkarte einpreisen. In den meisten Fällen ist genau dieser Reflex falsch. Schuld sind oft die Standardeinstellungen der Anleitung selbst – und niemand warnt dich davor, es gibt keine Fehlermeldung, die das anzeigt.

Genau diese Lücke zwischen dem, was eine Maschine könnte, und dem, was sie tatsächlich liefert, ist hier das Thema. Ein neugieriger Tester namens Alex Ziskind hat auf einem kompakten Desktop-PC eine Reihe kontrollierter Benchmarks gefahren, dabei methodisch eine Einstellung nach der anderen umgelegt – und die Ergebnisse sprechen deutlicher als jedes Datenblatt. Bevor du in neue Hardware investierst, lohnt sich eine bestimmte, wiederholbare Reihenfolge an Checks. Das Muster kennt DecodeStack bereits aus einem anderen Fall: wie unauffällig der Zugang zu einem bestimmten KI-Modell verschwinden kann – auch dort saß das eigentliche Problem in der Software-Schicht, nicht in der Hardware davor.

Maschine und Modell, kurz erklärt

Ziskinds Testgerät war ein Khadas Mind Pro, ein Mini-PC rund um Intels Panther-Lake-Chipfamilie (Core Ultra X7 358H oder X9 388H, je nach Konfiguration), mit bis zu 64 GB gemeinsam genutztem LPDDR5X-Speicher und Thunderbolt-4-Anschluss. Das Gerät selbst ist eigentlich Nebensache. Es steht stellvertretend für jede moderne Maschine, die ein Sprachmodell lokal ausführt: ein Gaming-Laptop, ein Mac mit Unified Memory, ein Desktop mit dedizierter Grafikkarte. Die im Folgenden beschriebene Diagnosemethode gilt unabhängig vom konkreten Gehäuse, weil sie ansetzt, wie die Software die Hardware nutzt – nicht bei der Hardware selbst.

Getestet wurde Qwen3.8-27B, ein Open-Weight-Modell mit 27 Milliarden Parametern, das Alibabas Qwen-Team unter einer freizügigen Lizenz veröffentlicht hat – open weight heißt, der Hersteller stellt das fertig trainierte Modell kostenlos bereit, ohne aber zwangsläufig Trainingsdaten oder Code offenzulegen. Gewählt wurde es, weil es groß genug ist, den Speicher einer Consumer-Maschine spürbar zu belasten, ohne dass es dafür eine Rechenzentrums-Karte braucht. Die Software dahinter heißt llama.cpp, die Open-Source-Engine, auf der die meisten lokalen KI-Tools (LM Studio, Ollama und andere) im Hintergrund tatsächlich laufen – nur mit einer freundlicheren Oberfläche davor. Alles, was folgt, ist eine llama.cpp-Einstellung. Das heißt: Es gilt überall dort, wo llama.cpp im Hintergrund arbeitet, nicht nur auf diesem einen Testgerät.

Erster Check: Passt das Modell überhaupt in den Speicher

Einmal geladen, muss ein Sprachmodell irgendwo liegen, wo der Prozessor schnell darauf zugreifen kann: entweder im dedizierten Videospeicher einer Grafikkarte, oder – bei Maschinen mit geteiltem Speicher wie dieser – in einem gemeinsamen Pool, aus dem sowohl CPU als auch GPU-Kerne schöpfen. Die meisten Anleitungen raten dazu, mit dem Flag --n-gpu-layers (oft abgekürzt -ngl) alle Schichten des Modells in diesen schnellen Speicher zu schieben, typischerweise mit dem Wert 99, 999 oder -1 – alle drei bedeuten schlicht: “Packe alles auf die GPU, egal ob es passt.”

Genau diese Einstellung wird in den meisten Copy-paste-Anleitungen unhinterfragt übernommen, und Ziskinds Zahlen zeigen ziemlich genau, warum das ein Problem ist. Mit 60 der insgesamt 64 Modellschichten auf den Grafikspeicher gezwungen – nah am Maximum, aber nicht ganz – sackte der Durchsatz auf 0,82 Tokens pro Sekunde, ungefähr ein Wort alle ein bis zwei Sekunden. Hielt man von Hand vier Schichten mehr zurück, sodass nur 56 statt 60 Schichten auf der GPU landeten, kletterte derselbe Aufbau auf 14 Tokens pro Sekunde – rund siebzehnmal schneller, bei identischer Hardware und identischem Modell.

Offizielle llama.cpp-Server-Doku zum Flag --n-gpu-layers

llama.cpp-Server-Dokumentation – die offizielle Doku zum oben besprochenen Flag --n-gpu-layers.

Der Mechanismus dahinter ist keine Zauberei. Passt ein Modell nicht sauber in den schnellen Speicherpool, muss das System ständig Teile hinein- und hinausschieben – und dieses Umschichten kostet weit mehr Zeit, als von vornherein eine kleine Scheibe des Modells auf dem langsameren, aber geräumigeren Systemspeicher-Pfad zu belassen. Das Maximal-Schichten-Flag geht stillschweigend davon aus, dass alles passt. Tut es das nicht, warnt nichts: Das Modell lädt trotzdem, antwortet trotzdem – nur im Schneckentempo. Das ist das zentrale Gegenbeispiel dieser Geschichte, und es widerspricht der verbreiteten Annahme aus Tutorials, dass mehr Schichten auf der Grafikkarte immer schneller sind. Ist es nicht, sobald das Speicherbudget überschritten wird.

Zweiter Check: Wie das Modell komprimiert wurde

Noch bevor du an der Schichtzahl drehst, lohnt sich ein Blick darauf, wie die Modelldatei selbst komprimiert wurde – ein Verfahren namens Quantisierung. Modellgewichte in voller Präzision brauchen enorme Mengen Speicher, deshalb wurde praktisch jedes für den Heimgebrauch verteilte Modell bereits verkleinert, indem jede Zahl mit weniger Bits dargestellt wird – ein Tausch von numerischer Genauigkeit gegen eine kleinere Datei. Der Haken: Nicht jedes Quantisierungsschema bei gleicher Bit-Tiefe ist gleich effizient.

Ziskinds Test verglich zwei Versionen desselben Modells, beide offiziell “4-Bit”, aber mit unterschiedlichem internen Aufbau: eine Q4_K_M-Datei mit rund 18 GB und eine kompaktere IQ4_XS-Datei mit rund 13 GB. Mit der kleineren Datei passte das Modell komplett in den schnellen Speicherpool, was den Durchsatz nahezu verdoppelte, von 14 auf 27 Tokens pro Sekunde. Um zu prüfen, ob die kleinere Datei dafür schlechter antwortet, maß der Test die Perplexity, einen Standardwert dafür, wie gut ein Modell echten Text vorhersagt (niedriger ist besser, und es ist der übliche Maßstab für solche Vergleiche). Beide Dateien erreichten denselben Wert von 6,8 auf dem Wikitext-2-Benchmark, einem weit verbreiteten Textkorpus für genau diese Messung – die kleinere Datei war bei diesem Vergleich also nicht messbar schlechter. Das ist keine universelle Garantie für jedes Modell und jeden Anwendungsfall, zeigt aber, dass sich das kompaktere Schema einen Versuch wert ist, bevor man annimmt, eine kleinere Datei bedeute automatisch eine schlechtere Antwort.

Die praktische Lehre daraus: Ein Modell, das fast passt, scheitert oft nur an einem einzigen Quantisierungsformat vor dem vollständigen Passen – und genau dort, im vollständigen Passen, steckt die eigentliche Geschwindigkeit.

Dritter Check: Ein kleineres Modell raten lassen

Die dritte von Ziskind getestete Technik heißt spekulatives Dekodieren, und sie ist keine Neuheit, sondern eine stabile, gut dokumentierte Funktion von llama.cpp. Die Idee dahinter: Statt jedes einzelne Wort vom großen 27-Milliarden-Parameter-Modell erzeugen zu lassen, rät ein deutlich kleineres “Entwurfsmodell” eine kurze Folge kommender Wörter voraus, und das große Modell prüft diesen Vorschlag in einem einzigen Durchgang, statt Wort für Wort zu generieren. Liegt das kleine Modell richtig – bei gewöhnlichem Text häufig der Fall –, bestätigt das große Modell mehrere Wörter auf einmal, statt sie einzeln zu berechnen.

In einem separaten, isolierten Vergleich – losgelöst von den beiden Fixes oben, Speicherplatzierung und Quantisierung – verdoppelte das Zuschalten von spekulativem Dekodieren den Durchsatz ungefähr, von 5 auf 11 Tokens pro Sekunde, ohne dass die Antwortqualität litt, weil das große Modell weiterhin jedes Wort überprüft. Auch hier gibt es einen Stellschraube: Wie viele Wörter das kleine Modell vorausraten darf, bevor das große kontrolliert, oft mit draft-max oder ähnlich in der Konfiguration bezeichnet. llama.cpps dokumentierter Standardwert dafür ist 3 – eine bewusst vorsichtige Zahl. Ziskind stellte fest, dass ein höherer Wert die Sache verschlimmbesserte statt verbesserte, weil ein längerer, ungeprüfter Vorschlag mit höherer Wahrscheinlichkeit irgendwo mittendrin danebenliegt – und ein einziger Fehltreffer in der Reihe zwingt das große Modell, den gesamten Abschnitt zu verwerfen und neu zu berechnen. Der Standardwert existiert aus gutem Grund; er ist ein Ausgangspunkt zum Testen, keine Grenze, die man einfach überschreibt.

Offizielle llama.cpp-Dokumentationsseite zu spekulativem Dekodieren

llama.cpp-Dokumentation zu spekulativem Dekodieren – die Doku der Engine selbst zu der oben beschriebenen Technik.

Womit das Kabel kaum etwas zu tun hat

Ein letztes Ergebnis verdient Aufmerksamkeit, weil es eine verbreitete Annahme korrigiert: Auf einer Maschine mit geteiltem oder vereinheitlichtem Speicher ist die Verbindung zwischen den Komponenten – hier Khadas’ proprietäre Mind-Link-Schnittstelle, ein PCIe-basierter Anschluss mit bis zu 15,8 Gigabyte pro Sekunde, kein normaler Thunderbolt- oder USB4-Port – selten der Flaschenhals, den man ihr unterstellt. Während normaler Textgenerierung lag der tatsächliche Datenverkehr über diese Verbindung in diesem Test bei rund 2 Megabyte pro Sekunde, ein winziger Bruchteil der Nennkapazität. Der begrenzende Faktor für die Geschwindigkeit eines lokalen Sprachmodells ist fast immer die Speicherbandbreite – also wie schnell Daten zwischen dem Speicherpool und den rechnenden Kernen fließen können, nicht die Transportstrecke zwischen einzelnen Bauteilen. Ein besseres Kabel oder ein anderer Port wird bei dieser Art Last kaum etwas bewegen; die Grenze setzt das Speichersystem selbst.

Die Reihenfolge der Checks

Keine der drei oben genannten Techniken ist neu. Quantisierung, spekulatives Dekodieren und manuelles Verteilen der Schichten gibt es in llama.cpp schon lange, und wer Zeit in lokalen KI-Foren verbracht hat, ist wahrscheinlich schon über alle drei gestolpert – nur meist getrennt voneinander. Was dieser Test besonders gut zeigt, ist, was passiert, wenn man sie der Reihe nach prüft – und was passiert, wenn ausgerechnet die am häufigsten kopierte Standardeinstellung aktiv gegen dich arbeitet.

Eine sinnvolle Reihenfolge, übertragbar auf jede Maschine, die llama.cpp unter irgendeiner Oberfläche laufen lässt:

  1. Erst bestätigen, dass das Modell bei der gewählten Schichtzahl wirklich in den schnellen Speicherpool passt – statt anzunehmen, das Maximal-Flag sei standardmäßig sicher.
  2. Ein kompakteres Quantisierungsformat bei gleicher Bit-Tiefe ausprobieren, bevor man davon ausgeht, das Modell müsse an Qualität einbüßen, nur um kleiner zu werden.
  3. Spekulatives Dekodieren einschalten, falls ein passendes kleineres Entwurfsmodell für dieselbe Modellfamilie existiert, und die Standardtiefe des Entwurfs beibehalten, solange Tests nichts anderes zeigen.
  4. Transportstrecken (Thunderbolt, USB4, PCIe) bei Shared-Memory-Systemen aus der Fehlersuche herauslassen – sie sind selten die Einschränkung.

Die Reihenfolge ist wichtig, weil jeder Schritt verändert, was der nächste noch lösen muss. Wird zuerst die Speicherplatzierung korrigiert, fallen die Gewinne durch Kompression und spekulatives Dekodieren oft größer aus, weil das Modell nicht länger gegen seine eigene Platzierung ankämpft.

Entscheidungskarte für ein langsames lokales LLM: --n-gpu-layers senken, wenn der Durchsatz bei maximaler Einstellung unter 1 Token/Sekunde liegt, damit das Modell sauber in den schnellen Speicher passt; ein kompakteres Quantisierungsformat wie IQ4_XS ausprobieren, wenn das Modell fast passt; spekulatives Dekodieren mit einem passenden Entwurfsmodell einschalten, sobald die Speicherplatzierung stabil ist; die Speicherbandbreite prüfen, bevor man Thunderbolt oder USB4 die Schuld gibt; und erst dann von einer Hardwaregrenze ausgehen, wenn keiner dieser kostenlosen Fixes hilft

Häufige Fragen

Warum wird ein lokales LLM manchmal langsamer, nicht schneller, wenn man die GPU-Schichten auf Maximum stellt?

Das Maximal-Flag zwingt jede Schicht eines Sprachmodells in den schnellen Grafikspeicher, selbst wenn das Modell dort nicht sauber hineinpasst. Passt es nicht, muss das System ständig Daten hinein- und hinausschieben – das kostet deutlich mehr Zeit, als von vornherein einen kleinen Teil des Modells auf dem langsameren Systemspeicher-Pfad zu belassen.

Bedeutet eine kleinere quantisierte Modelldatei automatisch schlechtere Antworten?

Nicht automatisch – es hängt vom genauen Kompressionsschema ab, nicht nur von der Bit-Tiefe. In einem dokumentierten Test erreichte ein kompakteres 4-Bit-Format denselben Wert wie ein größeres 4-Bit-Format auf einem Standard-Perplexity-Benchmark, lief dabei aber spürbar schneller, weil es komplett in den Speicher passte.

Was ist spekulatives Dekodieren, einfach erklärt?

Spekulatives Dekodieren lässt ein kleines, schnelles “Entwurfsmodell” mehrere kommende Wörter voraussagen, die ein größeres Modell dann in einem einzigen Durchgang prüft, statt jedes Wort einzeln zu erzeugen. Liegen die Vorschläge richtig – bei gewöhnlichem Text häufig der Fall – verdoppelt das ungefähr die Ausgabegeschwindigkeit, ohne die Qualität der finalen Antwort zu verändern.

Ist die Geschwindigkeit von Thunderbolt oder USB4 der Flaschenhals bei einem lokalen Sprachmodell?

Auf einer Maschine mit geteiltem oder vereinheitlichtem Speicher ist die Transportstrecke zwischen den Komponenten selten der begrenzende Faktor für die Geschwindigkeit eines Sprachmodells. Der tatsächliche Datenverkehr über diese Verbindung macht während der Textgenerierung typischerweise nur einen kleinen Bruchteil der Nennkapazität aus – die Speicherbandbreite setzt die praktische Grenze, nicht die Kabelgeschwindigkeit.

Muss ich neue Hardware kaufen, wenn mein lokales LLM langsam läuft?

Nicht unbedingt. Bevor du neue Hardware kaufst, prüfe, ob das Modell sauber in den verfügbaren schnellen Speicher passt, probiere ein effizienteres Quantisierungsformat aus und aktiviere spekulatives Dekodieren, falls ein passendes Entwurfsmodell existiert. Das sind kostenlose Software-Anpassungen, die in getesteten Fällen deutlich größere Geschwindigkeitsgewinne brachten, als die Hardware allein vermuten ließe.

#llm#local-ai#llama-cpp#self-hosting#performance