Le guide complet de l'IA pour ingénieurs en 2026

TL;DR — Cet article condense le vocabulaire, les concepts et les techniques que tout ingénieur doit maîtriser pour intégrer l'IA en production sans illusion ni paralysie. On part de zéro, on monte jusqu'aux architectures d'agents, et on finit avec une roadmap concrète pour passer de curieux à expert. Pas de magie, pas de hype, juste ce qui marche.

Une anecdote, pour commencer

La première fois que j'ai branché une API LLM dans une application Rails, j'avais ce sentiment étrange d'avoir triché. Trois lignes de code, un appel HTTP, une réponse en langage naturel à peu près convaincante — et voilà, mon application "comprenait" du texte. J'ai mis l'écran en plein écran et je suis allé chercher un café.

Le café terminé, j'ai relu la réponse. Elle était fausse. Pas grossièrement fausse — subtilement fausse, juste assez pour passer une revue de code rapide, juste assez pour finir en production, juste assez pour faire dérailler un compte client une semaine plus tard.

Cette anecdote, c'est l'histoire de tous les ingénieurs qui découvrent l'IA générative en 2026 : la prouesse est immédiate, la maîtrise prend des années. Ce guide est ma tentative de compresser ces années en une lecture longue. Je l'écris pour l'ingénieur qui sait coder, qui n'a pas peur des concepts techniques, et qui veut arrêter d'utiliser les LLMs comme une boîte noire pour commencer à les utiliser comme un outil d'ingénieur — avec ses garanties, ses limites, et ses coûts.

On va couvrir un panorama large : machine learning classique, deep learning, LLMs et IA générative, vision, audio, agents, MLOps, sécurité, métier. Le but n'est pas de tout maîtriser à la fin de la lecture — c'est impossible — mais d'avoir la carte. Avec la carte, on sait où creuser ensuite.

Cheat sheet de cette intro — L'IA n'est pas magique, elle est statistique. Elle ne comprend rien, elle prédit. Sa mise en place demande de la rigueur d'ingénieur, pas de la confiance aveugle.

1. L'IA en perspective : de Turing aux transformers

1.1. Les trois grands courants

L'IA n'a pas commencé avec ChatGPT. Elle est traversée depuis les années 1950 par trois courants qui s'affrontent et se complètent.

Le courant symbolique (ou GOFAI, Good Old-Fashioned AI) postule que l'intelligence émerge de la manipulation de symboles selon des règles logiques. C'est l'IA des systèmes experts des années 1980 : on encode la connaissance d'un médecin dans des règles "si symptôme X alors maladie Y", et la machine raisonne. Ça marche pour des domaines fermés, ça échoue dès que le monde devient fuzzy.

Le courant connexionniste s'inspire du cerveau : des unités simples (neurones artificiels) connectées en réseau apprennent à partir d'exemples. Frank Rosenblatt invente le perceptron en 1958. L'idée stagne pendant des décennies (deux "hivers de l'IA"), faute de puissance de calcul et de données. Elle explose en 2012 avec AlexNet sur ImageNet : un réseau de neurones convolutif bat tous les concurrents en vision par ordinateur. Le deep learning est lancé.

Le courant statistique vient des mathématiques appliquées : régression, modèles bayésiens, SVM. Il a longtemps dominé le ML "industriel" avant l'ascension des réseaux profonds, et reste extrêmement utile aujourd'hui pour les problèmes structurés.

1.2. Frise chronologique courte

• 1950 : Alan Turing pose la question "Can machines think?" et propose son test.
• 1956 : conférence de Dartmouth, naissance officielle du terme Artificial Intelligence.
• 1958 : perceptron de Rosenblatt.
• 1986 : rétropropagation popularisée par Rumelhart, Hinton, Williams.
• 1997 : Deep Blue bat Kasparov aux échecs.
• 2012 : AlexNet (Krizhevsky, Sutskever, Hinton) écrase ImageNet.
• 2014 : GANs (Goodfellow) — l'IA peut générer des images crédibles.
• 2017 : Attention is All You Need — l'architecture Transformer naît.
• 2018 : BERT (Google) et GPT-1 (OpenAI) inaugurent les grands modèles de langage.
• 2020 : GPT-3, 175 milliards de paramètres, capacités émergentes en few-shot.
• 2022 : ChatGPT, l'IA devient grand public.
• 2023 : explosion des LLMs open source (Llama, Mistral), du RAG, des agents.
• 2024-2025 : reasoning models (o1, R1), agents fiables, IA multimodale en production.

Vocabulaire — Hiver de l'IA : période de désinvestissement et de désenchantement (1974-80, 1987-93). On en a connu deux. On en connaîtra peut-être un troisième.

1.3. Pourquoi maintenant ?

Trois courbes ont convergé : données (internet a produit un corpus textuel massif), calcul (GPUs Nvidia, TPUs Google, quelques ordres de grandeur de plus tous les cinq ans) et algorithmes (le Transformer permet de scaler). Sans ces trois, pas de GPT. Le retenir, c'est comprendre que l'IA actuelle n'est pas une révolution conceptuelle isolée, mais une convergence d'infrastructure.

Red flag — Méfie-toi des récits "tout a changé en 2022 avec ChatGPT". Le travail de fond a quarante ans. Les "révolutions" sont surtout des paliers de scaling.

2. IA classique vs IA générative : la grande bascule

L'IA classique cherche à prédire : quel client va churner, quelle image contient un chat, quelle valeur va prendre une vente le mois prochain. L'IA générative cherche à produire : un résumé, un email, une image, une fonction Python. Les deux se complètent : un pipeline mature combine souvent des modèles classiques rapides en première ligne et un LLM pour les cas complexes.

Mythe vs réalité — Mythe : "L'IA générative remplace l'IA classique." Réalité : les modèles classiques restent imbattables en coût, latence et explicabilité sur les problèmes structurés. Un LLM pour classifier 10 millions de tickets/jour, c'est une faute professionnelle.

3. Les paradigmes d'apprentissage

3.1. Apprentissage supervisé

On donne au modèle des paires (entrée, étiquette) et il apprend à prédire l'étiquette. C'est le paradigme dominant de l'IA "industrielle" : classification (spam/non-spam), régression (prix d'un appartement), détection (objet dans une image).

from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
model = GradientBoostingClassifier().fit(X_train, y_train)
print("Accuracy:", model.score(X_test, y_test))

Le piège : il faut des labels. Annoter coûte cher. Et les datasets biaisés produisent des modèles biaisés.

3.2. Apprentissage non supervisé

Pas d'étiquette. Le modèle découvre des structures dans les données. Clustering (k-means, DBSCAN), réduction de dimension (PCA, t-SNE, UMAP), détection d'anomalies, modèles génératifs. Utile quand on n'a pas de labels — donc presque tout le temps en réalité.

3.3. Apprentissage auto-supervisé (self-supervised)

C'est le secret des LLMs. On crée des labels artificiels à partir des données elles-mêmes. Pour un modèle de langage : on cache un mot dans une phrase et on demande au modèle de le prédire. Aucune annotation humaine, et pourtant le modèle apprend une représentation profonde du langage. Le pré-entraînement de GPT, BERT, Llama repose sur ce principe.

3.4. Apprentissage par renforcement (RL)

Un agent agit dans un environnement, reçoit des récompenses, et apprend à maximiser sa récompense cumulée. Historiquement utilisé pour les jeux (AlphaGo) et la robotique. En 2026, c'est surtout connu pour le RLHF (Reinforcement Learning from Human Feedback), qui aligne les LLMs sur les préférences humaines : on présente deux réponses possibles à un humain, il choisit la meilleure, et on entraîne le modèle à produire les réponses préférées.

Variante populaire : DPO (Direct Preference Optimization), plus simple à mettre en place que RLHF, sans modèle de récompense séparé.

3.5. Transfer learning et few-shot

Le transfer learning consiste à prendre un modèle pré-entraîné sur une tâche générale et l'adapter à une tâche spécifique. C'est la norme aujourd'hui : on ne part jamais de zéro.

Le few-shot learning (et son cousin zero-shot) est une capacité émergente des LLMs : on leur montre 0 à quelques exemples dans le prompt, et ils généralisent. C'est ce qui rend les LLMs si flexibles : pas besoin de fine-tuner pour beaucoup de cas.

prompt = """Classifie le sentiment.
- "J'adore ce produit." -> positif
- "Service catastrophique." -> négatif
- "Livraison rapide, emballage abîmé." ->"""

Cheat sheet section 3 — Supervisé = apprendre des labels. Non supervisé = trouver des structures. Self-supervised = labels créés depuis les données. RL = apprendre par récompenses. Few-shot = apprendre depuis quelques exemples dans le prompt.

4. Données et datasets : le carburant de l'IA

4.1. Pipelines de données

Une vérité que les médias oublient : 80% du travail d'un projet ML, c'est de la donnée. Collecte, nettoyage, déduplication, normalisation, labellisation, split train/val/test. Les outils typiques côté Python : pandas, polars, dask, Apache Beam, dbt côté warehouse.

Le split train/validation/test est sacré. Le test set ne doit jamais être touché pendant le développement, sous peine de data leakage (fuite d'information du test vers le train) et de surévaluer son modèle.

4.2. Feature engineering

Transformer les données brutes en features exploitables : encoding des catégorielles (one-hot, target encoding), scaling (standardisation, min-max), création de variables dérivées, embeddings comme features. Bien fait, le feature engineering bat souvent un modèle plus complexe.

4.3. Versioning et qualité

Les modèles changent, les données changent. Sans versioning des datasets, impossible de reproduire une expérience. Outils : DVC, LakeFS, Delta Lake. La qualité se mesure avec des tests (Great Expectations, Soda) et se monitore avec la détection de drift (la distribution des données en production change-t-elle ?).

4.4. Datasets de référence

Quelques datasets que l'expert doit connaître :

• ImageNet (vision) : 14 millions d'images, 20 000 catégories. La référence depuis 2009.
• CIFAR-10/100 : petits jeux d'images pour prototyper.
• MNIST : chiffres manuscrits, le "Hello World" du deep learning.
• GLUE / SuperGLUE : NLP, tâches de compréhension du langage.
• SQuAD : question-answering.
• Common Crawl : corpus web massif, base d'entraînement de la plupart des LLMs.
• The Pile, RedPajama, FineWeb : versions filtrées et structurées de Common Crawl.
• MMLU, GPQA, BBH, HumanEval, SWE-bench, ARC-AGI : benchmarks d'évaluation des LLMs (on y reviendra).

Red flag — Si tu télécharges un dataset public sans regarder ses licences, sa provenance et sa contamination potentielle avec les benchmarks, tu construis sur du sable.

5. Le cycle de vie d'un modèle : entraînement → inférence

Un modèle vit deux phases distinctes, qui demandent des compétences différentes.

L'entraînement consiste à ajuster les paramètres du modèle pour minimiser une fonction de coût sur un dataset. Cela se fait par descente de gradient (et ses variantes : SGD, Adam, AdamW), itérativement, sur des batchs de données. Pour un LLM moderne, l'entraînement complet (pre-training) coûte des millions à des milliards d'euros, dure des semaines, et nécessite des milliers de GPUs. C'est le travail des grands labos (OpenAI, Anthropic, Google, Meta, Mistral, DeepSeek).

L'inférence consiste à utiliser le modèle entraîné pour produire une prédiction sur de nouvelles entrées. C'est cette phase que tu vas voir 99% du temps en tant qu'ingénieur d'application. L'inférence est moins gourmande que l'entraînement, mais ses contraintes (latence, débit, coût par requête) sont au cœur de la mise en production.

Entre les deux, le fine-tuning : on prend un modèle pré-entraîné et on l'ajuste sur un dataset plus petit et spécifique. C'est moins cher que l'entraînement complet, et c'est la voie privilégiée pour spécialiser un modèle.

Vocabulaire — Pré-entraînement : phase initiale, sur un corpus massif et générique. Fine-tuning : phase d'adaptation, sur un corpus spécifique et plus petit. Alignment : phase post fine-tuning où on aligne le modèle sur des préférences humaines (RLHF, DPO).

6. Hardware et inférence

6.1. GPUs, TPUs, NPUs

L'IA moderne tourne sur des accélérateurs matériels. Les GPUs Nvidia (A100, H100, B200) dominent l'entraînement et l'inférence cloud. Les TPUs de Google équipent ses datacenters. Les NPUs (Apple Neural Engine, Qualcomm Hexagon) gèrent l'inférence on-device.

Ce qu'il faut retenir : la mémoire (VRAM) est le goulot d'étranglement principal. Un modèle 70B en FP16 demande ~140 GB de VRAM rien que pour les poids. D'où l'importance de la quantization (section suivante).

6.2. Frameworks et runtimes d'inférence

• vLLM : serveur d'inférence open source haute performance pour LLMs (PagedAttention, continuous batching).
• TGI (Text Generation Inference, HuggingFace) : alternative robuste.
• llama.cpp : inférence CPU/GPU avec quantization GGUF, parfait pour le on-device.
• Ollama : surcouche conviviale à llama.cpp, idéale pour développer en local.
• SGLang : framework récent, optimisé pour le throughput.

6.3. Latence et débit

Deux métriques cruciales : time-to-first-token (TTFT) et tokens par seconde (TPS). Le TTFT compte pour l'UX (perception de réactivité), le TPS pour le coût et la capacité à servir du throughput.

Red flag — Si tu déploies un LLM sans connaître ton TTFT et ton TPS sur ton hardware, tu n'as pas de système, tu as une démo.

7. Quantization et optimisation des modèles

La quantization consiste à réduire la précision des poids du modèle : passer de FP32 (32 bits) à FP16, INT8, INT4, voire INT2. Un modèle 7B passe de ~14 GB (FP16) à ~4 GB (INT4), avec une perte de qualité souvent négligeable.

Techniques courantes :

• GPTQ : quantization post-entraînement basée sur l'optimisation des erreurs.
• AWQ (Activation-aware Weight Quantization) : prend en compte les activations.
• GGUF : format de fichier pour llama.cpp, supporte plusieurs niveaux de quantization.
• bitsandbytes : bibliothèque de référence en Python pour la quantization à la volée.

Autres techniques d'optimisation : distillation (transférer les connaissances d'un gros modèle vers un petit), pruning (élaguer les poids non utiles), mixture of experts (n'activer qu'une fraction des paramètres par token).

from transformers import AutoModelForCausalLM, BitsAndBytesConfig
quant_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype="float16")
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3-8B", quantization_config=quant_config)

Mythe vs réalité — Mythe : "La quantization dégrade toujours les performances." Réalité : INT8 est presque transparent, INT4 perd 1 à 5% selon les benchmarks, et certains modèles s'en sortent étonnamment bien en INT2. Il faut tester sur sa tâche.

8. Caching : KV cache, prompt cache, semantic cache

Le caching est l'arme la plus sous-utilisée pour réduire les coûts et la latence en LLM.

Le KV cache (Key-Value cache) est un mécanisme interne au Transformer : pendant la génération token par token, on cache les clés et valeurs des couches d'attention pour éviter de recalculer le passé à chaque étape. Sans KV cache, l'inférence est quadratique en longueur ; avec, elle redevient quasi-linéaire.

Le prompt caching (proposé par Anthropic, OpenAI, Google) cache des parties communes de prompt entre requêtes. Si tu envoies systématiquement le même system prompt de 5000 tokens, le facturer une seule fois (et l'inférer plus vite) change l'économie de ton produit. Réductions typiques : 50 à 90% sur la portion cachée.

Le semantic caching est applicatif : on stocke (question, réponse) et on retourne la réponse cachée si une nouvelle question est sémantiquement proche. Outils : GPTCache, Redis Vector. Attention au piège : deux questions sémantiquement proches peuvent appeler des réponses différentes selon le contexte utilisateur.

Cheat sheet section 8 — KV cache = optimisation interne du modèle. Prompt cache = optimisation côté API provider. Semantic cache = optimisation côté application.

9. Streaming et patterns asynchrones

Les LLMs génèrent token par token. Attendre la réponse complète avant d'afficher détruit l'UX. Le streaming est devenu la norme.

Mécanismes :

• Server-Sent Events (SSE) : le serveur pousse les tokens au client via une connexion HTTP longue. Simple, supporté nativement par tous les SDKs.
• WebSockets : bidirectionnel, utile pour les conversations interactives ou multi-modal.
• gRPC streaming : pour les architectures inter-services performantes.

Côté backend, traiter des LLMs en async est crucial : les appels durent des secondes, bloquer un thread sync sature ton serveur. Python : asyncio + httpx. Ruby/Rails : async-http, Sidekiq pour les jobs longs, ActionCable pour pousser au client.

from openai import AsyncOpenAI
client = AsyncOpenAI()
async for chunk in await client.chat.completions.create(
    model="gpt-4", messages=[...], stream=True):
    print(chunk.choices[0].delta.content, end="", flush=True)

10. Le NLP avant les transformers (survol historique)

Avant 2017, le NLP était un patchwork de techniques :

• Tokenization par espaces ou règles (NLTK, spaCy).
• Bag-of-words, TF-IDF : représentation des documents par fréquence de mots.
• Word embeddings : Word2Vec (Mikolov, 2013), GloVe — chaque mot devient un vecteur dense.
• RNN et LSTM : modèles séquentiels qui traitaient les phrases mot après mot.
• NER (Named Entity Recognition), POS tagging, parsing syntaxique : tâches structurées.

Beaucoup de ces techniques restent utiles : un BM25 + TF-IDF reste imbattable pour certaines recherches. Mais l'effet "transformer" a été tel qu'on a tendance à l'oublier.

Vocabulaire — Word embedding : vecteur dense représentant un mot dans un espace sémantique (ex. 300 dimensions). Les mots proches sémantiquement sont proches géométriquement.

11. Tokens et tokenization

11.1. Qu'est-ce qu'un token ?

Un token est l'unité atomique manipulée par un LLM. Ce n'est pas un mot, ni un caractère : c'est une sous-unité, généralement de 3 à 5 caractères en anglais. Le mot "tokenization" peut être découpé en ["token", "ization"] ou ["tok", "en", "iz", "ation"] selon le tokenizer.

11.2. Algorithmes de tokenization

• BPE (Byte-Pair Encoding) : algorithme dominant. On part des caractères et on fusionne itérativement les paires les plus fréquentes. Utilisé par GPT, Llama, Mistral.
• WordPiece : variante de BPE utilisée par BERT.
• SentencePiece : agnostique à la langue, utile pour les langues sans espaces (japonais, chinois). Utilisé par T5, mBART.
• tiktoken : la bibliothèque officielle d'OpenAI pour leurs tokenizers.

import tiktoken
enc = tiktoken.encoding_for_model("gpt-4")
print(enc.encode("Bonjour le monde"))

11.3. Pourquoi ça compte

Les coûts des LLMs sont en tokens, pas en mots. Le français utilise typiquement 1.3x plus de tokens que l'anglais pour le même contenu, le japonais peut atteindre 2x. Compter ses tokens est un réflexe d'expert.

La fenêtre de contexte se mesure en tokens. "200k tokens" chez Anthropic, "1M tokens" chez Gemini, c'est ce qui rentre dans le prompt + la réponse.

Cet article est un panorama complet

Cette publication couvre l'introduction et les fondations (histoire, paradigmes, données, cycle de vie, hardware, quantization, caching, streaming, NLP, tokens). La suite — embeddings, architectures (Transformer, CNN, RNN, diffusion, MoE, SSM), LLMs détaillés, multimodal, prompt engineering avancé, hallucinations, reasoning, context engineering, RAG complet, fine-tuning, agents IA, MLOps, sécurité, éthique, métier d'ingénieur IA, glossaire — couvre environ 13 000 mots supplémentaires répartis en 50 sections.

Le panorama complet est disponible en téléchargement (Markdown, PDF, DOCX). Demandez-le, je vous le partage.

Cyril — DaLMS

12. Embeddings : le pont entre langage et géométrie

Un embedding est un vecteur dense (384 à 3072 dimensions) qui représente une donnée dans un espace continu. La similarité sémantique se mesure par la distance géométrique. Outils : OpenAI text-embedding-3, Cohere embed-v4, sentence-transformers (bge, e5, jina). Métriques : cosine, dot, L2. Benchmark de référence : MTEB.

13. Architectures : Transformer, CNN, RNN, Diffusion

Le Transformer (Vaswani 2017) repose sur l'attention : chaque token regarde tous les autres et apprend à pondérer ce qui compte. Variantes : encoder-decoder (T5), decoder-only (GPT, Llama), encoder-only (BERT). Les CNN dominent encore en vision efficace (ResNet, ViT). Les RNN/LSTM survivent pour les signaux courts. Les modèles de diffusion (Stable Diffusion, Flux) génèrent images, vidéos, audio.

14. Architectures émergentes : MoE, Mamba, reasoning, SLMs

MoE (Mixtral, DeepSeek-V3) : sparse experts routés par token, capacité énorme à coût d'inférence réduit. SSM/Mamba : alternative linéaire au Transformer pour les longs contextes. Reasoning models (o1, R1, Claude extended thinking) : longue chaîne de raisonnement interne, gains massifs en math/code. SLMs (Phi-4-mini, Gemma 3, Qwen 2.5 3B) : 1-4B paramètres, parfaits pour l'edge, le on-device, et les tâches spécialisées.

15. Multimodal : VLMs, audio, vidéo

VLMs (GPT-4o, Claude 4, Gemini 2.5, Qwen2.5-VL) traitent images + texte. Audio : Whisper (ASR), Voxtral, Moshi (full-duplex), ElevenLabs/Cartesia (TTS), Suno/Udio (musique). Vidéo : Sora, Veo, Kling, Luma. 3D : NeRF, Gaussian Splatting.

16. LLMs en 2026 — panorama

Closed : GPT-5, Claude 4.6 Sonnet/Opus, Gemini 2.5 Pro/Flash. Open weights : Llama 3.3, DeepSeek-V3/R1, Mistral Large 2, Qwen 2.5/3. Le meilleur générique n'est pas toujours le meilleur pour ta tâche : évalue.

17. Context window, attention, RoPE

De 8k à 2M tokens selon les modèles. Attention quadratique → coûteuse pour les longs contextes. Solutions : Flash Attention, sliding window, sparse attention, RoPE, YaRN. Attention au piège lost in the middle. Plus de contexte ≠ mémoire infinie : mieux vaut un RAG bien fait qu'un dump de 500k tokens.

18. Prompt engineering avancé

CoT (« réfléchis étape par étape »), self-consistency, Tree-of-Thoughts, ReAct, Reflection, multi-agent debate. Structured output (JSON mode, function calling, constrained decoding via Outlines/Guidance). Auto-tuning : DSPy. Pydantic + Instructor en Python pour la génération typée.

19. Hallucinations : gestion en production

Causes : données absentes, cutoff, prompt ambigu, surconfiance RLHF. Mitigations : RAG ancré, citations vérifiables, LLM-as-judge, reasoning models, validation post-génération, datasets de questions piège. Sans stratégie d'évaluation des hallucinations, ton produit est un risque légal latent.

20. Reasoning et chain-of-thought

CoT : technique de prompting. Reasoning models : entraînement spécifique. Cas d'usage : math, code complexe, planification multi-étapes. Pas pour les tâches simples — coût et latence multipliés.

21. Context engineering

Discipline qui généralise le prompt engineering. Couvre system prompt, mémoire (court/long terme), retrieval, tool outputs, instructions dynamiques. La qualité du contexte pèse plus que la qualité du modèle : un GPT-5 mal contextualisé se fait battre par un Llama 70B bien contextualisé.

22. Semantic search & hybrid search

Dense (vector) : sens. Sparse (BM25, TF-IDF) : mots-clés. Hybrid (RRF, score weighting) : combinaison. Reranker (Cohere Rerank, bge-reranker, Jina) : précision finale.

23. RAG : Retrieval Augmented Generation

Pipeline : ingestion → chunking → embedding → indexation → retrieval (hybrid + rerank) → augmentation → generation. Vector DBs : pgvector (par défaut pour 90% des cas), Qdrant, Weaviate, Pinecone, Chroma, Milvus, Elasticsearch. Chunking : recursive, semantic, document-aware, late chunking. Anti-patterns RAG : 50 chunks brutaux dans le prompt, pas d'eval, pas de mise à jour, pas de contrôle d'accès.

24. Fine-tuning : vue d'ensemble

Pas par défaut. Justifié pour : format très spécifique non stabilisé en prompting, distillation, domaine très spécialisé, ton/style typé. Techniques : full FT, PEFT, LoRA, QLoRA, instruction tuning, RLHF/DPO/IPO. Outils : transformers + peft + trl, Axolotl, LLaMA-Factory, Unsloth.

25. Tool use & MCP

Function calling : déclarer des fonctions au modèle qui décide d'appeler. Patterns : parallel tool use, forced tool use, constrained decoding. MCP (Model Context Protocol, Anthropic 2024) : standard ouvert pour exposer outils, ressources et prompts. Sécurité : least privilege, sandboxing, validation, confirmation humaine sur actions à enjeu.

26. Agents IA : du concept à la production

Boucle Observer → Réfléchir → Agir → Observer. Patterns : ReAct, Plan-and-Execute, Reflection, Self-Refine, multi-agent. Mémoire : working, episodic, semantic, procedural (mem0, Letta). Production : observabilité, garde-fous (timeout, max_steps), evals end-to-end, sandboxing, coûts. Les agents sont efficaces sur tâches bien cadrées avec outils sûrs et humain dans la boucle.

27. Auto-évaluation et self-correction

LLM-as-judge, self-critique, Constitutional AI, Best-of-N. Limites : hérite des biais. Combiner LLM-judge + règles formelles + tests humains.

28. Computer Vision et Audio en prod

Vision : classification, détection (YOLO, DETR), segmentation (SAM), OCR (Tesseract, Mistral OCR), génération (Flux, SD). Audio : Whisper, Voxtral, ElevenLabs, Cartesia, pyannote. Pour gros volumes, des modèles spécialisés battent les VLMs/LLMs en coût et précision.

29. Patterns architecturaux : RAG, classification, extraction, agent

Chatbot RAG : permissions, fraîcheur, citations, fallback. Classification : prompt structuré + structured output, fallback rules, dérive. Extraction : Pydantic + Instructor, LangChain extraction. Agent autonome : multi-étapes, recherche, automation. Règle : commence par le pattern le plus simple qui résout.

30. IA + bases de données

pgvector (Postgres) couvre 90% des cas. Text-to-SQL avec validation AST + sandbox. Knowledge graphs (Neo4j) + embeddings : GraphRAG pour données fortement reliées.

31. IA et code

Génération : Claude 4.6, GPT-5, DeepSeek-Coder, Codestral. Refactoring : combiner LLM + outils déterministes (OpenRewrite, jscodeshift). Debug : très efficace sur bugs locaux/typage, moins sur perf/distribué.

Encart Ruby/Rails

Pour développer une app Rails : ruby-openai (gem mature), langchainrb, pgvector via neighbor, ActiveRecord + embeddings, jobs LLM via Sidekiq/GoodJob, streaming SSE via ActionController::Live ou Hotwire/Turbo Streams. Pour l'eval, héberge un service Python à part. MCP est en train de devenir l'option naturelle pour exposer des outils.

32. Coding agents : Copilot, Cursor, Claude Code

Auto-complétion (Copilot, Cursor Tab, Codeium), chat assistants (Cursor Composer), agents autonomes (Claude Code, Cursor Agents, Codex, Aider, Cline). Bonnes pratiques : CLAUDE.md/AGENT.md, tâches granulaires, relire diffs, tests robustes comme oracle.

33. Évaluation : métriques et benchmarks

Classique : accuracy, precision, recall, F1, AUC, MSE, MAE. NLP/LLM : BLEU, ROUGE, perplexity, BERTScore. Benchmarks : MMLU, GPQA, HumanEval, SWE-bench, MATH, AIME, ARC-AGI, MMMU. Les benchmarks publics sont contaminés et saturés. Toujours croiser avec evals privées.

34. Evals custom — le secret des produits IA solides

50 à 500 cas représentatifs, edge cases inclus, versionné, immuable. Frameworks : Promptfoo, Braintrust, LangSmith, Phoenix, Ragas, DeepEval. Méthodes : exact match, LLM-as-judge, heuristics, pairwise comparison, tests humains. Sans evals + CI, ton produit IA est piloté à l'aveugle.

35. Observabilité IA

LangFuse (open source, excellent), Helicone, Phoenix, LangSmith, Braintrust, Datadog LLM Observability. Tracer : prompt complet, réponse, tokens in/out, coûts, latence, ids, métadonnées métier, tools, erreurs. OpenTelemetry pousse une convention sémantique IA (gen_ai.*).

36. Debug & prompt management

Debug IA : Reproduce → Localize → Isolate → Compare → Fix and eval. Prompt management : versioning (Git, fichiers, services), templating (Jinja2, ERB, Liquid), A/B testing, déploiement contrôlé.

37. MLOps : versioning, CI/CD, monitoring, coûts

Versioning code (Git), data (DVC, LakeFS, Iceberg), modèles (MLflow, W&B), expériences. CI/CD : tests, intégration, evals frozen, canary/shadow/A-B. Monitoring : performance, drift, concept drift, opérationnel (Evidently, WhyLabs, Arize). Cost : cache, batching, routing, quantization, distillation.

38. Coûts : modèle économique des LLMs

Tokens input (1x), output (3-5x), cached input (0.1-0.5x), reasoning tokens (facturés comme output). Leviers : prompt caching (-50 à -90%), batching, modèles plus petits + RAG, distillation. Coûts cachés : embeddings, vector DB, logs, evals.

39. Build vs buy, open vs closed

API pour démarrer, self-hosted à fort volume constant. Open weights (Llama 4, DeepSeek V3, Qwen 3) rivalisent avec le frontier. Hybrid en pratique : closed pour critique/difficile, open pour volume répétitif.

40. Acteurs majeurs

Labos : OpenAI, Anthropic, Google DeepMind, Meta, xAI, Mistral, DeepSeek, Alibaba, Cohere. Infra : Nvidia, AMD, Intel, Hugging Face, Together, Replicate, Fireworks, Groq, Cerebras. Tooling : LangChain, LlamaIndex, DSPy, vLLM, Pinecone, LangFuse.

41. Frameworks Python

PyTorch domine. JAX monte en recherche perf. HuggingFace transformers + datasets + tokenizers + accelerate + peft + trl : à connaître par cœur.

42. Organisation, équipes, gouvernance

Rôles : Data Scientist, ML Engineer, AI Engineer, MLOps, Research, Data Engineer, PM AI. Topologies : centralisée, embarquée, plateforme + features (norme), centre d'excellence. Gouvernance : AI Act (UE), RGPD, ISO/IEC 42001, NIST AI RMF, sectoriels.

43. Privacy

Risques : PII dans prompts, fine-tuning sur données utilisateur, logs, inférence d'attributs. Mitigations : anonymisation (Presidio, Macie), differential privacy, federated learning, on-device, DPAs stricts, cloud souverain.

44. Sécurité IA

Prompt injection (séparer instructions/données, validation outputs), jailbreak, data leakage, adversarial attacks (extraction, poisoning, membership inference). Garde-fous : NeMo Guardrails, Guardrails AI, Llama Guard, Prompt Guard, Azure AI Content Safety, Bedrock Guardrails. En input ET output.

45. Limites des LLMs

Hallucinations, knowledge cutoff, arithmétique faible, biais de confirmation, lost in the middle, sensibilité au prompt, pas de mémoire native, reasoning fragile, multilingue inégal, pas d'auto-mise à jour.

46. Éthique de l'IA

Biais (effet structurel, à mesurer), travail invisible des annotateurs, transparence (citations, CoT, mais pas explainability fort), concentration des modèles de fondation, impact sociétal. Ce n'est pas une checklist mais une posture.

47. Critique des benchmarks

Contamination, saturation, gaming, distribution shift, effet Goodhart. Solutions : benchmarks privés, évaluations dynamiques, test sets temporels, evals humains.

48. AGI et hype

AGI : terme polysémique. Scaling laws : prédictives sur certains intervals, plateaux possibles. La position d'expert : reconnaître les progrès massifs sans céder à la téléologie inevitable. Lectures : MIRI, Anthropic safety, AI Safety.

49. IA décentralisée, edge, federated

Federated learning (Flower, TFF, PySyft), edge AI (Apple Foundation Models, ONNX Runtime, llama.cpp, Core ML), privacy-preserving (DP, homomorphic encryption, secure MPC). Critique en santé, finance, défense.

50. IA et environnement

Empreinte carbone (GPT-3 ~552t CO2eq), eau (datacenter cooling), optimisations (quantization, distillation, SLMs, hardware efficient). Ce que peut faire l'ingénieur : mesurer (CodeCarbon, ML CO2 Impact), éviter le surdimensionnement, cacher, batch, ne pas re-entraîner par habitude.

51. Collaboration humain-IA

Human-in-the-loop, workflows hybrides (IA propose, humain valide), UX IA (streaming, citations cliquables, retry, feedback inline), confiance et calibration (exposer l'incertitude, alternatives).

52. Avant / après IA — 5 cas concrets

Support client (routing auto + RAG + suggestions). Recherche dans le codebase (sémantique + génération de tests). Onboarding documentaire (chatbot RAG sur le wiki). Automatisation interne (agents + MCP). Veille concurrentielle (agents qui scrapent + résument + alertent).

53. Anti-patterns courants

RAG bricolé, agent géant, prompt monstre, fine-tuning prématuré, évaluation absente, métrique unique, system prompt secret, confiance aveugle dans les outputs, lock-in invisible, "ça suffira" qui ne sera jamais polish.

54. Comment lire un papier IA

Abstract et conclusion d'abord. Figures. Méthode si l'idée intéresse. Baselines (sont-elles fortes ?). Limitations (souvent la partie la plus honnête). Veille : arXiv (cs.LG, cs.CL, cs.AI, cs.CV), Papers with Code, HuggingFace Papers, newsletters (The Batch, Import AI, AlphaSignal, Sebastian Raschka).

55. Veille et apprentissage continu

Newsletters : The Batch, Import AI, Latent Space, Simon Willison, Lilian Weng. Cours : Karpathy "Zero to Hero", HuggingFace, fast.ai, DeepLearning.ai, Stanford CS231n/224N/336. Communauté : GitHub, Twitter (Karpathy, Raschka, tri_dao), Discord HF/LangChain. La veille active = un projet personnel qui force à lire ce qui sert.

56. L'IA dans 5 ans — prospective

Modèles plus petits et efficaces. Reasoning généralisé. Multimodal natif. Agents fiables. MCP universel. On-device puissant. Coûts en chute. Régulation effective. Tension géopolitique. Outillage stabilisé. Incertain : AGI vs plateau, oligopole vs commodity, impact emploi.

57. Le métier d'ingénieur IA

Selon ton profil : backend → AI engineer rapide ; data scientist → industrialisation ; data engineer → atout ; frontend → UX IA ; manager → coûts/evals/risques. Compétences : Python, PyTorch, prompt eng, RAG, eval, observabilité, MLOps. Au moins une fois : entraîner un modèle, manipuler embeddings, construire un agent, déployer une API LLM, mesurer la qualité.

58. Soft skills

Communication, pensée produit, esprit critique, collaboration, apprentissage continu. Ces skills ne sont pas softs : elles sont la moitié de la séniorité dans un domaine instable.

59. Roadmap pour devenir expert

Mois 1-3 : fondations (Karpathy, transformers, premier projet, papiers fondateurs). Mois 3-6 : LLMs et applications (chatbot RAG complet avec eval, prompt engineering avancé, observabilité). Mois 6-12 : production (déploiement réel, MLOps, sécurité, agent avec tool use, modèles open source self-hosted). An 1-2 : profondeur (spécialisation, fine-tuning hands-on, mentorat, écrits, conf, valeur produit). An 2+ : expertise (arbitrage architecture IA, influence stratégique, contributions reconnues, pédagogie).

60. Glossaire combiné

Acronymes : AGI, API, ASR, AUC, BPE, CNN, CoT, DPO, GAN, GPU, HITL, LLM, LoRA, LSTM, MCP, ML, MLOps, MoE, NER, NLP, PEFT, PII, PCA, RAG, RLHF, RNN, SaaS, SGD, SLM, SSM, SVM, TPS, TPU, TTFT, TTS, VLM.

Concepts clés : Agent, Alignment, Attention, Backpropagation, Chunking, Context window, Cosine similarity, Data drift, Data leakage, Differential privacy, Distillation, Embedding, Few-shot/Zero-shot, Fine-tuning, Foundation model, Gradient descent, Guardrails, Hallucination, Hybrid search, In-context learning, Jailbreak, KV cache, MoE, Multimodal, Pre-training, Prompt engineering, Prompt injection, Quantization, RAG, ReAct, Reranker, Retrieval, RLHF, Sampling, Self-supervised, Streaming, System prompt, Temperature, Tokenization, Tool use, Transfer learning, Transformer, Vector database.

Conclusion : la posture d'apprenant permanent

Cet article fait plus de 15 000 mots dans sa version intégrale (Markdown/PDF disponibles en téléchargement). Aucun ingénieur lecteur n'aura tout retenu. Ce n'est pas le but. Le but est de donner une carte — assez précise pour s'orienter, assez incomplète pour donner envie d'explorer.

Devenir expert en IA en 2026, c'est avant tout accepter une tension : ce que tu apprends aujourd'hui sera partiellement faux demain. Les fondations de ML, les principes du Transformer, les patterns d'ingénierie système restent. Mais les SOTA, les benchmarks, les modèles dominants, les frameworks de référence : tout cela bougera. La posture qui survit, c'est celle de l'apprenant permanent — curieux, sceptique, méthodique.

Il y a quelque chose de profondément humain dans ce qu'on traverse. On bâtit des outils statistiques qui imitent une fraction des capacités cognitives humaines. On les déploie à l'échelle. On en mesure les bénéfices, les biais, les coûts. On débat de leur place. Le métier d'ingénieur IA, ce n'est pas juste pousser des modèles en prod — c'est négocier en continu avec des outils qui transforment notre rapport à la connaissance, au travail, et à la vérité.

Garde la tête froide. Mesure. Doute. Apprends. Et reste un ingénieur — quelqu'un qui prend une réalité incertaine et la rend fiable, modeste, utile. C'est suffisant. Et c'est rare.

— Cyril, DaLMS

12. Embeddings : pont entre langage et géométrie

Un embedding est un vecteur dense (384 à 3072 dim) représentant une donnée dans un espace continu. Similarité sémantique = distance géométrique. Outils : OpenAI text-embedding-3, Cohere, sentence-transformers (bge, e5, jina). Métriques : cosine, dot, L2. Benchmark : MTEB.

13. Architectures : Transformer, CNN, RNN, Diffusion

Le Transformer (Vaswani 2017) repose sur l'attention : chaque token regarde tous les autres et apprend à pondérer. Variantes : encoder-decoder (T5), decoder-only (GPT, Llama), encoder-only (BERT). CNN : vision efficace (ResNet, ViT). RNN/LSTM : signaux courts. Diffusion (Stable Diffusion, Flux) : images, vidéos, audio.

14. Architectures émergentes : MoE, Mamba, reasoning, SLMs

MoE (Mixtral, DeepSeek-V3) : sparse experts routés par token. SSM/Mamba : alternative linéaire pour longs contextes. Reasoning models (o1, R1, Claude extended thinking) : longue chaîne de raisonnement interne. SLMs (Phi-4-mini, Gemma 3, Qwen 2.5 3B) : 1-4B paramètres, edge, on-device.

15. Multimodal

VLMs : GPT-4o, Claude 4, Gemini 2.5, Qwen2.5-VL. Audio : Whisper, Voxtral, Moshi, ElevenLabs, Cartesia, Suno. Vidéo : Sora, Veo, Kling, Luma. 3D : NeRF, Gaussian Splatting.

16. LLMs en 2026 — panorama

Closed : GPT-5, Claude 4.6 Sonnet/Opus, Gemini 2.5 Pro/Flash. Open weights : Llama 3.3, DeepSeek-V3/R1, Mistral Large 2, Qwen 2.5/3.

17. Context window, attention, RoPE

De 8k à 2M tokens. Solutions : Flash Attention, sliding window, sparse attention, RoPE, YaRN. Piège : lost in the middle. Plus de contexte ≠ mémoire infinie.

18. Prompt engineering avancé

CoT, self-consistency, ToT, ReAct, Reflection, multi-agent debate. Structured output (JSON mode, function calling, constrained decoding). Auto-tuning : DSPy. Pydantic + Instructor.

19. Hallucinations

Mitigations : RAG ancré, citations vérifiables, LLM-as-judge, reasoning models, validation post-génération. Sans stratégie d'évaluation, risque légal latent.

20. Reasoning et CoT

CoT : prompting. Reasoning models : entraînement spécifique. Pour math, code complexe, planification. Pas pour tâches simples.

21. Context engineering

Discipline qui généralise le prompt engineering : system prompt, mémoire, retrieval, tool outputs. Qualité du contexte > qualité du modèle.

22-23. Semantic search & RAG

Hybrid (dense + sparse) + reranker. RAG : ingestion → chunking → embedding → indexation → retrieval → augmentation → generation. Vector DB : pgvector pour 90% des cas. Anti-pattern : pas d'eval, pas de mise à jour.

24-26. Fine-tuning, tool use, agents

Fine-tuning : LoRA/QLoRA via peft + trl, Axolotl, Unsloth. Pas par défaut. Tool use : function calling + MCP (Model Context Protocol). Agents : ReAct, Plan-and-Execute, Reflection. Production = observabilité + garde-fous + evals end-to-end + sandboxing.

27-31. Vision, audio, patterns archi, IA + DB, IA + code

Vision : YOLO, DETR, SAM, Tesseract, Mistral OCR, Flux. Audio : Whisper, ElevenLabs. Patterns : chatbot RAG, classification, extraction structurée, agent autonome. IA+DB : pgvector, Text-to-SQL, GraphRAG. IA+code : Claude 4.6, GPT-5, DeepSeek-Coder, Codestral.

Encart Ruby/Rails

ruby-openai, langchainrb, pgvector via neighbor, Sidekiq pour jobs LLM, ActionController::Live ou Hotwire pour streaming SSE. MCP devient l'option naturelle pour exposer des outils.

32. Coding agents

Auto-complétion (Copilot, Cursor Tab), chat assistants (Cursor Composer), agents autonomes (Claude Code, Cursor Agents, Codex, Aider). Bonnes pratiques : CLAUDE.md/AGENT.md, tâches granulaires, relire diffs, tests robustes.

33-35. Évaluation, evals custom, observabilité

Métriques classiques + benchmarks LLM (MMLU, GPQA, HumanEval, SWE-bench, ARC-AGI). Benchmarks publics contaminés. Evals custom : 50-500 cas, Promptfoo, Braintrust, LangSmith, Phoenix, Ragas. Observabilité : LangFuse, Helicone, Phoenix, OpenTelemetry gen_ai.

36-38. Debug, prompt management, MLOps, coûts

Debug : Reproduce → Localize → Isolate → Compare → Fix and eval. Prompt management : versioning, A/B, déploiement contrôlé. MLOps : MLflow, DVC, CI/CD ML, monitoring drift. Coûts : input 1x, output 3-5x, cached input 0.1-0.5x. Leviers : prompt caching, batching, modèles plus petits.

39-42. Build vs buy, open vs closed, acteurs, frameworks, équipes

API pour démarrer, self-hosted à fort volume. Open weights rivalisent avec frontier. Acteurs : OpenAI, Anthropic, Google, Meta, xAI, Mistral, DeepSeek, Alibaba. Frameworks : PyTorch + HuggingFace + transformers. Topologies : plateforme + features (norme).

43-46. Privacy, sécurité, limites, éthique

Privacy : anonymisation (Presidio), DP, federated learning, on-device, DPAs stricts. Sécurité : prompt injection, jailbreak, data leakage, adversarial. Garde-fous : NeMo Guardrails, Llama Guard. Limites : hallucinations, cutoff, arithmétique faible, lost in the middle. Éthique : biais, travail invisible, transparence, concentration.

47-50. Benchmarks, AGI, edge, environnement

Benchmarks : contamination, saturation, gaming, Goodhart. AGI : terme polysémique, scaling laws partielles. Federated learning, edge AI, privacy-preserving ML. Environnement : empreinte carbone, eau, optimisations, mesure (CodeCarbon).

51-56. Collaboration, cas d'usage, anti-patterns, lire papier, veille, prospective

Human-in-the-loop, UX IA. Cas : support, code search, onboarding, automation, veille. Anti-patterns : RAG bricolé, agent géant, fine-tuning prématuré, pas d'eval. Lire papier : abstract+conclusion+figures+limitations. Veille : The Batch, Karpathy, fast.ai, Discord HF. 2030 : modèles plus petits, reasoning généralisé, multimodal natif, agents fiables, MCP universel.

57-59. Métier, soft skills, roadmap

Profils : Data Scientist, ML/AI Engineer, MLOps, PM AI. Compétences : Python, PyTorch, prompt eng, RAG, eval, observabilité. Roadmap : mois 1-3 fondations ; 3-6 LLMs et apps ; 6-12 production ; an 1-2 profondeur ; an 2+ expertise.

60. Glossaire

Acronymes : AGI, ASR, AUC, BPE, CNN, CoT, DPO, GAN, GPU, HITL, LLM, LoRA, LSTM, MCP, ML, MLOps, MoE, NER, NLP, PEFT, PII, PCA, RAG, RLHF, RNN, SLM, SSM, SVM, TPS, TPU, TTFT, TTS, VLM. Termes clés : Agent, Alignment, Attention, Chunking, Context window, Data drift, Differential privacy, Distillation, Embedding, Few-shot, Fine-tuning, Foundation model, Guardrails, Hallucination, Hybrid search, In-context learning, Jailbreak, KV cache, Multimodal, Pre-training, Prompt injection, Quantization, ReAct, Reranker, RLHF, Self-supervised, Streaming, System prompt, Tokenization, Tool use, Transfer learning, Transformer, Vector database.

Conclusion : la posture d'apprenant permanent

Cet article fait plus de 15 000 mots dans sa version intégrale (Markdown / PDF disponibles en téléchargement, demandez-les). Aucun ingénieur lecteur n'aura tout retenu — ce n'est pas le but. Le but est de donner une carte. Avec la carte, on sait où creuser.

Devenir expert en IA en 2026, c'est accepter une tension : ce qu'on apprend aujourd'hui sera partiellement faux demain. Les fondations de ML, les principes du Transformer, les patterns d'ingénierie système restent. Mais les SOTA, les benchmarks, les modèles dominants : tout cela bougera. La posture qui survit, c'est celle de l'apprenant permanent — curieux, sceptique, méthodique.

Garde la tête froide. Mesure. Doute. Apprends. Et reste un ingénieur — quelqu'un qui prend une réalité incertaine et la rend fiable, modeste, utile. C'est suffisant. Et c'est rare.

— Cyril, DaLMS