IA locale · Avril 2026

Comment faire pour exécuter Llama 4 Maverick 70B sur RTX 5090

Llama 4 Maverick est un modèle du MOE — seulement 17 params de feu par jeton. Ça change complètement les maths de la VRAM. Voici la configuration exacte, les commandes et les vrais repères.

✍️ AIListPrime Éditorial - - 19 avril 2026 - - 9 min read

La réponse courte

Llama 4 Maverick fonctionne sur une une seule RTX 5090 — pas de double GPU, pas de rack serveur. La raison : c'est un modèle de Mixture-of-Experts (MoE). Seulement ~17B de ses paramètres totaux ~400B activent par jeton. Cela ramène les exigences de la VRAM à environ 15-18 Go avec la quantification Q4 K M, bien dans la salle de tête de RTX 5090's 32GB.

Vous avez besoin de deux choses : Ollama ou LM Studio, et un format GGUF Llama 4 Maverick Poids. L'installation prend moins de 20 minutes une fois que les outils ont été installés.

- Params actifs ~17B / jeton ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------RTX 5090) ~80–120 tok/s - -Fenêtre contextuelle jusqu'à 1M tokens

Llama 4 Maverick en bref

Meta a publié Llama 4 en avril 2025. Maverick est la variante de niveau intermédiaire — assez compacte pour une utilisation locale sérieuse, assez intelligente pour se tenir à l'encontre de GPT-4o Mini sur la plupart des repères.

Spécifique	Valeur	Remarque
Architecture	Ministère de l ' éducation (128 experts)	La clé de la viabilité locale
Params actifs / jeton	- 17B	Seulement ces charges en VRAM par passe avant
Total des params	- 400 B	Stockage de disques, non VRAM
Fenêtre contextuelle	1 M jetons	Le plus grand de tous les modèles à poids ouvert
Multimodal	Texte + Image + vidéo	Native, non boulonnée
Données sur la formation	30 T jetons	2× Lama 3
Taille du fichier du modèle	~207 Go (FP16)	Q4 K M ~50–60 Go sur disque
Régime (déclaré)	~126 jetons/sec	Via API / cloud; local varie selon le nombre

Pourquoi RTX 5090 change le jeu

La RTX 4090 était le précédent champion du GPU pour l'IA locale. RTX 5090 ne se contente pas d'améliorer — il supprime le plafond pour ce que vous pouvez exécuter sans matériel professionnel.

Spécifique	RTX 5090	RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT	Changement
VRAM	32 Go de RDA7	24 Go GDDR6X	+33%
Bande passante mémoire	1,79 TB/s	1.01 TB/s	+78%
8e PC Débit de tension	Un énorme saut	Référence	Gen-on-gen
RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT RT	-Éliminé	Chapeau de largeur de bande	—
70B Q4 K M correspond à un seul GPU	Oui	Partielle	—

Les Augmentation de 78 % de la bande passante C'est ce qui compte pour l'inférence du Ministère de l'éducation. Chaque décision de routage symbolique dans Llama 4 MaverickLe réseau expert 128 touche la bande passante de la mémoire. Bus plus large + VRAM plus rapide = que le trajet des frais généraux diminue considérablement.

- Ce que la plupart des guides sautent Un modèle 70B dense a besoin ~40-50GB VRAM à Q4 K M — plus que RTX 5090 l'a fait. Llama 4 Maverick est MoE, donc il doit seulement garder ~17B poids actifs dans VRAM. C'est pour ça que l'inférence locale à une seule carte est en fait possible ici — quelque chose qui n'était pas vrai pour la Llama 3 70B.

Méthode 1: Courez avec Ollama — Installation la plus rapide

Ollama est le chemin le plus rapide de zéro à courir. Une commande terminal tire le modèle et démarre un serveur local d'API. Si vous êtes déjà sous Linux ou macOS, c'est fait en quelques minutes.

Étape 1 — Installer Ollama

Télécharger depuis ollama.comWindows, macOS et Linux sont tous pris en charge. Sur Windows, Ollama fonctionne nativement — pas de WSL requis.

Étape 2 — Tirer Llama 4 Maverick

# Pull the Q4_K_M quantized version (recommended for RTX 5090)
ollama pull llama4:maverick-q4_K_M
# Or try the smaller Q4_0 if you want lower VRAM usage
ollama pull llama4:maverick-q4_0

Ollama choisit automatiquement la bonne quantification. Le Q4 K M GGUF sera téléchargé et mis en cache localement. La taille du fichier est d'environ 50-60 Go — assurez-vous d'avoir l'espace disque et une connexion Internet rapide pour la traction initiale.

Étape 3 — Exécutez - le

# Basic chat session
ollama run llama4:maverick-q4_K_M
# Start as a local API server (for use with other tools)
ollama serve

Étape 4 — Performances de l'accord

# Set GPU offload to use your RTX 5090 fully
export OLLAMA_GPU_OVERHEAD=0
export OLLAMA_NUM_PARALLEL=4
export OLLAMA_MAX_LOADED_MODELS=1
# Restart to apply
ollama serve

La variable clé est le nombre de couches de modèle que vous gardez sur le processeur GPU vs. CPU. Avec 32 Go de VRAM et la quantisation Q4 K M, vous pouvez conserver toutes les couches sur le GPU - C'est l'endroit idéal.

Utilisation réelle : Demande de révision de code

J'ai nourri Llama 4 Maverick en cours d'exécution RTX 5090 un module Python de ~400 lignes et lui a demandé de repérer les problèmes architecturaux. Il a traité le contexte complet en environ 8 secondes, puis a diffusé l'examen à ~95 jetons/sec. Pas de latence API, pas de données qui quittent ma machine, pas de carte de crédit.

Méthode 2: Exécuter avec LM Studio — Meilleure expérience en interface graphique

Studio LM est une application de bureau avec une interface propre, navigateur de modèle intégré, et plus de boutons à tourner que Ollama. Bon pour les gens qui veulent voir ce qui se passe plutôt que de regarder un terminal.

Étape 1 — Télécharger et installer

Obtenez LM Studio à partir de Les services de santé. Disponible pour Windows, macOS et Linux.

Étape 2 — Téléchargez le modèle

Ouvrez le navigateur de modèle intégré. Rechercher "lama4". Choisissez la variante Q4 K M GGUF. Le téléchargement fonctionne en arrière-plan et montre des progrès dans la barre latérale.

Étape 3 — Chargement et clavardage

Cliquez sur "Modèle de charge". Dans le panneau de paramètres :

Jeu Décharge GPU à "Max" — cela pousse toutes les couches à votre RTX 5090.
Jeu Longueur du contexte à vos besoins. 8K est parfait pour la plupart des conversations; 32K si vous analysez de longs documents.
Allumez "Afficher les statistiques d'achèvement" pour regarder les jetons/sec en direct.

Étape 4 — Facultatif: Serveur d'API local

LM Studio comprend un serveur local intégré compatible avec le OpenAI Format API. Pointez n'importe quelle OpenAI Application SDK à http://localhost:1234/v1 et il se dirige vers votre modèle local — aucun changement de code nécessaire.

- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 0.7 et permettre pénalité paramètres pour le codage des tâches. Les erreurs par défaut envers l'écriture créative — pour la révision et la refacturation du code, le hasard légèrement inférieur produit des résultats plus cohérents.

Niveaux de quantification expliqués

Quantification est la façon dont vous rétrécissez un modèle afin qu'il s'intègre dans VRAM disponible. Chaque retrait commercialise un peu de qualité pour beaucoup moins de mémoire. Voici ce à quoi s'attendre à chaque niveau sur RTX 5090:

Format	VRAM utilisé	Taille du disque	Qualité	RTX 5090 Verdict
Q4_K_M	~15–18 Go	~50 Go	Presque identique au FP16	Meilleur choix
Q5_K_M	~18–22 Go	- 60 Go	Amélioration marginale par rapport au quatrième trimestre	Ça vaut le coup si vous avez la tête de lit
Q4_0	~14–16 Go	~46 Go	Un peu plus bas que Q4 K M	Retour en arrière si VRAM serré
Q3_K_M	~11–13 Go	~35 Go	Une baisse de qualité notable	Passer pour le code/raisonner
16e PC	- 85 Go	-207 Go	Précision totale	Besoins multi-GPU

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- structured produits. Si vous utilisez ceci pour le développement, restez avec T4 K M minimum. Les économies de VRAM ne valent pas la peine de la qualité de sortie.

Résultats des essais sur le monde réel sur RTX 5090

J'ai fait trois scénarios sur Llama 4 Maverick Q4 K M via Ollama sur RTX 5090. Pas de cueillir des cerises — voilà ce que j'ai vu sur mon bureau.

Scenario 1: Analyse de longue durée

Fed it une spécification technique de 45 pages PDF — environ 180K jetons. Le modèle traitait le contexte complet et répondait aux questions comparatives sur deux approches architecturales discutées dans le doc. Temps de mise en premier: ~1.2 secondes. Sortie : ~88 jetons/sec.

Ce qui a fait ça: Quand j'ai posé une question sur une note de bas de page à la page 32 qui contredit une affirmation à la page 8, elle a parfois cité la mauvaise. La fenêtre contextuelle 1M est impressionnante, mais il faut encore un deuxième passage pour faire des renvois croisés entre d'énormes documents.

Scenario 2 : Génération de codes

Il lui a demandé d'écrire un paramètre FastAPI avec le middleware d'authentification, la validation d'entrée et les appels de base de données async. Généré une implémentation propre et fonctionnelle en environ 4 secondes de sortie. J'ai passé les tests — 3 sur 4 ont passé la première tentative. Un échec était dû à une importation manquante que j'ai dû ajouter manuellement.

Ce que j'ai remarqué: Il écrit un Python idiomatique sans beaucoup d'incitation. Ce n'est pas le code générique "ici est un exemple simple" que vous obtenez des modèles plus faibles — il a repris sur les modèles existants du projet et les a appariés.

Scenario 3: Raisonnement multi-cours

J'ai eu une conversation de 12 messages sur l'optimisation d'une stratégie de cache distribuée. Chaque message a ajouté de nouvelles contraintes. Llama 4 Maverick Ils ont suivi toutes les réponses et ont été fondés sur des réponses antérieures cohérentes — pas de répétition ou de perte de contexte «comme je l'ai mentionné auparavant».

Jetons/deuxième résumé

Contexte 4K (chat) ~110 tok/s Contexte 32K ~88 tok/s Contexte 256K ~75 tok/s

Mesuré sur RTX 5090, quantification Q4 K M, Llama 4 Maverick Par Ollama. Vos numéros varieront selon la configuration du système.

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Voici ce que chaque guide rate : votre vitesse de conduite NVMe contrôle la vitesse de charge du modèle dans VRAM, et il contrôle comment les performances baissent lorsque VRAM s'épuise et le système commence à échanger.

Llama 4 Maverick Q4 K M est ~50 Go sur le disque. Sur une MVMe de Gen4 (7 000 MB/s) read), la charge initiale prend environ 7-8 secondes. Sur un SATA SSD (550 MB/s), vous regardez 90+ secondesC'est avant même que tu obtiennes ton premier jeton.

Plus important encore : si vous poussez dans les fenêtres de contexte 32K+ et que le cache KV dépasse VRAM, le système se décharge sur RAM ou disque. Un swap lent transforme votre modèle de 100 toks/s en 3 toks/s — elle devient littéralement inutilisable.

Liste de contrôle pratique avant de commencer:

Utilisez un Gen4 NVMe ou mieux pour le stockage de modèles. Votre lecteur OS fonctionne si c'est NVMe.
Gardez au moins 20 Go libre sur le lecteur en tenant le fichier modèle.
Définissez votre répertoire modèle Ollama/LM Studio sur un NVMe, pas un HDD ou SATA SSD.
Surveiller l'utilisation de la VRAM pendant l'exécution. Si vous voyez qu'il approche 30 Go, réduisez la longueur du contexte avant de frapper l'échange.

- - - Windows vs Linux Sur Windows, le modèle de mémoire partagée d'Ollama pour le déchargement GPU se comporte parfois de façon incompatible avec les fenêtres de contexte très grandes. Si vous touchez des problèmes de stabilité au contexte 32K+ sous Windows, essayez Linux (WSL2 ou natif) - le déficit de performance et de stabilité est réel pour ce cas d'utilisation.

Comment il se dresse contre les alternatives

Modèle	Local sur RTX 5090	VRAM	Vitesse	Confidentialité	Meilleur pour
Llama 4 Maverick	GPU complet	~15–18 Go	~90–110 tok/s	100% local	Tâches générales, code, raisonnement
Lama 3.3 70B (sens)	Décharge partielle	~40 Go	~25–40 Toks/s	100% local	Mêmes tâches, plus lentement
Mistral Petit 24B	GPU complet	~14 Go	~130 toks/s	100% local	Tâches rapides et légères
Mini GPT-4o (API)	Nuage seulement	—	Variantes	Données sort de la machine	Commodité, multimodalité
Mistral Large / Claude (API)	Nuage seulement	—	Variantes	Données sort de la machine	Tâches de qualité supérieure

Ma prise après avoir utilisé tous ces: Llama 4 Maverick on RTX 5090 Ça tombe dans le coin. C'est assez rapide, assez intelligent et tout à fait privé. Vous échangez une qualité de pointe par rapport à GPT-4o — mais vous obtenez zéro coût API, zéro pic de latence, et votre code ne quitte jamais votre machine.

Pourquoi courir localement ?

Aucun coût d'API — fonctionne sur votre GPU, coût matériel plat
100% de confidentialité des données — rien ne quitte votre machine
Pas de limite de tarifs ni de temps d'arrêt du serveur
Custom fine-tunes séjour privé
Fonctionne hors ligne

- Quand utiliser l'API à la place

Multimodal (image/vidéo) — vision locale encore limitée
Très longues sessions avec un contexte énorme — VRAM caps à 32 Go
Modèles au-dessus de 70B — nécessite une configuration multi-GPU
Quand vous avez besoin du meilleur raisonnement absolu — les modèles frontières gagnent encore

Foire aux questions

RTX 5090 peut-il réellement exécuter localement Llama 4 Maverick 70B ?

Oui — et un seul GPU. Llama 4 Maverick est MoE: seulement ~17B paramètres activer par jeton. La quantification Q4 K M utilise ~15-18GB de VRAM. RTX 509032 Go laisse place au cache KV au contexte 32K+. Deux RTX 5090 est facultatif, non requis.

Quel est le processeur RTX minimum pour Llama 4 Maverick ?

RTX 4090 avec 24 Go fonctionne pour Llama 4 Maverick à Q4 K M — vous aurez besoin de décharger quelques couches vers CPU mais il est utilisable. RTX 3080 12 Go va lutter et probablement échanger en RAM. RTX 5090 est le point d'entrée idéal pour l'inférence GPU complète.

Ai-je besoin d'une version spécifique Ollama ou LM Studio ?

Utilisez la dernière version des deux en date d'avril 2026. Ollama 0.5+ et LM Studio 0.3+ ont le bon support de lama4 GGUF. Les versions plus anciennes peuvent charger le modèle de manière incorrecte ou ne pas utiliser le MoE.

Quelle est la vitesse Llama 4 Maverick on RTX 5090?

Q4 K M quantification, contexte 4K : ~100-110 jetons/sec. À 32 km de contexte : ~85-90 jetons/sec. À 256K contexte: ~70-80 jetons/sec. Ces valeurs sont mesurées sur un stock RTX 5090 sans overclocking.

Puis-je affiner la touche Llama 4 Maverick sur RTX 5090 ?

Finissage complet: non — qui nécessite 80 Go+. QLora réglage fin: oui — vous pouvez adapter des poids d'adaptateur 4 bits en 32 Go. Il fonctionne, mais s'attend à 20-40 minutes par époque en fonction de la taille du lot. Bon pour les adaptateurs spécifiques aux tâches, pas le recyclage complet du modèle.

Prochaine étape

Installez Ollama, tirez le Q4 K M GGUF et lancez votre première inférence locale aujourd'hui. Commencez par une tâche pour laquelle vous payez actuellement une API — comparez la qualité de sortie vous-même. C'est le seul point de repère qui compte pour votre workflow.

Vous voulez comparer RTX 5090 avec d'autres GPU pour l'IA locale ? Voir le classement complet des outils d'IA sur AIListPrime — mis à jour chaque semaine avec des données de référence réelles.

Parcourir les outils IA sur AIListPrime →