Fondations & Architecture

Infrastructure & Hardware Aware Inference

12 MINUTES DE LECTURE

intermédiaire

Badge disponible

🎧Inférence & Hardware

Écoutez le résumé audio de ce module.

0:00

--:--

Balado généré via NotebookLM

🎯 Au programme Nous allons décortiquer la mécanique sous-jacente d’un moteur d’Intelligence Artificielle. L’objectif est de comprendre comment dimensionner votre machine et mesurer la performance brute avant de coder la moindre logique métier.

Concepts Clés de la Séquence

VRAM

Codex

Video RAM. La mémoire de la carte graphique. C'est l'espace de travail principal où l'agent charge les poids du modèle pour "réfléchir" rapidement.

En savoir plus

Inférence (Edge AI)

Codex

Le processus d'exécution d'un modèle d'IA pour générer une réponse (Edge AI = inférence en local, sans cloud).

En savoir plus

Quantisation (GGUF)

Codex

GPT-Generated Unified Format. Un format de fichier optimisé pour stocker les modèles LLM de manière à pouvoir les charger très rapidement en mémoire, popularisé par llama.cpp.

En savoir plus

TTFT (Time To First Token)

Codex

Time To First Token. Mesure la latence réseau et le temps de réflexion initiale (combien de temps avant de voir le premier mot s'afficher).

En savoir plus

Pour construire un système IA d’élite, il ne suffit pas d’enchaîner des appels API vers le Cloud. Un véritable Architecte comprend la mécanique sous-jacente de son moteur.

S’enfermer exclusivement dans l’écosystème d’un fournisseur unique (Vendor Lock-in) est un risque industriel majeur (coûts incontrôlés, fuite de données, censure). L’objectif n’est pas de rejeter le Cloud, mais de l’utiliser en pleine conscience, en maîtrisant d’abord les fondamentaux de l’inférence locale (Edge AI).

1. La VRAM : Le Goulot d’étranglement

Pour qu’un LLM génère du texte de manière fluide, l’intégralité de ses poids (paramètres) doit être chargée dans la VRAM (Video RAM) de votre GPU. Contrairement au CPU séquentiel classique, le GPU est conçu pour le calcul matriciel massif, indispensable à l’inférence.

Si votre modèle est trop lourd et déborde sur la RAM système classique (Swap), la vitesse de génération s’effondrera instantanément (passant par exemple de 50 tokens/sec à 2 tokens/sec).

Règle de Dimensionnement

Avant de déployer un modèle, un ingénieur doit savoir s’il “passe” en mémoire. Voici la formule empirique d’allocation :

text

VRAM Requise (Go) ≈ (Paramètres en Milliards) × (Précision en octets) + 20% (Contexte)

Exemple avec Llama-3 8B (8 Milliards de paramètres) :

En précision native FP16 (16 bits = 2 octets) : 8 * 2 = 16 Go (+ 20% = ~19 Go de VRAM).
Conclusion pragmatique : Sans optimisation, exécuter un modèle pourtant “petit” exigerait une infrastructure onéreuse. C’est ici qu’intervient la quantisation.

2. La Quantisation (Optimiser le Silicium)

La quantisation est une technique de compression mathématique. Elle réduit la précision des paramètres du réseau de neurones (ex: passer de nombres à virgule flottante 16 bits à des entiers 4 bits). Le modèle perd une fraction microscopique de sa nuance, mais divise son poids par 4.

Format	Précision	VRAM Requise (8B)	Rétention Intellectuelle	Usage Industriel Recommandé
FP16	16-bit	~19 Go	100% (Baseline)	Entraînement / Fine-Tuning
Q8_0	8-bit	~9 Go	~99%	Agents critiques (Serveurs)
Q4_K_M	4-bit	~5.5 Go	~95%	Inférence Locale / Edge AI

Le Format GGUF Dans l’écosystème open-source, le format standard est le .gguf. Il s’agit d’un fichier binaire unique encapsulant l’architecture du modèle, ses poids quantifiés et son tokenizer. C’est le format idéal pour la portabilité absolue.

3. Architecture d’Exécution : Vue d’Ensemble

Voici comment se structure l’orchestration matérielle d’une requête d’inférence souveraine, avant même d’atteindre votre code applicatif :

Le Comparatif des Moteurs d’Inférence

Vous n’êtes pas obligés de tout coder de zéro. Des moteurs d’inférence open-source (écrits en C++ ou Rust) gèrent l’allocation mémoire pour vous et exposent une API HTTP :

Moteur	Avantages	Inconvénients	Usage Principal
Ollama (Le standard Dev)	Ultra-léger, installation 1 clic, tâche de fond.	Moins performant sous très haute charge.	Prototypage, Agents locaux, Desktop apps.
MLX (Apple Silicon)	L’API native Apple, le feu sur Mac (VRAM partagée).	Uniquement pour l’écosystème Mac (M1/M2/M3…).	Prototypage Mac, Inférence ultra-optimisée.
oMLX (Apple Silicon)	Un wrapper Rust pour MLX exposant une API compatible OpenAI.	Uniquement pour l’écosystème Mac, jeune projet.	Inférence Mac avec tooling OpenAI compatible.
BentoML (Le couteau suisse)	Flexible, permet de packager et déployer facilement.	Courbe d’apprentissage plus raide.	Déploiement multi-modèles de production.
vLLM (Le standard Cloud)	Throughput maximal, gestion PagedAttention, ultra-rapide.	Lourd à installer (Python), nécessite GPU Datacenter.	Serveurs de production, hébergement SaaS.
Hugging Face TGI (Text Gen Inference)	Extrêmement robuste en production, écosystème officiel HF.	Orienté Datacenter, complexe en local.	APIs de production à fort trafic.
LM Studio (L’interface visuelle)	Interface graphique (GUI) magnifique, sans CLI.	Logiciel fermé (closed-source), lourd.	Expérimentation manuelle, Data Analysts.

Dans cette formation, nous utiliserons Ollama pour son intégration parfaite dans les workflows de développement Node.js/TypeScript.

Prérequis : Installation d'Ollama

Avant d’écrire notre premier script, vous devez installer le moteur et télécharger un modèle.

Vérifiez d’abord la compatibilité de votre machine sur canirun.ai — cet outil vous indique en 10 secondes si votre GPU/CPU peut faire tourner Ollama. En fonction des résultats, n’hésitez pas à choisir le modèle le plus adapté à votre matériel.
Allez sur Ollama.com , téléchargez et installez l’application.
Ouvrez votre terminal et exécutez la commande suivante (notre modèle recommandé par défaut) : ollama pull gemma4:e4b
Attendez la fin du téléchargement (environ 9 Go).

Pourquoi le modèle gemma4:e4b ? gemma4 est un LLM (Large Language Model) local ultra-performant. Pourquoi le recommander par défaut plutôt que le classique Llama 3.1 8B ? Parce que gemma4 est l’un des premiers modèles à intégrer nativement les capacités Textuelles, Visuelles et Audios. En l’utilisant, vous vous éviterez de devoir télécharger et jongler avec 3 modèles différents lorsque nous attaquerons la multimodalité au Module 06 ! (Si la version e4b de 9 Go est trop lourde pour votre machine, rabattez-vous sur la version allégée : ollama pull gemma4:e2b)

Astuce : Activer CORS pour le navigateur Par défaut, Ollama bloque les requêtes provenant des navigateurs web (sécurité CORS). Pour que votre future interface web puisse communiquer avec votre Ollama local, vous devez l’autoriser explicitement :

Sur Mac/Linux : Fermez l’application Ollama, puis lancez-la depuis un terminal avec la commande OLLAMA_ORIGINS="*" ollama serve.

Sur Windows : Ajoutez la variable d’environnement OLLAMA_ORIGINS avec la valeur * dans les paramètres système de Windows, puis quittez completement Ollama (via la barre des tâches) et relancez-le.

🤖 Alternative SLM (Small Language Models) : Si votre machine souffre avec un LLM classique comme Gemma 4 ou Llama 3, vous pouvez opter pour un SLM (Small Language Model). Ce sont des modèles ultra-légers (souvent < 4 milliards de paramètres) qui tournent sur la majorité des ordinateurs portables sans saturer la RAM. Phi-3 (Microsoft) ou Qwen 2.5 sont d’excellentes alternatives très rapides (ollama pull phi3).

💻 Alternative Cloud (Si votre machine est très limitée) : Si vous n’avez pas de GPU dédié ou que votre ordinateur (ex: vieux PC, Chromebook) ne peut pas faire tourner l’inférence locale de manière fluide, pas de panique ! Vous pouvez suivre toute la formation en utilisant vos propres clés d’API (OpenAI, Anthropic, etc.) ou en créant un compte gratuit sur Groq ou OpenRouter pour faire tourner des modèles open-source à la vitesse de l’éclair. Nous verrons cela lors du Module 05 pour configurer vos clés si nécessaire.

4. Travaux Pratiques : Initialisation de Nexus

Pour ce projet fil rouge, nous allons utiliser le Starter Kit fourni avec la formation. Il contient la structure de base, les données d’entreprise simulées (employés, salaires de NovaTech) et les scripts d’initialisation.

Ouvrez votre terminal, placez-vous dans le dossier du starter kit et exécutez :

bash

# 1. Installez les configurations TypeScript et les dépendances locales
npm install

# 2. Installez les dépendances du Vercel AI SDK et de Zod
npm install ai @ai-sdk/openai zod

Ouvrez ce dossier dans votre éditeur (VSCode, Cursor…). Créez le fichier apps/backend/src/index.ts (le dossier src/ de départ est actuellement vide). Nous allons y écrire nos premières lignes de code.

Top-Level Await & ESM Le fichier package.json du starter kit est configuré avec "type": "module". Cela indique à Node.js que le projet utilise les modules ECMAScript (ESM) et permet ainsi d’utiliser le mot-clé await à la racine de vos fichiers TypeScript sans erreur.

Structure du projet

nexus-project/
- package.json
- apps/
  - backend/
    - src/
      - index.ts (nouveau)
    - scripts/
      - seed.ts
    - package.json
    - tsconfig.json

A. Mission : Profiler l’Inférence Locale (TTFT)

Avant de donner une intelligence complexe à notre agent, nous devons mesurer la performance brute de notre “cerveau” local. L’une des métriques industrielles les plus importantes est le TTFT (Time To First Token).

Étape intermédiaire : Le Ping de la machine

Avant de calculer des millisecondes, vérifions que votre script arrive à parler avec votre carte graphique locale. Tapez ceci dans apps/backend/src/index.ts :

typescript

// apps/backend/src/index.ts
console.log("📡 Ping du serveur Ollama local...");
const res = await fetch("http://127.0.0.1:11434/api/tags");
const data = await res.json();
console.log("✅ Modèles disponibles :", data.models.map((m: any) => m.name).join(", "));
export {};

Exécutez avec npx tsx apps/backend/src/index.ts. Vous devriez voir “gemma4:e4b” dans la liste.

Quête Principale : Profiler l'Inférence Locale (TTFT)

Objectif : Dans apps/backend/src/index.ts, écrivez un script qui mesure le temps de réponse brut d’un LLM local en millisecondes.

Prérequis : Lancez Ollama en fond et téléchargez un modèle via ollama pull modele-adapte-a-votre-machine.

💡 Éléments & Indices :

L’URL de l’API locale est http://127.0.0.1:11434/api/generate.
Utilisez la fonction native fetch() en POST. Le payload JSON requiert le model (“gemma4:e4b”), le prompt, et stream: false.
Le Prompt Engineering : Ne demandez pas juste “Bonjour”. Demandez explicitement au modèle de répondre de manière concise (ex: “Confirme que tes systèmes sont opérationnels en une seule phrase.”) pour minimiser le temps de génération et isoler le temps de réflexion pur.
Voici la structure de base pour démarrer votre script :

typescript

// apps/backend/src/index.ts
const ENGINE_URL = "http://127.0.0.1:11434/api/generate";

async function runInferenceProfile() {
  const startTime = performance.now();
  
  // 1. TODO: Faire le fetch() POST vers l'URL
  // 2. TODO: Calculer endTime et afficher la différence (ttftMs)
}

runInferenceProfile();
export {};

💡 Astuce : Vous pouvez copier-coller ce prompt directement à Vibrisse (en bas à droite), ou à votre assistant IA habituel pour générer ce code :

Prompt d'ingénieur

"Tu es un Ingénieur IA. Écris le contenu de apps/backend/src/index.ts. Fais un appel API POST via fetch() natif sur http://127.0.0.1:11434/api/generate. Le body doit demander à gemma4:e4b de confirmer son statut en une courte phrase, sans streaming. Mesure le TTFT (Time To First Token) avec performance.now() et affiche une alerte si le temps dépasse 2000ms (risque de swap CPU)."

Et voici le code source attendu pour référence :

typescript

// apps/backend/src/index.ts
const ENGINE_URL = "http://127.0.0.1:11434/api/generate";

async function runInferenceProfile() {
  console.log("⏳ Initialisation du moteur cognitif...");
  
  const payload = {
    model: "gemma4:e4b",
    prompt: "Confirme tes systèmes en une phrase courte.",
    stream: false,
    temperature: 0.1
  };

  const startTime = performance.now();
  
  try {
    const response = await fetch(ENGINE_URL, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify(payload)
    });

    if (!response.ok) throw new Error(`HTTP Error: ${response.status}`);
    
    const data = await response.json();
    const endTime = performance.now();
    const ttftMs = (endTime - startTime).toFixed(0);
    
    console.log("✅ Réponse :", data.response.trim());
    console.log(`⏱️ Métriques : Inférence en ${ttftMs}ms`);
    
    if (parseInt(ttftMs) > 2000) {
      console.warn("⚠️ Attention : Latence élevée. Le modèle tourne probablement sur le CPU (RAM).");
    } else {
      console.log("⚡ Succès : L'accélération GPU/Metal est active.");
    }
    
  } catch (error) {
    console.error("🛑 Échec de connexion. Ollama est-il lancé ?", error);
  }
}

runInferenceProfile();
export {};

Pour exécuter ce code dans votre projet, lancez npx tsx apps/backend/src/index.ts depuis la racine de votre monorepo (ou via npm run dev si vous avez mappé cette commande dans le package.json de votre backend).

B. Pourquoi utiliser le Vercel AI SDK ?

Le Vercel AI SDK s’est imposé comme le standard de l’industrie pour créer des agents et applications IA en JavaScript/TypeScript, et ce pour plusieurs raisons :

Une API Unifiée (Agnosticisme) : Il permet de changer de modèle (passer de OpenAI à Anthropic, Groq ou Ollama) en changeant simplement une ligne de code, sans jamais réécrire votre logique métier.
Standardisation des Outils (Function Calling) : Historiquement, chaque LLM avait sa propre syntaxe pour appeler des fonctions. Le Vercel AI SDK unifie cela avec une syntaxe commune basée sur Zod, garantissant un typage strict de bout en bout.
Streaming & UI : Le SDK gère nativement le streaming des réponses (les fameux mots qui s’affichent un par un), ce qui est vital pour l’UX, tout en simplifiant drastiquement le code côté React/Frontend.

Pourquoi pas LangChain ou LlamaIndex ? Bien qu’il existe d’autres alternatives populaires comme LangChain JS/TS ou LlamaIndex (peut-être une side quest dédiée ? 👀), nous privilégions le Vercel AI SDK. LangChain souffre souvent d’une “sur-abstraction” (trop de magie cachée) qui rend le débogage complexe en production. LlamaIndex est excellent mais très spécialisé dans le RAG. Le Vercel AI SDK offre le parfait équilibre : une abstraction légère, agnostique, et un contrôle total (surtout pour l’interface utilisateur).

Bien que nous fassions notre tout premier ping “à la main” ci-dessus pour comprendre la mécanique HTTP, nous utiliserons le SDK pour tout le reste de l’architecture.

🔬 Analyse de l’Architecte : Décryptage & Pièges

Ce que vous venez d’observer : Le modèle gemma4:e4b pèse environ 9.6 GB et possède 4.5 milliards de paramètres effectifs (pour environ 8 milliards de paramètres totaux incluant les embeddings par couche). Sur une machine récente, le TTFT devrait être de l’ordre de 100 à 300ms. C’est l’essence même de l’Edge AI : une réflexion quasi instantanée.

Le Piège Mortel (Le Swap RAM) : Si votre script affiche un TTFT de plus de 2000ms, vous venez d’expérimenter le “Swap”. Votre VRAM (GPU) était pleine, donc le système d’exploitation a déversé les poids du modèle dans la RAM classique (CPU). Le calcul matriciel s’effondre. Un agent autonome qui swap est un agent mort-né.

La Température (Le Paramètre Crucial) : Dans le script, nous avons fixé la temperature: 0.1. Ce paramètre (généralement entre 0 et 1) contrôle la créativité du modèle. Pour écrire un poème, on la mettra à 0.9. Mais pour un Agent IA qui doit accomplir des tâches prévisibles (comme lire une base de données), on vise toujours une température très basse (0.1 ou 0) pour éviter qu’il n’hallucine de fausses données.

Le secret des pros : Ne croyez pas aveuglément votre code. Pendant que votre script tourne, ouvrez un autre terminal et tapez ollama ps. Vous verrez en temps réel exactement quelle quantité de mémoire votre modèle a verrouillé, et s’il utilise bien à 100% l’accélération GPU.

Retour au Dashboard

Infrastructure & Hardware Aware Inference

🎧Inférence & Hardware

1. La VRAM : Le Goulot d’étranglement

Règle de Dimensionnement

2. La Quantisation (Optimiser le Silicium)

3. Architecture d’Exécution : Vue d’Ensemble

Le Comparatif des Moteurs d’Inférence

Prérequis : Installation d'Ollama

4. Travaux Pratiques : Initialisation de Nexus

A. Mission : Profiler l’Inférence Locale (TTFT)

Étape intermédiaire : Le Ping de la machine

Quête Principale : Profiler l'Inférence Locale (TTFT)

B. Pourquoi utiliser le Vercel AI SDK ?

🔬 Analyse de l’Architecte : Décryptage & Pièges

📚 Ressources pour aller plus loin