Un guide pratique pour les responsables techniques et les développeurs qui veulent faire tourner des grands modèles de langage (LLM) sur l'ordinateur portable du développeur, sous Linux, plutôt que sur un serveur partagé ou un GPU dans le cloud. Il couvre ce qui tient dans 16 GB et 24 GB de mémoire GPU d'un portable, le calcul qui le justifie, les modèles ouverts qui valent la peine d'être utilisés en novembre 2026, la configuration d'Ubuntu 26.04 avec la pile NVIDIA, l'exécution de modèles avec Ollama, llama.cpp et vLLM, leur intégration aux outils de développement, l'affinage avec LoRA, la consommation et la chaleur, la sécurité, et le moment où une tâche doit passer sur un serveur ou dans le cloud.
Cette note technique accompagne notre article de blog Ordinateurs portables pour développeurs IA : pourquoi chaque équipe d'IA devrait donner à ses développeurs leur propre GPU, qui présente l'argumentaire économique. La machine d'exemple est le Juno Neptune 18", un portable Linux de 18 pouces que nous vendons. Les tailles de modèles proviennent de la bibliothèque Ollama et les chiffres des GPU de NVIDIA, vérifiés le 18 novembre 2026. Les vitesses dépendent du modèle, de la quantification, du contexte et des réglages d'alimentation ; nous expliquons donc comment mesurer plutôt que de citer des chiffres de benchmark.
1. Pourquoi placer le GPU sur le bureau du développeur
L'essentiel du développement d'IA est une boucle interne : modifier un prompt, une étape de récupération, une définition d'outil ou quelques lignes de code, l'exécuter, lire le résultat, recommencer. Cette boucle tourne des centaines de fois par jour. Lorsque chaque exécution attend un GPU partagé, le démarrage d'une instance cloud ou une API soumise à des limites de débit, les développeurs regroupent leurs modifications et apprennent plus lentement. Un modèle local répond en quelques secondes, fonctionne hors ligne et ne coûte rien par appel.
- Confidentialité. Le code source, les données clients et les prompts ne quittent jamais un appareil géré par l'entreprise. Cela simplifie les évaluations au titre du UK GDPR et les contrats clients qui interdisent l'envoi de données à des API tierces.
- Réalisme. Les développeurs voient les limites réelles des modèles ouverts (longueur de contexte, quantification, mémoire) avant la production.
- Parité. Linux, le pilote NVIDIA, CUDA et les conteneurs sont les mêmes que sur vos serveurs GPU ; un prototype passe donc sur un serveur sans modification.
- Disponibilité. Pas de file d'attente, pas de quota, pas de dépendance à une panne pendant le développement.
Un portable ne remplace pas les serveurs. L'entraînement, les affinages importants, les longues campagnes d'évaluation et le service en production relèvent d'un serveur GPU partagé ou d'un cluster (section 11).
2. La machine
Les chiffres qui comptent pour le travail d'IA, pour le Neptune 18" tel que configuré dans notre boutique. Les chiffres des GPU sont ceux de NVIDIA ; les autres sont ceux du fabricant.
| Composant | Spécification | Pourquoi c'est important |
|---|---|---|
| GPU (standard) | GPU NVIDIA GeForce RTX 5080 Laptop : 16 GB de GDDR7, 256 bits, 7 680 cœurs CUDA, 1 334 TOPS d'IA | Contient sur le GPU les modèles de 8–20B et leur cache KV |
| GPU (sur demande) | GPU NVIDIA GeForce RTX 5090 Laptop : 24 GB de GDDR7, 256 bits, 10 496 cœurs CUDA, 1 824 TOPS d'IA | Ajoute la classe 27–32B et un contexte plus long |
| Puissance du GPU | 150 W + 25 W de Dynamic Boost dans ce châssis (plages de NVIDIA : 80–150 W pour le RTX 5080, 95–150 W pour le GPU RTX 5090 Laptop) | La vitesse soutenue dépend de la puissance ; lancez les longues tâches sur secteur |
| CPU | Intel Core Ultra 9 290HX Plus, 24 cœurs (8P + 16E), jusqu'à 5,5 GHz ; 55 W de base, 160 W max | Tokenisation, chargement des données et déport de couches du modèle sur le CPU |
| Mémoire | 32 à 192 GB de DDR5 (2 modules à 5600 MHz jusqu'à 96 GB ; 4 modules à 4000 MHz pour 128 et 192 GB) | De la place pour des modèles plus grands que la mémoire GPU (section 4) |
| Stockage | 1 × M.2 2280 PCIe Gen 5 + 3 × M.2 2280 PCIe Gen 4, jusqu'à 16 TB | Les fichiers de modèles pèsent 5–140 GB chacun ; conservez une bibliothèque en local |
| Écran | 18" 16:10, QHD+ 240 Hz (RTX 5080) ou UHD+ 200 Hz (RTX 5090), 100 % DCI-P3 | De la place pour le code, le terminal et le notebook côte à côte |
| Connectique | 2 × Thunderbolt 4 / USB-C, 2 × USB-A, HDMI et Mini DisplayPort (reliés au GPU NVIDIA), Ethernet 2,5 Gb, Wi-Fi 7 | Transferts rapides de modèles et de jeux de données |
| Alimentation | Batterie de 99 Wh, chargeur de 330 W | Le travail sur GPU se fait sur secteur |
| Logiciels | Kubuntu ou Ubuntu 26.04 LTS préinstallé | La même famille de système d'exploitation que la plupart des serveurs GPU |
3. Ce qui tient : la mémoire GPU décide
Lorsque les poids d'un modèle, son cache KV et le moteur d'exécution tiennent tous dans la mémoire GPU, la génération est rapide. Dans le cas contraire, une partie du modèle s'exécute depuis la mémoire système via PCIe et sur le CPU, et la vitesse chute fortement. La première question à se poser pour tout modèle est donc sa taille.
| Modèle (tag Ollama) | Téléchargement | RTX 5080 (16 GB) | RTX 5090 (24 GB) | Usage idéal |
|---|---|---|---|---|
| qwen3:8b | 5,2 GB | Sur le GPU, long contexte | Sur le GPU | Assistant généraliste rapide, agents, RAG |
| qwen3:14b | 9,3 GB | Sur le GPU | Sur le GPU | Raisonnement plus solide à bonne vitesse |
| gpt-oss:20b (OpenAI, MoE) | 14 GB | Sur le GPU, contexte court à moyen | Sur le GPU, contexte plus long | Raisonnement, utilisation d'outils, code généraliste |
| gemma3:27b (Google) | 17 GB | Partiellement déporté | Sur le GPU | Rédaction, multilingue, images en entrée |
| qwen3.8:27b | 18 GB | Partiellement déporté | Sur le GPU | Code, recherche et tâches d'agent, texte et images |
| qwen3-coder:30b (MoE, environ 3B actifs) | 19 GB | Experts déportés, encore utilisable | Sur le GPU | Complétion de code et agents de développement |
| nemotron-3.5-lightning:30b (NVIDIA, MoE, 3B actifs) | 19–25 GB | Experts déportés | Quantification plus petite sur le GPU | Agents permanents, jusqu'à 1M de contexte |
| qwen3:32b | 20 GB | Partiellement déporté | Sur le GPU, contexte court | Qualité d'un modèle dense de 32B |
| llama3.3:70b (Meta) | 43 GB | GPU + RAM système (64 GB ou plus) : lent, suffisant pour des vérifications | Comparaison avec un modèle de classe serveur | |
| gpt-oss:120b (OpenAI, MoE, 5,1B actifs) | 65 GB | GPU + RAM système (96 GB ou plus) : utilisable grâce au MoE | Raisonnement ouvert proche de l'état de l'art sur un portable | |
| qwen3:235b (MoE) | 142 GB | GPU + 192 GB de RAM : expérimental | Essayer un très grand modèle avant d'acheter un serveur | |
Les tailles correspondent aux tags Ollama par défaut, pour la plupart des quantifications 4 bits. Les licences diffèrent (Apache 2.0, conditions Gemma, licence Llama de Meta, licence de modèle ouvert de NVIDIA, etc.) : consultez la fiche de chaque modèle avant de l'utiliser à des fins commerciales.
4. Le calcul de mémoire
Trois éléments se partagent la mémoire GPU : les poids, le cache KV et le moteur d'exécution.
Poids
weights ≈ parameters × bits per weight ÷ 8. Un modèle de 14B pèse 28 GB en 16 bits, environ 14–15 GB en 8 bits et environ 8–9 GB en 4 bits (les formats 4 bits stockent un peu d'information supplémentaire par bloc, de sorte que les fichiers réels sont légèrement plus gros qu'un demi-octet par paramètre). La perte de qualité d'une bonne quantification 4 bits est faible pour la plupart des travaux de développement ; le 8 bits est proche de l'original. Les GPU Blackwell, y compris la série RTX 50, prennent aussi en charge matériellement le FP4 et le FP8, que des moteurs d'exécution tels que TensorRT-LLM et vLLM peuvent exploiter.
Cache KV
Pour chaque token du contexte, chaque couche stocke une clé et une valeur : KV bytes per token = 2 × layers × KV heads × head size × bytes per value. Pour Llama 3.1 8B, cela donne 2 × 32 × 8 × 128 × 2 = 131 072 octets (128 KiB) en 16 bits. Le cache croît linéairement avec la longueur du contexte et avec le nombre de requêtes servies simultanément.
Un modèle de 8B qui pèse 5 GB sur disque nécessite donc environ 23 GB avec son contexte complet de 128K. Trois moyens de le faire tenir :
- Utilisez le contexte dont vous avez besoin. La plupart des travaux de code et de RAG se satisfont de 16–32K. Les moteurs d'exécution réservent le cache pour le contexte que vous définissez ; définissez-le donc.
- Quantifiez le cache. Un cache KV en 8 bits le divise par deux avec une faible perte de qualité ; en 4 bits, il le divise par quatre. Dans Ollama, définissez
OLLAMA_FLASH_ATTENTION=1etOLLAMA_KV_CACHE_TYPE=q8_0; dans llama.cpp, utilisez--cache-type-k q8_0 --cache-type-v q8_0. - Privilégiez les modèles à attention groupée (grouped-query) ou à autre attention compacte. Moins de têtes KV signifie un cache plus petit ; la fiche du modèle les indique.
Moteur d'exécution
Prévoyez 1–2 GB pour le contexte CUDA, les activations et les tampons, et n'oubliez pas que le bureau utilise lui aussi de la mémoire GPU lorsque les écrans sont pilotés par le GPU NVIDIA. Vérifiez avec nvidia-smi avant de charger un modèle.
La vitesse, et pourquoi la mémoire système compte encore
Générer chaque token implique de lire une fois chaque poids actif ; la vitesse de génération est donc limitée principalement par la bande passante mémoire : la GDDR7 du GPU est plusieurs fois plus rapide que la DDR5 du portable. C'est pourquoi un modèle qui déborde dans la mémoire système ralentit, et pourquoi les modèles à mélange d'experts (MoE) font exception : gpt-oss-120b compte 117B paramètres, mais seuls environ 5,1B sont actifs pour chaque token ; garder les couches partagées sur le GPU et les experts en mémoire système offre donc encore une vitesse utilisable. Pour ce type de travail, une mémoire système plus abondante et plus rapide aide : deux modules à 5600 MHz sont plus rapides que quatre à 4000 MHz ; choisissez donc 96 GB (2 × 48 GB), sauf si vous avez besoin de 128 ou 192 GB pour la capacité.
Mesurez sur votre propre travail : ollama run <model> --verbose affiche les débits de traitement du prompt et de génération en tokens par seconde, et llama-bench fait de même pour llama.cpp.
5. Configurer Ubuntu 26.04 pour le travail d'IA
Les machines que nous livrons arrivent avec le pilote NVIDIA installé et vérifié. Pour en vérifier ou en reconstruire une :
# Is the NVIDIA GPU visible, and which driver is in use?
nvidia-smi
# Ubuntu's recommended NVIDIA driver (signed for Secure Boot)
sudo ubuntu-drivers list
sudo ubuntu-drivers install
sudo reboot
# Laptops with two GPUs: run everything on the NVIDIA GPU, or only what asks for it
prime-select query
sudo prime-select nvidia # or: on-demand
Avec Secure Boot activé, un pilote compilé localement nécessite l'enregistrement de sa clé de signature (MOK) au démarrage suivant ; les pilotes empaquetés par Ubuntu évitent cette étape. Prenez le pilote soit dans l'archive d'Ubuntu, soit dans le dépôt de NVIDIA, mais pas dans les deux.
Conteneurs avec le GPU
Les conteneurs permettent de conserver des versions de CUDA par projet et correspondent à ce qui s'exécute sur les serveurs. Installez Docker (ou Podman), puis le NVIDIA Container Toolkit depuis le dépôt apt de NVIDIA en suivant son guide d'installation, et raccordez-le :
sudo apt-get install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker
# Test: the container should list the laptop GPU
docker run --rm --gpus all ubuntu nvidia-smi
Python
Utilisez un environnement virtuel par projet (uv ou venv) et installez PyTorch avec le build CUDA que sa page d'installation recommande pour votre pilote. Vérifiez-le avec python -c "import torch; print(torch.cuda.is_available(), torch.cuda.get_device_name(0))".
6. Exécuter des modèles
Ollama : le démarrage le plus rapide
curl -fsSL https://ollama.com/install.sh | sh
ollama run gpt-oss:20b # downloads once, then runs locally
ollama ps # shows how much of the model is on the GPU vs the CPU
ollama ps est la première vérification : « 100% GPU » est ce que vous voulez voir. Si une part de CPU apparaît, réduisez le contexte, quantifiez le cache KV ou choisissez un modèle plus petit. Ollama écoute sur 127.0.0.1:11434 et sert une API compatible OpenAI sur /v1 ; la plupart des outils peuvent donc l'utiliser sans modification.
llama.cpp : le contrôle total
# All layers on the GPU, 32K context, 8-bit KV cache, OpenAI-compatible server on :8080
llama-server -m qwen3-14b-q4_k_m.gguf --n-gpu-layers 99 --ctx-size 32768 \
--cache-type-k q8_0 --cache-type-v q8_0 --host 127.0.0.1 --port 8080
# A MoE model bigger than GPU memory: keep shared layers on the GPU, put experts in system RAM
# (recent llama.cpp builds; raise the number until it fits)
llama-server -m gpt-oss-120b.gguf --n-gpu-layers 99 --n-cpu-moe 24 --ctx-size 16384
vLLM : le plus proche du service en production
pip install vllm
vllm serve Qwen/Qwen3-8B --max-model-len 16384 --gpu-memory-utilization 0.85
# OpenAI-compatible API on http://127.0.0.1:8000/v1
vLLM préalloue la mémoire GPU pour son cache KV ; sur un GPU de portable de 16 GB, gardez donc des modèles de petite taille et définissez --max-model-len. Son intérêt est la parité : le même serveur, les mêmes options et la même API que sur vos serveurs GPU.
LM Studio est une application de bureau pour la même tâche, avec un navigateur de modèles et une API locale, utile pour ceux qui ne vivent pas dans un terminal.
7. Assistants de code et agents sur un modèle local
La plupart des assistants d'IDE, agents de développement et frameworks d'agents acceptent une URL de base compatible OpenAI. Dirigez-les vers http://127.0.0.1:11434/v1 (Ollama), :8080/v1 (llama.cpp) ou :8000/v1 (vLLM). Choix pratiques en novembre 2026 :
- Complétion pendant la frappe : un modèle petit et rapide (qwen3:8b ou similaire). La latence compte plus que la taille.
- Conversation et refactorisation : gpt-oss:20b sur 16 GB ; qwen3-coder:30b ou qwen3.8:27b sur 24 GB.
- Agents avec outils : des modèles entraînés à l'appel d'outils (gpt-oss, famille Qwen3, Nemotron 3.5 Lightning), avec suffisamment de contexte pour les résultats des outils, généralement 32K ou plus.
Conservez un modèle de pointe hébergé pour les problèmes les plus difficiles si votre politique le permet ; le modèle local traite en toute confidentialité le volume quotidien. De nombreuses équipes routent selon la tâche : local par défaut, hébergé à la demande.
8. Affiner un modèle sur un portable
L'affinage complet ne serait-ce que d'un modèle de 7B nécessite bien plus de 24 GB. LoRA et QLoRA entraînent de petites matrices d'adaptation par-dessus des poids figés (QLoRA conserve le modèle de base en 4 bits), ce qui rend l'affinage possible sur un portable :
- 16 GB (RTX 5080) : QLoRA sur des modèles de 7–8B avec des longueurs de séquence modestes ; jusqu'à environ 14B avec des outils d'économie de mémoire et des séquences courtes.
- 24 GB (RTX 5090) : QLoRA sur 14B confortablement, et jusqu'à environ 30B avec des séquences courtes.
- Au-delà : les affinages de 70B et les affinages complets passent sur un serveur (section 11).
Utilisez PEFT et TRL de Hugging Face, ou Unsloth pour réduire l'utilisation de mémoire, avec le gradient checkpointing et une taille de lot de un ou deux plus l'accumulation de gradients. Ces plages dépendent de la longueur de séquence, du rang et des outils : commencez petit, surveillez nvidia-smi et augmentez progressivement. Le portable est idéal pour vérifier les formats de données, les hyperparamètres et les scripts d'évaluation sur une petite exécution avant de payer pour une longue.
9. Consommation, chaleur et batterie
- Branchez-vous sur secteur pour le travail GPU. Sur batterie, le GPU fonctionne à puissance réduite ; c'est le chargeur de 330 W qui permet de soutenir des charges GPU de plus de 150 W.
- Surveillez-le :
nvidia-smi dmon -s pucmaffiche en continu la consommation, l'utilisation, les fréquences et la mémoire ;nvidia-smi -q -d POWER,TEMPERATUREindique les limites. - Tâches longues : dégagez les aérations, utilisez le profil d'alimentation performance et attendez-vous à entendre les ventilateurs. Pour les tâches de plusieurs heures, un poste fixe ou un serveur est l'outil le plus adapté.
10. Sécurité et gouvernance
- Chiffrez le disque. Le chiffrement intégral du disque (LUKS) protège le code, les données et les fichiers de modèles en cas de perte du portable ; nous le configurons avant l'expédition lorsqu'il est commandé.
- Gardez les serveurs de modèles en local. Ollama, llama.cpp et vLLM n'ont pas d'authentification des utilisateurs par défaut. Liez-les à
127.0.0.1; ne les exposez jamais sur0.0.0.0sur un Wi-Fi de bureau ou public sans un proxy qui authentifie. - Sachez d'où viennent les modèles. Téléchargez-les depuis les dépôts officiels de l'éditeur, préférez safetensors et GGUF aux formats capables d'exécuter du code au chargement, et tenez une liste des modèles approuvés et de leurs licences.
- Gérez l'appareil. Mises à jour, chiffrement du disque et verrouillage de l'écran relèvent de votre gestion habituelle des appareils ; les données traitées localement restent des données personnelles au sens du UK GDPR.
11. Quand sortir le travail du portable
| Signal | Passer sur |
|---|---|
| Le modèle nécessite plus de 24 GB à pleine vitesse, ou un long contexte pour de nombreux utilisateurs | Une station de travail ou un serveur avec RTX PRO 6000 (96 GB), ou un système DGX |
| Une tâche dure des heures, ou bloque la machine du développeur | Un serveur GPU partagé, avec ordonnancement |
| Plusieurs développeurs ont besoin du même modèle toute la journée | Un point de terminaison d'inférence d'équipe unique au lieu de nombreuses copies |
| Entraînement multi-GPU ou service en production | Cluster ou cloud, avec résidence des données au Royaume-Uni si nécessaire |
Pas encore prêt à acheter ? Workstation Rentals loue des portables d'IA et des stations de travail GPU à la semaine ou au mois, et GPU Leasing explique comment les prendre en location longue durée.
12. Quelle configuration pour quel développeur
| Rôle | GPU | Mémoire système | Stockage |
|---|---|---|---|
| Développeur d'applications utilisant l'IA (RAG, agents, assistants) | RTX 5080, 16 GB | 64 GB | 2 TB |
| Ingénieur IA (évaluation, affinage, modèles de 27–32B) | RTX 5090, 24 GB | 96 GB (2 × 48 GB, le plus rapide) | 4 TB |
| Chercheur qui teste en local de très grands modèles MoE | RTX 5090, 24 GB | 128–192 GB | 4 TB ou plus |
| Data scientist (notebooks, ML classique, petits modèles) | RTX 5080, 16 GB | 64–96 GB | 2–4 TB |
13. Questions fréquentes
Un portable peut-il vraiment exécuter un modèle de 120B ? gpt-oss-120b, oui, avec 96 GB de mémoire système ou plus, car seuls environ 5,1B paramètres sont actifs par token. Les modèles denses de 70B fonctionnent aussi, mais lentement ; utilisez-les pour comparer des réponses, pas pour un travail interactif.
16 GB ou 24 GB ? 16 GB couvrent la classe 8–20B, qui suffit à la plupart des travaux de développement. Choisissez 24 GB si vous travaillez avec des modèles de 27–32B, des contextes longs ou des affinages au-delà de 8B.
Pourquoi Linux plutôt que Windows ? Les serveurs, les conteneurs et la plupart des outils d'IA sont conçus d'abord pour Linux. Développer sur le même système d'exploitation élimine toute une catégorie de problèmes du type « ça marche sur ma machine ».
Un modèle local remplace-t-il les modèles de pointe hébergés ? Pas pour les tâches les plus difficiles. Il absorbe le volume quotidien en toute confidentialité et à moindre coût ; conservez un modèle hébergé pour ce qui l'exige, lorsque la politique le permet.
Et Apple silicon ? Les Mac dotés d'une grande mémoire unifiée exécutent bien les grands modèles avec MLX, mais sans CUDA. Si vos serveurs sont sous NVIDIA et Linux, un portable Linux NVIDIA garde une pile identique.
Sources
- NVIDIA, spécifications des GPU pour portables GeForce RTX série 50 (cœurs CUDA, TOPS d'IA, mémoire, largeur d'interface, plage de puissance du GPU), consultées le 18 novembre 2026.
- Pages de la bibliothèque Ollama pour qwen3, gpt-oss, gemma3, qwen3.8, qwen3-coder, nemotron-3.5-lightning et llama3.3 (tailles de téléchargement et descriptions), consultées le 18 novembre 2026.
- OpenAI, fiche du modèle gpt-oss (117B paramètres au total et environ 5,1B paramètres actifs pour gpt-oss-120b).
- Meta, configuration de Llama 3.1 8B (32 couches, 8 têtes KV, taille de tête 128), utilisée pour l'exemple de cache KV.
- Juno Computers, spécifications du Neptune 18" ; fiche de la boutique Workstation (configuration, prix et délai d'expédition).
- Les commandes suivent la documentation d'Ubuntu, du NVIDIA Container Toolkit, d'Ollama, de llama.cpp et de vLLM ; les options changent d'une version à l'autre, consultez donc la documentation actuelle.
Mention des droits : NVIDIA, GeForce, RTX, CUDA, cuDNN, NCCL, TensorRT, DGX, Blackwell et Nemotron sont des marques de NVIDIA Corporation. Intel et Core Ultra sont des marques d'Intel Corporation. Ubuntu et Kubuntu sont des marques de Canonical Ltd. Juno et Neptune sont des noms de Juno Computers Ltd. Llama est une marque de Meta Platforms, Inc. ; Gemma, de Google LLC ; Qwen, d'Alibaba Cloud ; gpt-oss et OpenAI, d'OpenAI. Les autres noms sont la propriété de leurs détenteurs respectifs. Cet article est indépendant et n'est approuvé par aucune de ces entreprises.