Blog de développement

59 – Faire tourner un gros LLM en local sur un mini-PC Strix Halo : quatre moteurs, un seul plafond

Dernière modification : 2026-11-13

Notes de mise en œuvre — poste Beelink GTR9 Pro, novembre 2026. Honnête, technique, sans survente.

Le contexte matériel

  • Machine : Beelink GTR9 Pro — Ryzen AI Max+ 395, iGPU Radeon 8060S (gfx1151, nom de code Strix Halo), 128 Go de RAM unifiée (CPU et GPU partagent la même mémoire).
  • RAM réellement disponible : ~122 Gio (le BIOS en réserve une part). C'est LE chiffre qui commande tout ce qui suit.
  • OS : Ubuntu 26.04, pile ROCm 7.1.x des dépôts.
  • Objectif : un LLM local pour la rédaction asynchrone (pages web, notes, mails) et du codage agentique, sans dépendre du cloud.

Le modèle visé est Qwen3.8-Flash-Next (un MoE à multi-token prediction / décodage spéculatif intégré). Sur un seul chip et une mémoire unifiée, la question n'est jamais « quel modèle » mais « qu'est-ce qui tient en RAM en laissant la machine utilisable ».

Le fil conducteur : un plafond, pas une courbe

Tout se joue sur une arithmétique simple :

poids résidents + caches + le bureau graphique (compositeur iGPU, navigateur, Thunderbird, l'app de pilotage…) doivent tenir sous ~122 Gio.

Le bureau mange facilement 8 à 15 Gio. Un moteur qui charge ~66-80 Gio de poids passe confortablement. Un moteur qui veut ~103-115 Gio d'un bloc ne passe pas — et c'est le noyau Linux (l'OOM-killer) qui tranche, en tuant vos propres applications. Ce plafond explique à lui seul pourquoi trois moteurs sur quatre ont marché et pourquoi le quatrième a échoué.


1. halogen-flash-server — le clé-en-main (fermé)

Ce que c'est. Un moteur d'inférence à kernels maison (pas de llama.cpp dessous), écrit pour une seule puce (gfx1151) et une seule famille de modèle (Qwen3.8-Flash-Next). Livré en conteneur podman avec le runtime ROCm embarqué.

Pourquoi c'est le chemin le plus court.

  • Aucun SDK ROCm à compiler, aucun header rocWMMA à bricoler : le conteneur embarque tout, il ne faut que le driver noyau KFD (déjà présent).
  • BYO-GGUF : il sert notre fichier GGUF existant de 111 Go (UD-Q4_K_XL) sans re-télécharger. Seul ajout : une tête de draft de 1,5 Go pour le spéculatif.
  • API OpenAI et Anthropic sur le port 8731 → Claude Code s'y branche nativement, sans pont.

Chiffres mesurés chez nous (notre GGUF, thinking on, pas les chiffres vendeur) :

  • Décode MTP ~45 t/s en moyenne (prose 36-37, code 49-54), contre 25,5 t/s en llama.cpp Vulkan sur le même modèle.
  • Lecture honnête : +45 % sur la prose (25,5 → ~37), pas le ×2 annoncé — le ×2 n'existe que sur le code (taux d'acceptation du draft plus élevé).
  • Qualité : le spéculatif sort un texte octet pour octet identique au décodage série. Le gain de vitesse est gratuit en qualité.

Réserves assumées. Moteur fermé (binaire, EULA ; usage commercial autorisé mais code non auditable), chiffres d'origine 100 % vendeur, un seul runtime GPU à la fois, et un piège d'exploitation : un GTT resté alloué après un crash GPU oblige à redémarrer.

Verdict. Le plus simple à mettre debout. C'est la baseline locale « ça marche ce soir ».


2. strixite — l'ouvert (devenu l'étalon)

Ce que c'est. Le jumeau open-source (AGPL) de halogen : des kernels HIP écrits à la main, vérifiés contre une référence CPU, même cible exacte (gfx1151 + Qwen3.8-Flash-Next). « No llama.cpp, no ggml, no vendor libraries underneath. »

Mise en œuvre.

  • Livré en image conteneur (aucune compilation) — ou compilable depuis les sources via TheRock, mais on a pris l'image.
  • Ses propres poids ~115 Go : layout mixte 4/8 bits réfléchi (4,41 bits/poids), weights.strixw 66 Gio en mémoire + une table n-gram de 48 Gio sur SSD. Les chemins « sensibles » (attention, tête LM) sont en 8 bits, les experts en 4 bits — là où le 4 bits fait le moins mal.
  • API OpenAI seule (port 5300) → pour piloter Claude Code (qui parle l'API Anthropic), il faut un pont OpenAI→Anthropic (LiteLLM, monté en service systemd --user). Piège retenu : le provider openai/ tape /v1/responses (absent) → utiliser hosted_vllm/… pour viser /v1/chat/completions.
  • Tourne à 110 Gio de GTT sans reboot (il ne charge « que » ~66 Gio de poids résidents) — inutile de toucher au GRUB.

« Sans vision, avec tests ».

  • Sans vision : la tour de vision est active par défaut, mais envoyer une image au modèle faisait planter le GPU (hipErrorLaunchFailure, contexte GPU perdu). Règle d'exploitation : rester en texte seul (pour un PDF, passer par pdftotext, jamais l'image). C'est un garde-fou de prompt, pas un correctif moteur.
  • Avec tests : utilisé pour un vrai refactor (voir le billet comparatif), le modèle a écrit ET exécuté 98 tests unittest, fidélité mesurée à 0,00 pt. C'est l'exigence « à la loyale » : un port supposé marcher sans tests lancés ne compte pas.

Vitesse mesurée : décode ~56 t/s (moteur seul) → ~70 t/s via le pont sur du code, soit ~4× le Coder DeepSeek sous Vulkan. Le secret du décode : le MTP — une tête interne brouillonne jusqu'à 7 tokens d'avance, le modèle complet les vérifie en un passage et ne garde que les justes (94 % de bons premiers brouillons sur du code). ⚠️ Le MTP n'accélère que le décode, jamais le prefill.

Un signal de maturité : une PR « optimize HIP kernels gfx1151 » a été fermée non mergée, l'auteur concluant que le gain réel de ces micro-optimisations sur ce chip est ~1-3 % → les kernels sont déjà quasi au plafond du silicium. Sur un modèle résident, il n'y a plus grand-chose à gratter côté noyau.

Verdict. L'option ouverte, pérenne, auditable. Un peu plus de montage (ses poids + le pont), mais c'est devenu notre étalon — le point de référence que le reste doit battre.


3. Claude — la référence cloud (et pourquoi elle reste au tableau)

Ce n'est pas un moteur local. C'est Claude (Opus) via Claude Code / l'API Anthropic. Mise en œuvre : triviale — pas de GPU, pas de poids, pas de pont. On le cite ici parce que c'est la barre : la qualité et surtout le jugement contre lesquels on jauge les moteurs locaux.

Son rôle dans les essais n'est pas la vitesse (il est distant) mais l'audit : sur un refactor réel, Claude repère des bugs de logique métier et de données que les modèles locaux recopient en silence. Le local rattrape l'écart de transcription ; l'écart de jugement reste, lui, l'argument du cloud. D'où sa présence permanente comme repère.


4. Maya (DeepSeek-V4.1-Flash-1017) — l'échec, et pourquoi

Ce que c'est. Un moteur (Project Maya) pour un autre modèle, plus gros : DeepSeek-V4.1-Flash-1017 (pas Qwen). Vocabulaire DSpark/Engram/packs, API Anthropic native, cible ~43 t/s annoncés — alléchant.

La partie qui a marché : le build.

  • Compilation HIP via clang-21/CMake. On a buté sur le bug Ubuntu de librocwmma-dev (le paquet omet tout le sous-dossier internal/ que les headers incluent → fatal error: 'internal/accessors.hpp' file not found). Correctif : cloner rocWMMA à la bonne version (rocm-7.1.0) et compléter le dossier système par un symlink. Build OK ensuite (~47 000 tenseurs empaquetés).
  • Un quirk de placement de l'Engram (le modèle re-publié en v2 ne portait pas le même nommage que ses tables) → placement manuel, sha256 vérifiés.

La partie qui a échoué : le run. Maya-XS (le petit quant, « tout le modèle dans un PC 128 Go ») tente d'allouer ~103 Gio d'un bloc (échec reproductible cudaMalloc couche 38). Sur nos 122 Gio moins le bureau, ça ne tient pas — et l'OOM-killer du noyau sacrifie nos propres applications : il a tué l'app de pilotage (fin de session), le terminal, le client mail.

  • --mmap-experts on et --ssd-cache auto n'évitent pas l'allocation de la couche 38.
  • Réduire le contexte (256K → 64K) ne change rien (ce n'est pas le cache KV le problème).

Lecture honnête. Ce n'est pas un défaut de Maya : c'est la réalité du plafond RAM. Un modèle taillé pour « 128 Go » ne laisse aucune marge pour un bureau graphique. Pour le faire tenir résident (donc rapide), il faudrait tourner headless (couper la session graphique, piloter en SSH depuis une autre machine, pour libérer ~10-15 Gio). Le forcer à streamer du SSD = lent = on perd tout l'intérêt. Le téléchargement (590 Go) fut par ailleurs long et incomplet à plusieurs reprises. Mis en pause.


Ce que j'en retire

MoteurCodeLivraisonPoidsAPIDécode mesuréStatut
halogenFermé (EULA)ConteneurNotre GGUF (BYO)OpenAI + Anthropic~45 t/s MTP (prose ~37)OK, turnkey
strixiteOuvert (AGPL)Conteneur ou TheRockLes siens ~115 GoOpenAI (→ pont)~56 → ~70 t/s (code)Étalon
Claude— (cloud)——Anthropicn/a (distant)Référence/jugement
Maya (1017)OuvertBuild HIP~115 Go + EngramAnthropic— (n'a pas tourné)Échec (OOM)

Trois leçons durables :

  1. Le plafond RAM est le vrai juge. Sur 128 Go unifiés avec un bureau, un moteur qui vise ~66-80 Gio passe ; un qui vise ~103-115 Gio d'un bloc tue la session. Ce n'est pas une question de finesse de kernel.
  2. Conteneur > compilation. halogen et strixite évitent le chantier ROCm/rocWMMA en embarquant leur runtime. Maya, qui fallait compiler, a d'abord coûté le détour rocWMMA — puis a buté sur la RAM de toute façon.
  3. La finesse de kernel est déjà pressée. Sur un modèle résident gfx1151, l'auteur de strixite estime lui-même le reste à gratter à ~1-3 %. Le levier de vitesse restant n'est pas le kernel, c'est le modèle qui tient en RAM + le spéculatif (MTP).

Tous les chiffres « mesurés » le sont sur cette machine, un run, sans étude de variance. Les chiffres « annoncés » sont ceux des auteurs, non reproduits indépendamment. Rien n'est survendu : halogen et strixite tiennent la route, Maya n'a pas pu tourner ici.