La boutique est ouverte

Nous construisons les machines Workstation AI pour les sites web, les agents IA et l'entraînement de LLM — configurez-les et achetez-les en ligne.

Obtenir les prix pro
Produits IA
Labs IAAgents OpenAIAgents ClaudeGrok BotCRM natif Workstation AIMarketingTous les produits
Solutions IA
IA appliquéeAgents IAIA générativeAutomatisation par IAMontée en compétence IAOffres IA pour PMELaboratoire IA d'entrepriseStations de travail IAMatériel et logiciels NVIDIACalcul accéléré NVIDIAIA privéeCloud privé GPUClusters GPUIA en périphérieIA par secteur
Services IA
Modernisation des plateformesIngénierie numériqueFondations data et IAOpérations autonomesConseil IAAutomatisation DevOpsCybersécuritéDéveloppement logicielCréation d'agentsMise en place MLOpsLocation de GPUCloud privé GPU
À propos
EntrepriseNotre histoirePartenairesTémoignages clients
Centres de données IA
Centres de données IACloud privé GPUClusters GPULocation de GPU
Analyses IASérie JevLabo de benchmarksChoix de modèles
Notes techniques
Documentation
OS LinuxUbuntuRed Hat Enterprise LinuxSUSE LinuxAlpine LinuxDebian, Rocky & AlmaLinux
Plateformes cloud d'IAAWS & Amazon BedrockGoogle Cloud & Vertex AIMicrosoft Azure & AI FoundryClouds et places de marché GPU
Centres de données IA privésPour les cabinets d'avocatsPour les cabinets comptablesPlateformes sur siteCloud entièrement sécurisé
OutilsRing PromoterJobshout
Actualités
Blog
Nous contacterSe connecter

Stations de travail IA, logiciels multi-agents IA, infrastructure GPU et solutions d'agents intelligents pour les entreprises modernes.

Nous contacter

Solutions IA

IA appliquéeAgents IAIA générativeAutomatisation par IAMontée en compétence IAOffres IA pour PMELaboratoire IA d'entrepriseIA par secteur

Produits

Tous les produitsCRM & ERP natifs Workstation AIMarketingAgents OpenAIRing PromoterJobshout

Entreprise

À proposEntrepriseCentres de données IAPourquoi WorkstationPartenairesTémoignages clientsTarifsContactTenthMatrix

Ressources

Analyses IANotes techniquesDocumentationOS LinuxPlateformes cloud d'IACentres de données IA privésBlogRechercherPlan du site
Siège social au Royaume-Uni
77-79 Marlowes, Hemel Hempstead HP1 1LFItinéraire : prenez la sortie 20 de la M25, Outer LondonN° d'entreprise: 11641870Lun - Ven : 9h00 - 18h00 GMT
+44 7515 356 146
Bureau de Belgique
Workstation SRL, Rue Vanderkindere 34, 1180 Uccle, BrusselsBE 0751.518.683Lun - Ven : 9h00 - 18h00 CET
+32 492 45 67 46
Bureau de l'Inde
#159 Sector 9, Pocket 1, DDA Flats, 110077 Dwarka, New Delhi
+91 98881 98841
Bureau de Taïwan
3F, No. 2-4, Aisi Rd., Ren'ai Dist., Keelung City 200, Taiwan基隆市仁愛區愛四路2之4號3樓Lun - Ven : 9 h 00 - 18 h 00, heure de Taïwan (GMT+8)
+886 926 892 701+32 492 45 67 46
Bureau en Estonie
Aleksander Puškini tn 30-25, 20306 Narva, EstoniaLun - Ven : 9 h 00 - 18 h 00, heure d’Estonie (EET)
+32 492 45 67 46

© 2026 Workstation AI. Tous droits réservés.

ConfidentialitéSuppression des donnéesCookiesConditions d'utilisationPlan du site web

NVIDIA, le logo NVIDIA, RTX, RTX PRO, Blackwell, CUDA, NVLink, MGX, Omniverse, Spectrum-X, Quantum, BlueField, DGX et HGX sont des marques commerciales et/ou des marques déposées de NVIDIA Corporation aux États-Unis et dans d'autres pays. AMD, le logo AMD Arrow, EPYC, Instinct, Ryzen et Threadripper sont des marques commerciales d'Advanced Micro Devices, Inc. Dell et PowerEdge sont des marques commerciales de Dell Inc. ou de ses filiales. Intel et Xeon sont des marques commerciales d'Intel Corporation ou de ses filiales. AMAX, AceleMax et LiquidMax sont des marques commerciales d'AMAX Engineering Corporation. Tous les autres noms de produits, logos et marques appartiennent à leurs propriétaires respectifs. Nous les utilisons uniquement pour identifier les produits que nous décrivons, fournissons ou prenons en charge ; leur utilisation ne signifie pas que leurs propriétaires nous cautionnent.

Accueil / Notes techniques / Technology
AIHardwareLinuxLLMs

Portables pour développeurs IA : exécuter des LLM en local sous Linux avec des GPU de 16 GB et 24 GB (guide 2026)

Ce qui tient sur un GPU RTX 5080 ou RTX 5090 Laptop, le calcul de mémoire, les modèles ouverts qui valent la peine, la configuration d'Ubuntu 26.04 avec la pile NVIDIA, Ollama, llama.cpp et vLLM, les assistants de code, l'affinage LoRA, la sécurité, et quand passer le travail sur un serveur

18 novembre 2026Technology18 min read

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.

Illustration d'un ordinateur portable de 18 pouces exécutant gpt-oss:20b en local, avec les 16 GB du GPU RTX 5080 Laptop, les 24 GB du GPU RTX 5090 Laptop, jusqu'à 192 GB de DDR5 et Ubuntu 26.04 LTS.

Synthèse. C'est la mémoire GPU qui détermine ce qu'un portable peut exécuter. Un GPU RTX 5080 Laptop (16 GB) exécute entièrement sur le GPU les meilleurs modèles ouverts actuels de 8–20B, dont gpt-oss-20b d'OpenAI ; un GPU RTX 5090 Laptop (24 GB) y ajoute la classe 27–32B, comme Gemma 3 27B, Qwen3.8 27B, Qwen3-Coder 30B et Nemotron 3.5 Lightning de NVIDIA. Les modèles plus grands (Llama 3.3 70B, gpt-oss-120b) s'exécutent en répartissant le travail entre le GPU et la mémoire système, plus lentement mais utilement, d'où l'importance de 96–192 GB de DDR5. Prévoyez le cache KV en plus du modèle : avec un long contexte, il peut être aussi volumineux que le modèle lui-même. Sous Linux, le portable exécute les mêmes pilote, CUDA et conteneurs que vos serveurs GPU ; la boucle de développement reste donc sur le bureau, et seules les tâches lourdes passent 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.

ComposantSpécificationPourquoi 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'IAContient 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'IAAjoute la classe 27–32B et un contexte plus long
Puissance du GPU150 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
CPUIntel Core Ultra 9 290HX Plus, 24 cœurs (8P + 16E), jusqu'à 5,5 GHz ; 55 W de base, 160 W maxTokenisation, chargement des données et déport de couches du modèle sur le CPU
Mémoire32 à 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)
Stockage1 × M.2 2280 PCIe Gen 5 + 3 × M.2 2280 PCIe Gen 4, jusqu'à 16 TBLes fichiers de modèles pèsent 5–140 GB chacun ; conservez une bibliothèque en local
Écran18" 16:10, QHD+ 240 Hz (RTX 5080) ou UHD+ 200 Hz (RTX 5090), 100 % DCI-P3De la place pour le code, le terminal et le notebook côte à côte
Connectique2 × Thunderbolt 4 / USB-C, 2 × USB-A, HDMI et Mini DisplayPort (reliés au GPU NVIDIA), Ethernet 2,5 Gb, Wi-Fi 7Transferts rapides de modèles et de jeux de données
AlimentationBatterie de 99 Wh, chargeur de 330 WLe travail sur GPU se fait sur secteur
LogicielsKubuntu 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.

Graphique à barres des tailles de téléchargement des modèles par rapport aux seuils de 16 GB et 24 GB. Tiennent dans 16 GB : qwen3:8b 5,2 GB, qwen3:14b 9,3 GB, gpt-oss:20b 14 GB. Nécessitent 24 GB : gemma3:27b 17 GB, qwen3.8:27b 18 GB, qwen3-coder:30b et nemotron-3.5-lightning:30b 19 GB, qwen3:32b 20 GB. Nécessitent aussi la RAM système : llama3.3:70b 43 GB, gpt-oss:120b 65 GB, qwen3:235b 142 GB.

Modèle (tag Ollama)TéléchargementRTX 5080 (16 GB)RTX 5090 (24 GB)Usage idéal
qwen3:8b5,2 GBSur le GPU, long contexteSur le GPUAssistant généraliste rapide, agents, RAG
qwen3:14b9,3 GBSur le GPUSur le GPURaisonnement plus solide à bonne vitesse
gpt-oss:20b (OpenAI, MoE)14 GBSur le GPU, contexte court à moyenSur le GPU, contexte plus longRaisonnement, utilisation d'outils, code généraliste
gemma3:27b (Google)17 GBPartiellement déportéSur le GPURédaction, multilingue, images en entrée
qwen3.8:27b18 GBPartiellement déportéSur le GPUCode, recherche et tâches d'agent, texte et images
qwen3-coder:30b (MoE, environ 3B actifs)19 GBExperts déportés, encore utilisableSur le GPUComplétion de code et agents de développement
nemotron-3.5-lightning:30b (NVIDIA, MoE, 3B actifs)19–25 GBExperts déportésQuantification plus petite sur le GPUAgents permanents, jusqu'à 1M de contexte
qwen3:32b20 GBPartiellement déportéSur le GPU, contexte courtQualité d'un modèle dense de 32B
llama3.3:70b (Meta)43 GBGPU + RAM système (64 GB ou plus) : lent, suffisant pour des vérificationsComparaison avec un modèle de classe serveur
gpt-oss:120b (OpenAI, MoE, 5,1B actifs)65 GBGPU + RAM système (96 GB ou plus) : utilisable grâce au MoERaisonnement ouvert proche de l'état de l'art sur un portable
qwen3:235b (MoE)142 GBGPU + 192 GB de RAM : expérimentalEssayer 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.

Barres empilées pour Llama 3.1 8B en 4 bits : à 8K tokens, 4,9 GB de poids, 1,1 GB de cache KV et 1 GB pour le moteur d'exécution font 7,0 GB. À 32K, 4,3 GB de cache portent le total à 10,2 GB. À 128K, 17,2 GB de cache portent le total à 23,1 GB, au-delà de 16 GB et juste en dessous de 24 GB.

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=1 et OLLAMA_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

La pile d'IA sous Linux en sept couches : votre travail ; les moteurs d'exécution de modèles tels qu'Ollama, llama.cpp, LM Studio, vLLM, SGLang et TensorRT-LLM ; les frameworks tels que PyTorch, Transformers, PEFT et Unsloth ; Docker ou Podman avec le NVIDIA Container Toolkit ; le pilote NVIDIA, CUDA, cuDNN et NCCL ; Ubuntu 26.04 LTS ; et le matériel.

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 pucm affiche en continu la consommation, l'utilisation, les fréquences et la mémoire ; nvidia-smi -q -d POWER,TEMPERATURE indique 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 sur 0.0.0.0 sur 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

Trois colonnes : sur le portable, la boucle interne quotidienne de prompts, d'assistants de code, de prototypes RAG, de tests, de petits affinages LoRA et de travail hors ligne ; sur un serveur GPU partagé, les évaluations hebdomadaires de l'équipe, les affinages de 30 à 70B, un point de terminaison d'équipe, les tâches à long contexte et les modèles de plus de 24 GB ; sur un cluster ou dans le cloud, les travaux ponctuels tels que le pré-entraînement, le service en production, les tests de charge et les tâches multi-nœuds.

SignalPasser sur
Le modèle nécessite plus de 24 GB à pleine vitesse, ou un long contexte pour de nombreux utilisateursUne 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éveloppeurUn serveur GPU partagé, avec ordonnancement
Plusieurs développeurs ont besoin du même modèle toute la journéeUn point de terminaison d'inférence d'équipe unique au lieu de nombreuses copies
Entraînement multi-GPU ou service en productionCluster 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ôleGPUMémoire systèmeStockage
Développeur d'applications utilisant l'IA (RAG, agents, assistants)RTX 5080, 16 GB64 GB2 TB
Ingénieur IA (évaluation, affinage, modèles de 27–32B)RTX 5090, 24 GB96 GB (2 × 48 GB, le plus rapide)4 TB
Chercheur qui teste en local de très grands modèles MoERTX 5090, 24 GB128–192 GB4 TB ou plus
Data scientist (notebooks, ML classique, petits modèles)RTX 5080, 16 GB64–96 GB2–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.

Partager cet article

Plus dans Technology

Tester des systèmes ML et LLM impossibles à prouver corrects : une boîte à outils Python d'éléments probants

Tester des systèmes ML et LLM impossibles à prouver corrects : une boîte à outils Python d'éléments probants

Des éléments probants à la place des preuves, en environ 400 lignes de Python avec une sortie réelle : métriques par segment avec intervalles bootstrap et contrat de réussite ou d'échec, tests de propriétés et métamorphiques avec Hypothesis, calibration et prédiction conforme, contrats Pydantic et évaluations de non-régression pour les sorties LLM, contrôles de dérive, barrière en CI et vérification exacte d'un petit réseau de neurones

Lire la suite
TorchCurves en pratique : courbes B-spline et de Legendre apprenables dans PyTorch

TorchCurves en pratique : courbes B-spline et de Legendre apprenables dans PyTorch

Installer torchcurves, ajuster et dimensionner une courbe, choisir entre B-spline et Legendre ainsi que l’application d’entrée, construire une courbe de calibration monotone et un modèle additif sur des données tabulaires, comparer avec SciPy, scikit-learn, un KAN et un MLP, exporter les coefficients en JSON, tester et exploiter en production, avec des sorties réelles

Lire la suite
Exécuter des modèles agentiques, vocaux et de vision sur l'appareil avec Cactus : guide pratique (2026)

Exécuter des modèles agentiques, vocaux et de vision sur l'appareil avec Cactus : guide pratique (2026)

Installer cactus-compute, effectuer des appels d'outils, filtrer par niveau de confiance avec repli vers un modèle plus grand, extraire des données structurées, exécuter la parole et la vision, mesurer la latence et la mémoire, et livrer un conteneur hors ligne, avec chaque exemple exécuté et une comparaison avec llama.cpp, ONNX Runtime, ExecuTorch, MLC LLM et TensorRT Edge-LLM

Lire la suite