🧠 Intelligence Artificielle — concepts, histoire, familles, GenAI/LLM, MLOps & risques
IA = ensemble de méthodes permettant à une machine d’apprendre des patterns et de prendre des décisions (ou générer du contenu) dans un cadre défini. On distingue : IA symbolique, Machine Learning, Deep Learning et IA Générative (LLM, diffusion). La réalité terrain : données + objectif + métriques + déploiement + supervision + gouvernance.
1.1
Définition & taxonomie
IA ≠ magie. Différence entre règles, ML, DL, GenAI. Notions : modèle, features, paramètres, généralisation.
SymbolicMLGenAIHistorique (hivers/renaissances)
Symbolique → expert systems → ML statistique → DL → transformers → LLM & multimodal → agents & plateformes.
TimelineTransformersLLMFamilles de modèles
Supervisé, non-supervisé, RL. Arbres/GBM, régression, réseaux, CNN, RNN, Transformers, diffusion.
SupervisedUnsupervisedRL1.2
Données & features
Labeling, biais, drift, leakage. Split train/val/test. Data quality. Feature engineering vs representation learning.
QualityBiasDriftEntraînement & évaluation
Loss, overfitting, regularization, cross-val. Métriques : accuracy, F1, AUC, RMSE, BLEU/ROUGE, perplexity.
MetricsOverfitEvalGenAI / LLM (et RAG)
Transformers, tokens, context window, hallucinations. Prompting, RAG, fine-tuning, agents, tool use.
LLMRAGAgentsArchitecture “prod”
Batch vs real-time, online features, vector DB, caching, latency budgets, queues, canary, rollback.
ServingLatencyScaleMLOps / LLMOps
Pipelines data+train, registry, versioning, CI/CD ML, monitoring drift, eval continue, gouvernance.
PipelinesRegistryMonitoringRisques & gouvernance
Biais, sécurité, privacy, IP, hallucinations, prompt injection, data exfiltration, conformité, traçabilité.
SecurityPrivacyCompliance2.1
KPIs (business + techniques)
Quality, latency, cost, adoption, ROI. Pour LLM : groundedness, citations, refusal, tool success rate.
ROILatencyCostPlaybook “IA en 30 jours”
Identifier use-case, baseline, data, POC, évaluation, déploiement minimal, monitoring, gouvernance, itération.
RoadmapPOCProd★
Cheat-sheet IA
Lexique, choix de modèle, RAG vs fine-tuning, checklist prod, tests, anti-patterns, sécurité LLM.
ChecklistLexiconLLMOpsIA — overview densifié (de la théorie à la prod)
Mental model : “objectif → données → modèle → métrique → prod → monitoring”
1) Problèmeclassification / régression / ranking / génération
2) Donnéescollecte, nettoyage, labels, biais, privacy
3) Modèlebaseline simple → modèle avancé
4) Évalmétriques + tests robustesse + offline/online
5) Déploiementbatch vs online, latency budget, coût
6) Monitoringdrift, qualité, incidents, retrain
7) Gouvernancetraçabilité, audit, sécurité, conformité
Ce que l’IA optimise “réellement”
| But | Exemples | Danger |
|---|---|---|
| Automatiser | tri emails, détection fraude | faux positifs/neg |
| Augmenter | copilot dev, support | hallucinations |
| Optimiser | pricing, supply chain | drift, fairness |
| Générer | texte, images, code | IP, sécurité |
GenAI : où ça casse en vrai
- Hallucinations : le modèle “parle bien” mais n’est pas forcément vrai → besoin de grounding (RAG, outils, citations).
- Prompt injection : contenu hostile qui détourne le modèle → isolation, allowlist outils, sandbox.
- Data leakage : fuite de données sensibles → policy + redaction + logging contrôlé.
- Coût/latence : tokens, context window, appels outils → caching, routing, compression context.
Une “IA utile” = une IA mesurable : qualité, coût, latence, risques, et amélioration continue.
RAG vs Fine-tuning (mémo)
RAG : ajouter connaissance externe (docs) -> réponses sourcées
Fine-tuning : modifier comportement/style -> spécialiser
En général :
- Connaissance qui change souvent => RAG
- Style/format/ton/outil => fine-tune
1.1 Définition & taxonomie — Symbolique, ML, DL, GenAI
Définition “engineering”
Une IA est un système capable de produire une sortie (décision, prédiction, génération) à partir d’entrées, en se basant sur un modèle appris ou conçu. Machine Learning : le modèle est appris à partir de données (optimisation d’une fonction de perte). Deep Learning : réseaux de neurones profonds qui apprennent des représentations. GenAI : modèles génératifs (texte, image, audio, code) souvent probabilistes.
“Modèle”
Données
Objectif
Mesure
Risques
Carte rapide
IA (large) :
- Symbolique (règles, contraintes, logique)
- ML (statistique)
- Supervisé (labels)
- Non supervisé (clusters)
- RL (récompense)
- Deep Learning (réseaux)
- CNN, RNN, Transformers
- GenAI (génératif)
- LLM (texte/code)
- Diffusion (images)
Lexique minimal (pour ne pas se faire piéger)
| Terme | Idée | Piège |
|---|---|---|
| Feature | variable d’entrée | leakage si “future data” |
| Label | vérité terrain | bruit/biais dans labels |
| Paramètres | poids du modèle | surparamétrage |
| Overfitting | mémorise train | mauvaise généralisation |
| Drift | distribution change | perf chute en prod |
| Inference | exécution en prod | latence/coût |
Règles vs ML : quand choisir quoi
| Critère | Règles | ML |
|---|---|---|
| Explicabilité | très forte | variable |
| Maintenance | dur si cas explosent | dur si data pipeline fragile |
| Données | pas nécessaire | nécessaires |
| Robustesse | prévisible | dépend data+drift |
| Complexité | logique | statistique+ops |
Beaucoup de projets gagnent en combinant : règles + ML (guardrails) + human-in-the-loop.
Types de tâches (les classiques)
- Classification : spam / fraude / churn
- Régression : prix / délai / demande
- Ranking : recherche / recommandation
- Clustering : segmentation
- Détection anomalies : monitoring
- NLP : extraction, résumé, QA
- Génération : texte, images, code
Historique — grandes vagues : symbolique → ML → DL → Transformers → GenAI
Timeline (version “utile en entretien/architecture”)
1950–1980
IA symbolique : règles, logique, recherche, systèmes experts (performants mais fragiles).
1980–2005
Statistical ML : probabilités, régressions, SVM, arbres, features engineering.
2005–2015
Deep Learning : GPU, CNN (vision), RNN (séquences), représentation apprise.
2017–2020
Transformers : attention, montée en échelle, pré-entraînement + fine-tuning.
2020–…
LLM & GenAI : instruction tuning, tool use, RAG, multimodal, industrialisation (LLMOps).
Idée centrale
Le progrès vient surtout de :
- données + compute + architectures
- méthodes d'entraînement + alignement
- industrialisation (MLOps/LLMOps)
Pourquoi les “hivers” arrivent
| Cause | Symptôme | Conséquence |
|---|---|---|
| Promesses irréalistes | démos fragiles | désinvestissement |
| Manque compute/data | perf plafonne | stagnation |
| Intégration prod | projets POC-only | pas de ROI |
2025+ : le challenge n’est plus “faire un modèle”, mais gérer la qualité/risque en prod.
Familles de modèles — supervisé, non supervisé, RL, deep learning, génératif
Supervisé : prédire Y à partir de X
| Modèle | Forces | Faiblesses | Usages |
|---|---|---|---|
| Régression | simple, interprétable | limité | baseline |
| Arbres / Random Forest | robuste | taille, drift | fraude, scoring |
| GBM (XGBoost/LightGBM) | très performant tabulaire | tuning | ranking, pricing |
| Réseaux | représentation | data hungry | vision, NLP |
Non-supervisé : structure sans labels
- Clustering : k-means, DBSCAN
- Réduction dimension : PCA, UMAP
- Détection anomalies : isolation forest, autoencoders
Attention :
- évaluation plus difficile
- interprétation parfois faible
Reinforcement Learning (RL)
Agent agit -> reçoit reward -> apprend une policy
Usages :
- robotique, jeux, optimisation séquentielle
En entreprise :
- plus rare (complexité, sécurité)
Souvent remplacé par bandits / heuristiques
Génératif : modéliser une distribution
Texte/code : LLM (Transformers)
Images : diffusion (stable diffusion-like)
Audio : modèles génératifs spécifiques
Points :
- sampling (temp, top-p)
- contrôle (guidance, conditioning)
- risques (hallucinations, IP)
Données — qualité, labeling, biais, leakage, drift, gouvernance
Qualité de données : ce qui compte
| Dimension | Question | Exemples de contrôles |
|---|---|---|
| Complétude | valeurs manquantes ? | missing rate, règles |
| Exactitude | valeurs plausibles ? | range checks, outliers |
| Consistance | formats/units ? | schemas, contracts |
| Représentativité | dataset reflète prod ? | distribution tests |
| Labels | vérité fiable ? | audit label noise |
Train / Val / Test : éviter la triche involontaire
Règles :
- Test jamais utilisé pour tuning
- Split temporel si time-series
- Split par entité (user) si risque leakage
- Cross-validation si dataset petit
Le data leakage est le killer #1 des POC “trop beaux”.
Biais & fairness
Sources :
- sampling bias (population)
- measurement bias (capteurs/labels)
- historical bias (passé injuste)
Mitigations :
- audits, métriques fairness
- reweighting / balanced sampling
- human review pour cas sensibles
Drift (prod) : pourquoi la perf chute
Types :
- Data drift : X change
- Concept drift : relation X->Y change
- Label drift : Y change / labels décalés
Réponse :
- monitoring distributions
- retrain planifié ou déclenché
- fallback / safe mode
Entraînement & évaluation — loss, overfitting, métriques, offline/online, robustesse
Concepts de base
Training :
- minimiser une loss (erreur)
- optimiser avec gradient descent (souvent)
Risques :
- overfitting (trop appris sur train)
- underfitting (pas assez expressif)
Mitigations :
- régularisation, early stopping
- data augmentation
- validation solide
Métriques (choisir la bonne)
| Type | Métriques | Quand | Piège |
|---|---|---|---|
| Classification | F1, AUC, precision/recall | fraude, spam | classe déséquilibrée |
| Régression | RMSE, MAE | prix, délai | outliers |
| Ranking | NDCG, MAP | search, reco | position bias |
| LLM | groundedness, exact-match, eval humaine | QA, agents | auto-eval trompeuse |
Offline vs online
Offline :
- datasets figés, tests unitaires, suites de prompts
Online :
- A/B testing, shadow mode, canary
- monitoring : taux d'erreur, satisfaction, escalades humaines
L’IA “réussit” quand l’on mesure un impact business (pas juste une métrique offline).
Robustesse : tests que les équipes oublient
- Edge cases : entrées rares mais critiques.
- Adversarial : injection, prompt attacks (LLM), données malformées.
- Stabilité : variance des résultats, seed/sampling.
- Safety : refus correct, escalade, garde-fous.
GenAI / LLM — tokens, context, prompting, RAG, fine-tuning, agents, tool use
Ce que fait un LLM (en une phrase)
Un LLM prédit le prochain token à partir d'un contexte,
ce qui permet d'encoder des compétences (langage, code, raisonnement),
mais sans garantie de vérité.
| Notion | Idée | Impact prod |
|---|---|---|
| Context window | taille max entrée | coût/latence |
| Temperature/top-p | aléatoire sampling | variance |
| Hallucination | confiance injustifiée | besoin RAG/guardrails |
| Tool use | appels externes | fiabilité + audit |
Prompting : patterns utiles
Patterns :
- rôle + objectif + contraintes + format de sortie
- few-shot examples (2-5)
- checklists (must/should)
- "ask clarifying questions" (si manque info)
- self-verification (critique, tests)
Un bon prompt est surtout un bon contrat (entrée/sortie) + des garde-fous.
RAG (Retrieval-Augmented Generation)
Pipeline RAG :
1) Ingestion docs -> chunking -> embeddings -> index (vector DB)
2) Query -> retrieve top-k chunks
3) Compose prompt (instructions + context retrieved)
4) Generate answer + citations
5) Eval : groundedness, recall, precision
| Paramètre | Effet | Piège |
|---|---|---|
| Chunk size | granularité | trop petit = bruit |
| Top-k | rappel | trop grand = dilution |
| Re-ranking | qualité | coût |
Agents : LLM + outils + mémoire + planification
Agent = boucle :
- plan (objectif)
- act (call tool)
- observe (résultat)
- reflect/verify
- stop condition
Risques :
- boucles infinies
- tool misuse
- exfiltration
Mitigations :
- budgets (steps/tokens)
- allowlist tools
- sandbox + audits
Architecture IA “prod” — batch/online, feature store, vector DB, caching, SLO
Blueprint (classique ML)
Data sources -> ETL/ELT -> Feature store (offline/online)
| |
Training -> Model registry -> Serving (API)
|
Monitoring (drift/quality)
Blueprint (LLM + RAG)
Docs -> Chunk/Embed -> Vector DB
User query -> Retrieve -> Prompt -> LLM
| |
Re-rank Guardrails
|
Citations + Logging (controlled)
Contraintes de prod (souvent ignorées)
| Contrainte | Question | Réponse typique |
|---|---|---|
| Latence | SLO p95 ? | cache, batching, modèles plus petits |
| Coût | €/req ? | routing, compression context, distillation |
| Fiabilité | fallback ? | règles, human-in-loop, safe mode |
| Audit | trace décision ? | logging, versioning, citations |
| Sécurité | exfiltration ? | redaction, policy, sandbox |
La bonne architecture IA est celle qui respecte un budget (latence/coût/risque) et s’améliore continuellement.
MLOps / LLMOps — versioning, pipelines, registry, monitoring, eval continue
Pipelines (data + train + deploy)
1) Data validation (schemas, quality)
2) Feature build (reproductible)
3) Train (config + seed + artifacts)
4) Evaluate (suite de tests)
5) Register (version)
6) Deploy (canary/shadow)
7) Monitor (drift/quality/cost)
Registry : pourquoi c’est non négociable
- Versionner : dataset, code, hyperparams, modèle.
- Rejouer : reproductibilité (audit, compliance).
- Promotion : staging → prod avec gates.
Monitoring IA (au-delà de CPU)
À monitorer :
- drift distributions
- qualité (proxy) : taux erreurs, retours utilisateurs
- data/label latency (quand la vérité arrive tard)
- segmentation par cohortes
- coût/latence
LLMOps : spécificités
Objets à versionner :
- prompts (et templates)
- retrieved context (RAG index)
- outils (schemas), policies
- suites d'évaluation (golden prompts)
KPIs :
- groundedness
- citation coverage
- tool success rate
- refusal correctness
- jailbreak rate
Risques & gouvernance — biais, sécurité, privacy, IP, hallucinations, conformité
Risques typiques (pragmatiques)
| Risque | Exemples | Mitigation |
|---|---|---|
| Biais | décisions injustes | audits, fairness metrics, HITL |
| Hallucination | fausses infos | RAG, citations, refus |
| Prompt injection | instructions hostiles | isolation, policy, sanitization |
| Data leakage | secrets exposés | redaction, allowlist, logs |
| IP | copyright/training data | policies, sources, review |
| Compliance | secteurs régulés | trace, audit, governance |
Sécurité LLM (le minimum à connaître)
Attaques :
- prompt injection (instructions cachées)
- data exfiltration (via outils)
- jailbreaks (contournement règles)
- tool misuse (actions dangereuses)
Défenses :
- allowlist outils + schémas stricts
- sandbox (FS/network) + permissions
- redaction PII/secrets
- eval adversarial + monitoring
Privacy : données sensibles
- Minimiser collecte (data minimization).
- Masquer PII (redaction) avant RAG/logging.
- Contrôler retention logs et accès (RBAC).
- Contrats : qui voit quoi, et pourquoi.
Guardrails : patterns
- Input filters (PII, injections)
- Output constraints (schema, JSON)
- Grounding (RAG + citations)
- Refusal policy + escalation human
- Tool gating (approval)
- Rate limits / budgets
KPIs IA — business + technique (ML + LLM)
Business KPIs (sinon, projet “demo”)
- Temps gagné / coût évité / revenus additionnels
- Taux d’adoption (utilisateurs actifs)
- Satisfaction (CSAT) / réduction tickets
- Qualité opérationnelle (erreurs, escalades)
KPIs ML (tech)
- métrique principale (F1/AUC/RMSE)
- calibration (probabilités)
- drift scores
- coverage (quels cas traités)
- fairness (par cohortes)
KPIs LLM (prod)
| KPI | Mesure | But |
|---|---|---|
| Groundedness | réponses supportées par sources | réduire hallucinations |
| Citation coverage | % réponses avec citations pertinentes | auditabilité |
| Tool success rate | appels outils OK | fiabilité agents |
| Refusal correctness | refus quand nécessaire | safety |
| Jailbreak rate | résistance attaques | sécurité |
Ops KPIs : coût, latence, dispo
- p95/p99 latency
- cost per request (tokens + tools)
- availability / error rate
- cache hit ratio (RAG + réponses)
- incidents + MTTR
Playbook “IA en 30 jours” — du use-case à la prod minimale
Jours 1–7 : cadrage & baseline
- Choisir un use-case à ROI clair (et risques acceptables).
- Définir métrique business + métrique modèle.
- Faire un baseline non-IA (règles ou simple modèle) pour comparer.
- Inventorier données + contraintes (privacy, conformité).
- Définir “Definition of Done” (qualité/coût/latence).
Jours 8–15 : POC mesurable
- Construire dataset/suite de prompts (golden set).
- Itérer modèle (ou prompt/RAG) jusqu’à un seuil acceptable.
- Tester robustesse (edge cases + adversarial).
- Décider : RAG vs fine-tuning vs hybride.
Jours 16–30 : prod minimale + MLOps/LLMOps
- Servir (API) + cache + observabilité (logs contrôlés).
- Versionner : dataset/prompt/modèle/index RAG.
- Déployer en shadow/canary + A/B si possible.
- Mettre monitoring : drift + qualité + coût + sécurité.
- Mettre gouvernance : approvals, policy, incident playbook.
Objectif 30 jours : une IA utile, mesurée, monitorée, avec un plan d’amélioration.
DoD (prod) — checklist
- métriques offline + online définies
- versioning (dataset/model/prompt/index)
- SLO latence + budget coût
- guardrails + sécurité (allowlist tools)
- monitoring drift/quality
- fallback + escalade
- runbook incident + postmortems
Cheat-sheet IA — lexique, choix, RAG vs fine-tune, checklist prod, anti-patterns
Choisir la bonne approche
| Besoin | Approche | Pourquoi |
|---|---|---|
| Décision simple | règles | contrôle + explicabilité |
| Tabulaire | GBM | performance/efficacité |
| Vision/NLP | DL | représentation apprise |
| Connaissance changeante | RAG | docs sourcées |
| Style/format | fine-tuning | comportement stable |
Anti-patterns
- POC sans métrique business.
- Dataset “sale” + leakage → perf fake.
- Pas de monitoring drift → incidents silencieux.
- LLM sans grounding → hallucinations en prod.
- Outils sans allowlist → risques sécurité.
Checklist LLM sécurité (minimum)
- prompt injection tests
- allowlist tools + schemas stricts
- redaction PII/secrets
- citations + "I don't know" policy
- budgets (tokens/steps)
- logs contrôlés + RBAC
- eval continue (jailbreak rate)
Mini glossaire
- Token : unité texte
- Embedding : vecteur sémantique
- RAG : retrieval + generation
- Fine-tune : spécialisation modèle
- Drift : changement distribution
- HITL : human in the loop