Wer lokale KI-Modelle auf Apple Silicon betreibt, stößt unweigerlich auf das fundamentale Paradoxon moderner Inferenz: Die GPU-Rechenkerne langweilen sich, während der Speicherbus glüht.
Klassische autoregressive Large Language Models (LLMs) sind für lokale Hardware berüchtigt ineffizient. Weil jedes Token sequentiell berechnet wird, muss für jedes einzelne Wort das gesamte Modellgewicht einmal komplett aus dem Unified Memory in die GPU-ALUs gestreamt werden. Bei 512 Tokens und einem schlanken 0.5B Modell bedeutet das über 470 GB reinen RAM-Lesetransfer.
1. Der naive Port (Stanford Eager Path)
Stanfords Referenz-Implementation auf MPS zeigte erhebliche Mängel:
- BPE-Falle: 1 NCM-Position ≈ 0.58 BPE-Tokens. Real nur 5.1x weniger Gewichts-Streaming (nicht nominal 8.9x).
- 85.2 % mehr Transformer-Token-Zyklen: 512 Prefix-Tokens wurden mangels Cross-Level KV-Cache 9x redundant neu berechnet.
- CPU-Fallback-Stalls:
F.interpolate(mode='area')blockierte die Metal-Pipeline 8x pro Sample. - Ergebnis: +138 % Energie-Penalty (0.289 J/tok vs 0.121 J/tok), 31 % langsamer als AR.
2. Systems-Level Optimization (Co-Design)
Drei systemnahe Optimierungen in src/ncm_mps_runner.py beheben die Software-Flaschenhälse:
- Cross-Level Prefix KV-Cache: Snapshot vor Level 0 spart 6.75x Prefix-FLOPs (100 % bit-identisch,
torch.equal=True). - Hardware-native GPU-Matrix-Interp: Precomputed Projection Matrix
input @ Wohne CPU-Transfer. - Single-Pass Final-Decode: 60M VQ-VAE Decoder läuft nur 1x am Ende statt 9x pro Stufe.
- Ergebnis: 310.1 BPE tok/s (1.84x schneller als PyTorch MPS FP16) und 43.7 % weniger Energie pro Token.
1. Der Bottleneck-Shift: Memory Bandwidth → Compute
Klassische autoregressive LLMs generieren Token für Token. Bei Batch-Size 1 müssen für jedes einzelne Token die vollständigen Modellgewichte aus dem RAM in die Rechenkerne gestreamt werden (\(\mathcal{O}(T \cdot W)\)). NCM zerlegt Sequenzen über einen Multiscale Residual VQ-VAE in eine fixe Konzept-Hierarchie (9 Level bei XSum, 12 Level bei Sudoku). Pro Hierarchie-Ebene wird nur ein einziger paralleler Forward-Pass ausgeführt (\(\mathcal{O}(L \cdot W)\)).
A. Statistische Qualitätsevaluation (XSum, Großstichprobe N = 500)
Um methodische Unschärfen kleiner Stichproben auszuschließen, wurden alle Modelle im Paired Design über 500 BBC-Nachrichtenartikel aus dem XSum-Evaluationsset mit nativer Ground-Truth-Referenz getestet. Ausgewiesen sind Mittelwert ± Standardabweichung (\(\text{Mean} \pm \text{Std}\)) sowie die exakte Signifikanzprüfung via **Paired Bootstrap mit 10.000 Resamples**:
| Modell / Architektur | Backend / Optimierung | Passes | Ø BPE-Tokens | Gemessene Dauer | Iso-Latenz (28 Tok)* | BPE Durchsatz | ROUGE-1 | ROUGE-2 | ROUGE-L |
|---|---|---|---|---|---|---|---|---|---|
| Qwen2.5-0.5B (AR Baseline) | PyTorch MPS (FP16, Zero-Shot) | 48 | 28.1 | 178.4 ms | 177.8 ms | 157.5 tok/s | 0.2227 ± 0.101 | 0.0462 ± 0.064 | 0.1678 ± 0.081 |
| Qwen2.5-0.5B (AR MLX 4-Bit) | Apple MLX (Metal, 4-Bit) | 48 | 35.4 | 106.7 ms | 84.3 ms | 332.1 tok/s | 0.2283 ± 0.088 | 0.0424 ± 0.054 | 0.1664 ± 0.069 |
| NCM Fast (Naive Eager Port) | PyTorch MPS (Eager, FP16) | 9 | 25.9 | 380.0 ms | 410.0 ms | 68.3 tok/s | 0.3442 ± 0.142 | 0.1292 ± 0.125 | 0.2759 ± 0.134 |
| NCM Fast (Systems-Optimized) | PyTorch MPS (Prefix-KV, FP16) | 9 | 25.9 | 89.8 ms | 96.9 ms | 288.9 tok/s | 0.3442 ± 0.142 | 0.1292 ± 0.125 | 0.2759 ± 0.134 |
| Hybrid (NCM + MLX 4-Bit)* | 16b MPS + 4b Metal | 137 | 176.0 | 3.39 s | - | 51.9 tok/s | 0.1824 ± 0.065 | 0.0448 ± 0.048 | 0.1308 ± 0.039 |
| Signifikanz (NCM vs. AR Base) | Paired Bootstrap (10k, N=500) | - | - | - | - | - | Δ = +0.121 (p < 0.0001) | Δ = +0.083 (p < 0.0001) | Δ = +0.108 (p < 0.0001) |
| Signifikanz (NCM vs. MLX 4b) | Paired Bootstrap (10k, N=500) | - | - | - | - | - | Δ = +0.116 (p < 0.0001) | Δ = +0.087 (p < 0.0001) | Δ = +0.110 (p < 0.0001) |
* Methodische Erläuterungen zu Tabelle 1:
1. Invariante A (\(\text{Tokens} / \text{Dauer} = \text{Durchsatz}\)): Der Durchsatz berechnet sich exakt aus \(\text{Tokens} / \text{Dauer}\) (z. B. 28.1 tok / 0.1784s = 157.5 tok/s; 35.44 tok / 0.1067s = 332.1 tok/s; 25.94 tok / 0.0898s = 288.9 tok/s).
2. Iso-Token-Normalisierung: Auf eine einheitliche Ziel-Länge von 28.0 BPE-Tokens normiert (\(28.0 / \text{Durchsatz}\)) decodiert MLX 4-Bit in nur 84.3 ms (vs. 96.9 ms für NCM Fast).
3. Stichproben-Kennzeichnung: AR Baseline, MLX 4-Bit und NCM Fast wurden über alle \(N = 500\) Samples evaluiert. Die Hybrid-Pipeline wurde aus Laufzeitgründen (3.39s/Sample) auf einem repräsentativen Subset von \(N = 20\) Samples evaluiert.
4. Steady-State vs. Burst-Durchsatz: Tabelle 1 zeigt die reale End-to-End Inferenz pro Sample über 500 diskrete Läufe. Der in Tabelle 3 für powermetrics gemessene Durchsatz (310.4 tok/s NCM, 345.1 tok/s MLX) stammt aus kontinuierlichem Hardware-Streaming im Burst-Regime.
Der NCM-Checkpoint von Stanford wurde gezielt auf dem XSum-Trainingsdatensatz fine-tuned. Qwen2.5-0.5B hingegen wurde im Zero-Shot-Verfahren evaluiert. Die statistisch hochsignifikanten ROUGE-Vorteile (\(p < 0,0001\)) sind daher primär ein Artefakt der aufgabenspezifischen Spezialisierung und kein Beweis für eine universelle Überlegenheit.
Bit-Identitäts-Nachweis: Ein torch.equal(g_naive, g_opt) Test über alle 20/20 XSum-Samples bestätigte 100.0 % exakte Identität (0 Mismatch-Tokens). Die maximale absolute Differenz zwischen CPU-Interpolation und MPS-GPU-Matrixmultiplikation beträgt exakt \(0.00 \times 10^0\).
B. Diskrete Symbol-Planung: Sudoku-Hard Evaluation (Symmetrisch N = 100 vs. AR Baseline)
Sudoku besitzt ein striktes, nicht-kausales Regelgitter (9 Zeilen, 9 Spalten, 9 3×3-Blöcke = 27 Constraints) ohne BPE-Tokenizer-Verzerrungen. Beide Modelle wurden auf denselben 100 Puzzles (Indices 0–99) evaluiert:
| Modell / Architektur | Generierungs-Methode | Puzzles (\(N\)) | Passes / Puzzle | Dauer / Puzzle | Ø Constraints (von 27) | Perfekte Lösungsrate |
|---|---|---|---|---|---|---|
| Qwen2.5-0.5B-Instruct | Autoregressiv (Zero-Shot) | 100 | ~95 Passes | 0.469s | 1.79 / 27 (± 2.1) | 0 / 100 (0.0 %) |
| NCM Sudoku-Hard | Hierarchisch (12 Levels, Task-Trained) | 100 | 12 Passes | 0.077s (1.181 pos/s) | 26.39 / 27 (± 1.50) | 84 / 100 (84.0 %) |
Struktureller Befund: Autoregressives Left-to-Right Decoding ohne Backtracking oder Suchbäume scheitert auf globalen Constraint-Puzzles erwartbar (1.79/27 Constraints), da frühe Entscheidungen spätere Zeilen blockieren. NCMs hierarchische Multi-Scale Repräsentation schärft grobe Ziffernmuster über 12 Stufen parallel nach und löst 84 % der schweren Puzzles fehlerfrei.
C. Physische Hardware-Telemetrie am Apple Silicon SoC (powermetrics)
Kontinuierliche Abtastung der Hardware-Sensoren über powermetrics (Abtastrate 100 ms) unter Abzug der statischen System-Idle-Baseline (\(P_{\text{idle}} = 1,59\) W). Alle Werte erfüllen exakt die physikalischen Invarianten \(E_{\text{total}} = P_{\text{avg}} \times t\) und \(J/\text{tok} = E_{\text{total}} / \text{Tokens}\):
| Modell / Konfiguration | BPE Tokens | Dauer (s) | BPE Durchsatz | Ø SoC Power | Dyn. Power | Total Energy (J) | J / BPE (Total) | J / BPE (Dyn) |
|---|---|---|---|---|---|---|---|---|
| Qwen2.5-0.5B (MLX 4-Bit Metal) | 2.250 | 6.52s | 345.1 tok/s | 25.81 W | 24.22 W | 168.28 J | 0.0748 J/tok | 0.0702 J/tok |
| Qwen2.5-0.5B (PyTorch MPS FP16) | 960 | 5.70s | 168.4 tok/s | 19.19 W | 17.60 W | 109.38 J | 0.1139 J/tok | 0.1045 J/tok |
| NCM Fast (Systems-Optimized) | 1.679 | 5.41s | 310.4 tok/s | 19.86 W | 18.27 W | 107.44 J | 0.0640 J/tok | 0.0589 J/tok |
- Gegenüber der unoptimierten PyTorch MPS FP16 Baseline (168.4 tok/s) ist NCM Fast (310.4 tok/s) um 1.84x schneller und verbraucht 43.8 % weniger Energie pro Token (0.0640 J vs. 0.1139 J).
- Gegenüber der optimierten Apple MLX 4-Bit Metal Baseline (345.1 tok/s) ist NCM im Durchsatz leicht langsamer (-10 %), aber 14.4 % energieeffizienter pro Token (0.0640 J vs. 0.0748 J), da MLX bei Vollast 25.81 W zieht.
D. Statistische MBR-Kandidaten-Skalierung (Ablation über \(N = 20\) Samples)
Untersuchung von Test-Time Scaling via Minimum Bayes Risk (MBR) Konsensentscheidung (\(K = 1, 4, 8\)) gemittelt über 20 repräsentative XSum-Artikel (passages[0:20]):
| Kandidaten (\(K\)) | Passes | Dauer / Sample | Effektiver BPE Durchsatz | ROUGE-1 | ROUGE-2 | ROUGE-L | MBR Utility Score* |
|---|---|---|---|---|---|---|---|
| 1 (Fast) | 9 | 0.098s | 285.4 tok/s | 0.3509 ± 0.144 | 0.1218 ± 0.119 | 0.2706 ± 0.137 | - |
| 4 (Low Effort) | 36 | 0.454s | 61.6 tok/s | 0.3452 ± 0.154 | 0.1197 ± 0.115 | 0.2613 ± 0.147 | 0.4292 |
| 8 (Medium Effort) | 72 | 0.897s | 31.2 tok/s | 0.3466 ± 0.150 | 0.1205 ± 0.129 | 0.2686 ± 0.138 | 0.4339 |
* Methodik & Befund: Kandidat #0 wird stets deterministisch als Greedy-Anker (\(T=0,7\), top_k=1, top_p=0) generiert, während ab \(k \ge 1\) eine Temperaturspreizung (\(T=0,85 \dots 1,15\)) den Konzeptraum exploriert. Auf Text-Summarization bringt MBR-Konsens keine statistisch signifikante ROUGE-Verbesserung, während der \(4,6\times\) bis \(9,2\times\) höhere Rechenaufwand den effektiven Durchsatz auf 31,2 tok/s drückt.
2. Das Roofline-Modell: Wo NCM bei 14B+ skaliert (und wo nicht)
Ein oft geäußertes Missverständnis ist, NCM würde bei 14B-Modellen und 1.024 Tokens die Inferenzzeit auf „~1 Sekunde“ drücken, weil nur 145.6 GB Gewichte gestreamt werden. Das ist physikalisch falsch. Eine vollständige Roofline-Analyse (Speicherbandbreite vs. Rechenleistung) offenbart die wahre Natur des Bottleneck-Shifts:
| Metrik (14B Modell, 1.024 Tokens, 273 GB/s Bus) | Autoregressives LLM (14B 4-Bit) | Next-Concept Modeling (14B, 16 Level) |
|---|---|---|
| Vorwärtsdurchläufe (Passes) | 1.024 sequentielle Schritte | 16 hierarchische Schritte |
| Modellgewichts-Transfer | 9.318,4 GB (9,32 TB) | 145,6 GB (64x Ersparnis!) |
| Speicher-Streaming-Zeit (\(t_{\text{mem}} = \text{GB} / 273\)) | 34,13 Sekunden | 0,53 Sekunden |
| Gesamte Matrix-FLOPs (\(W_{\text{FLOPs}}\)) | 28,7 TFLOPs (1 Token/Pass) | 229,4 TFLOPs (alle Tokens parallel) |
| Reine Rechenzeit (\(t_{\text{compute}} = \text{FLOPs} / 15 \text{ TFLOPs}\)) | 1,91 Sekunden | 15,29 – 30,6 Sekunden |
| Physikalische Latenz \(\max(t_{\text{mem}}, t_{\text{compute}})\) | 34,13 Sekunden | 15,29 – 30,6 Sekunden |
| Dominanter Engpass | 95 % Memory-Bound (DRAM-Stall) | 98 % Compute-Bound (ALU-Saturation) |
| Realer Wanduhrzeit-Speedup | Baseline (1.0x) | 1.1x bis 2.2x (nicht 64x!) |
NCM spart bei 1.024 Tokens tatsächlich 9.172,8 GB RAM-Streaming ein. Weil NCM aber auf allen Hierarchie-Ebenen die gesamte Sequenz parallel berechnen muss, explodiert der Rechenaufwand von 28.7 auf 229+ TFLOPs.
Der Bottleneck-Shift findet real statt (die GPU wartet nicht mehr auf RAM, sondern rechnet unter Volllast). Die Latenz sinkt jedoch moderat um 1.1x bis 2.2x (von 34s auf 15–30s) – keineswegs um den Faktor 64x.
3. Das 2-Stufen Hybrid-System: Ein empirisches Negativergebnis
Die vorgestellte 2-Stufen-Hybrid-Pipeline (NCM MPS + MLX Metal 4-Bit) erweist sich in der Praxis als klares Negativergebnis:
- Mit 51,9 tok/s (137 Passes) ist sie langsamer als reines NCM und reines MLX.
- Mit ROUGE-1 = 0,1824 erzielt sie die schlechtesten Qualitätsscores aller Varianten.
- Befund: Unverbundenes semantisches Drafting zweier getrennter Modellarchitekturen führt ohne gemeinsames End-to-End-Training zu linguistischer Reibung.
4. Open Source & Exakte Reproduktionsumgebung
Das vollständige, lauffähige Proof of Concept inklusive aller Systems-Optimierungen (Cross-Level Prefix KV-Cache, GPU-Matrix-Interpolation), powermetrics Profiling und XSum-Evaluierungsskripten steht Open Source auf GitHub bereit:
Zum GitHub Repository: PiinoStudio/ncm-apple-silicon ↗
• System: macOS Sequoia (Darwin 26B118, Apple Silicon MacBook Pro M5 Pro, 24 GB Unified Memory, 273 GB/s Bandbreite)
• Software-Stack: Python 3.11.11, PyTorch 2.4.0 (MPS), Apple MLX 0.22.0, Transformers 4.48.0, Rouge-Score 0.1.2
• Datensätze: XSum (\(N = 500\) Samples), Sudoku-Hard (\(N = 100\) Puzzles)