Comment faire tourner un modèle de 35 milliards de paramètres sur une carte graphique de 4 Go
C'est la question légitime : un modèle Qwen3.6-35B-A3B en Q4_K_M pèse 21.9 Go. Ta carte graphique NVIDIA T1000 ne dispose que de 4 Go de VRAM. Comment est-il possible d'atteindre des performances correctes ?
La réponse tient en trois mots : LLaMA.cpp fait de la magie noire. Plus précisément, il répartit intelligemment le modèle entre trois ressources : la VRAM du GPU, la RAM système, et le CPU. Voici comment cela fonctionne en détail.
Carte professionnelle entrée de gamme. Architecture Pascal (GP107). 256 CUDA cores. Bande passante ~48 GB/s. C'est le point faible, mais pas bloquant grâce à l'offload partiel.
Architecture Rocket Lake (11e gen). Fréquence boost 5.0 GHz. Support AVX-512. C'est le moteur principal de calcul quand le GPU est saturé. Très performant pour l'inférence CPU.
La RAM système sert de tampon entre le GPU et le CPU. Les couches non placées sur le GPU y sont stockées et chargées à la demande. 32 Go suffisent amplement pour un modèle Q4 de 21.9 Go.
L'offload partiel (partial offload) est la technique qui permet de ne pas tout mettre sur le GPU. Au lieu de copier l'intégralité du modèle en VRAM, LLaMA.cpp répartit les couches du modèle (les 40 couches de Qwen3.6) entre le GPU et le CPU.
Un modèle de langage est composé de couches empilées. Qwen3.6-35B-A3B a 40 couches. Chaque couche contient des poids (matrices de transformation) et des opérations d'attention. LLaMA.cpp découpe le modèle couche par couche et place les premières couches sur le GPU.
LLaMA.cpp utilise un algorithme de placement qui maximise le nombre de couches sur le GPU tout en respectant la contrainte de VRAM. Pour ton setup :
# Exemple de répartition sur ta T1000 4Go
# Modèle Q4_K_M : 21.9 Go total
GPU (T1000, 4 Go VRAM)
├── Couche 0 → ~0.5 Go (embeddings + projection)
├── Couche 1 → ~0.5 Go (attention + FFN)
├── Couche 2 → ~0.5 Go
├── Couche 3 → ~0.5 Go
├── Couche 4 → ~0.5 Go
├── Couche 5 → ~0.5 Go
├── Couche 6 → ~0.5 Go
├── Couche 7 → ~0.5 Go
└── ~0.5 Go réservé pour les buffers CUDA
RAM + CPU (i7-11700K, 32 Go)
├── Couche 8 → ~0.55 Go
├── Couche 9 → ~0.55 Go
├── ... couches 10 à 39 ...
└── ~18.4 Go restants (couches 8-39)
LLaMA.cpp n'est pas un simple chargeur de modèle. C'est un moteur d'inférence optimisé au niveau du compilateur :
Le secret n'est pas dans le GPU, mais dans l'algorithme. Grâce au MoE (Mixture of Experts), Qwen3.6-35B-A3B n'active que ~3 milliards de paramètres par token, pas 35 milliards. C'est 12x moins de calculs que le modèle le suggère par ses paramètres totaux. L'inférence MoE est intrinsèquement plus légère, ce qui compense partiellement le transfert PCIe entre CPU et GPU.
La T1000 ne stocke que ~8 couches sur 40 (soit ~20% du modèle). Le reste est en RAM et calculé par le CPU. Mais voici pourquoi les performances restent correctes :
Seulement ~3B paramètres actifs par token. Le modèle est conçu pour être léger à l'inférence. C'est l'avantage majeur du MoE sparse.
Le bus PCIe 3.0 x16 offre ~16 GB/s de bande passante. Les couches CPU→GPU sont transférées au fur et à mesure. Le GPU calcule, le CPU prépare la suite.
8 cœurs / 16 threads à 5.0 GHz en boost. AVX-512 activé. Le CPU fait le gros du travail de calcul. C'est un excellent CPU pour l'inférence LLM.
Voici ce que tu peux attendre avec ton Lenovo Thinkstation P350 (T1000 4Go + i7-11700K + 32 Go RAM) :
~15-25 tok/s sur CPU. Le GPU accélère les 8 premières couches (embeddings + attention initiale). Le reste est calculé par le CPU. Correct pour du chat interactif, un peu lent pour du code génératif long.
~10-18 tok/s sur CPU. Le modèle est trop gros pour tenir en RAM seule sans swapping. Performance réduite car tout passe par la RAM. À éviter si tu veux de la réactivité.
~25-40 tok/s sur CPU. Le modèle tient entièrement en RAM sans toucher au GPU. Plus rapide car pas de transfert PCIe. Qualité dégradée mais acceptable pour du chat quotidien.
Le compromis : Q4_K_M est le sweet spot. Q3_K_M serait plus rapide mais au prix de la qualité. Q5_K_M serait plus précis mais plus lent. Le choix dépend de ton usage : si tu veux de la réactivité, Q3_K_M. Si tu veux de la qualité, Q4_K_M. Si tu as besoin du maximum de précision et que tu peux attendre, Q5_K_M.
LM Studio et Ollama utilisent tous les deux LLaMA.cpp en backend, mais avec des approches différentes :
Permet de contrôler le nombre de couches GPU via l'interface. Slider "GPU Layers" pour régler manuellement combien de couches vont sur la T1000. Plus de contrôle mais plus de configuration manuelle. Auto-détection du matériel.
Détermine automatiquement le nombre optimal de couches GPU. Configuration via le fichier Modelfile. Moins de contrôle manuel mais plus simple à utiliser. Moins de overhead car pas d'interface graphique.
# Dans LM Studio → Settings → GPU
# Nombre de couches GPU (GPU Layers)
GPU Layers : 8 ~20% du modèle sur la T1000
# Precision (qualité du calcul GPU)
GPU Precision : FP16 Meilleur équilibre vitesse/qualité
# Offload strategy
Offload Strategy : Partial Essentiel pour la T1000
# KV Cache (mémoire pour le contexte)
KV Cache Size : 4096 ~4K tokens en KV cache GPU
# Au-delà, le KV cache passe en RAM → plus lent
Qwen3.6 n'utilise que ~3B paramètres actifs par token. C'est comme si tu faisais tourner un modèle de 3B paramètres, mais avec la connaissance d'un modèle de 35B. La sparsité est le super-pouvoir du MoE.
Le Gated DeltaNet remplace l'attention standard par une attention linéaire. Complexité O(n) au lieu de O(n²) en longueur de séquence. Moins de calculs = plus rapide, même sur CPU.
Pas de framework lourd (PyTorch, TensorFlow). Juste du C/C++ pur avec des kernels mathématiques optimisés. Zéro overhead. C'est comme comparer une Ferrari de course à un camion de déménagement.
8 cœurs / 16 threads à 5.0 GHz avec AVX-512. C'est un CPU desktop haut de gamme. Pour l'inférence LLM sur CPU, c'est excellent. La plupart des laptops ne sont pas aussi performants.
4.89 bits par poids donne une qualité quasi-identique au FP16 avec 4.5x moins de mémoire. La perte de précision est négligeable pour la plupart des tâches. C'est la quantification la plus intelligente.
Le bus PCIe 3.0 x16 offre ~16 GB/s. Les données transférées sont des poids quantifiés (4 bits), donc compacts. Le transfert CPU→GPU n'est pas le goulot d'étrangrement principal.
Ton Lenovo Thinkstation P350 fait tourner Qwen3.6-35B-A3B grâce à une combinaison de facteurs :
Le verdict : Tu n'as pas besoin d'une RTX 4090 pour faire tourner un modèle frontier. Avec une T1000 4Go, un i7 moderne et LLaMA.cpp, tu obtiens des performances tout à fait utilisables. C'est la beauté de l'open source : des modèles de qualité production, accessibles sur du matériel grand public.