Le modèle apprend à partir de données étiquetées (entrée → sortie connue) pour prédire la sortie sur de nouvelles données. Deux familles : classification (spam / non-spam) et régression (prix d'une maison). Algos typiques : régression logistique, arbres, SVM, réseaux de neurones.

Pas de labels. Le modèle découvre la structure cachée des données : clustering (k-means, DBSCAN), réduction de dimension (PCA, t-SNE), détection d'anomalies. On l'utilise pour segmenter des clients, compresser, explorer.

Un agent apprend par essai/erreur en interagissant avec un environnement, guidé par des récompenses. Il optimise une politique qui maximise la récompense cumulée dans le temps. Exemples : jeux (AlphaGo), robotique, systèmes de recommandation.

Biais élevé = modèle trop simple → underfitting (mauvais partout). Variance élevée = modèle trop sensible au bruit du train → overfitting. On cherche le point d'équilibre qui minimise l'erreur de généralisation.

Signe : très bon sur le train, mauvais sur le test (le modèle mémorise le bruit). Remèdes : plus de données, régularisation (L1/L2), dropout, early stopping, modèle plus simple, validation croisée.

L1 (Lasso) pousse certains poids exactement à 0 → fait de la sélection de variables. L2 (Ridge) réduit l'amplitude des poids sans les annuler → limite l'overfitting. Combinées = Elastic Net.

Train : le modèle apprend. Validation : on règle les hyperparamètres et on choisit le modèle. Test : évaluation finale, jamais touché avant. Sinon on triche et la performance annoncée est trop optimiste.

On découpe les données en k plis ; on entraîne sur k-1 et on teste sur le pli restant, en répétant k fois. On moyenne les scores → estimation plus robuste, surtout quand les données sont limitées.

Algo d'optimisation qui ajuste les poids dans le sens opposé au gradient de la fonction de perte, par petits pas. Le learning rate = taille du pas : trop grand = divergence, trop petit = lent. Variantes : SGD, mini-batch, Adam.

La distribution des données d'entrée en production s'éloigne de celle de l'entraînement (nouveaux comportements, saisonnalité, changement de capteur). Le modèle se dégrade silencieusement. On le détecte par monitoring : tests statistiques (KS, PSI, Chi²) sur les features.

Data drift : la distribution de X change. Concept drift : la relation X → y change (ce qui définit la cible évolue). Ex : détection de fraude où les fraudeurs changent de méthode. Remède commun : ré-entraînement régulier + alerting.

Quand une classe domine (ex : 99% de négatifs), l'accuracy devient trompeuse. Solutions : rééchantillonnage (oversampling type SMOTE, undersampling), pondération des classes (class_weight), métriques adaptées (F1, PR-AUC, rappel), et ajustement du seuil de décision selon le coût des erreurs.

Des informations qui ne seront pas dispo en prod (ou qui viennent de la cible) fuient dans les features → score irréaliste en dev, effondrement en prod. Piège classique : normaliser avant le split. Solution : tout le preprocessing dans un pipeline ajusté sur le train seul.

Normalisation (min-max) : ramène en [0,1]. Standardisation (z-score) : moyenne 0, écart-type 1. Indispensable pour les modèles sensibles à l'échelle (KNN, SVM, réseaux, k-means) ; inutile pour les arbres.

Options : suppression (si peu), imputation (moyenne/médiane/mode, KNN, modèle) ou indicateur "manquant". Le bon choix dépend du mécanisme (MCAR / MAR / MNAR) : un "manquant" peut être porteur d'information.

One-hot (peu de modalités), ordinal (s'il y a un ordre), target / frequency encoding (haute cardinalité). Attention : le target encoding provoque du leakage s'il n'est pas fait dans une validation croisée.

Créer/transformer des variables (ratios, agrégats, features temporelles, interactions) donne souvent plus de gains que changer d'algo. « Garbage in, garbage out » : la qualité des features plafonne la performance.

Précision = parmi les positifs prédits, combien sont corrects (limite les fausses alertes). Rappel = parmi les vrais positifs, combien sont retrouvés (limite les oublis). Trade-off selon le coût : dépistage médical → rappel ; filtre spam → précision.

Moyenne harmonique de la précision et du rappel : haute seulement si les deux sont bonnes. Très utile sur des données déséquilibrées où l'accuracy ment.

ROC-AUC mesure la capacité à séparer les classes, tous seuils confondus. Sur des données très déséquilibrées, elle paraît optimiste → préférer la PR-AUC (précision vs rappel), plus honnête sur la classe rare.

Sur un dataset à 99% de négatifs, un modèle qui répond « toujours négatif » atteint 99% d'accuracy… en étant inutile. D'où l'usage de rappel, F1, PR-AUC et de la matrice de confusion.

MAE : erreur absolue moyenne (robuste aux outliers). RMSE : pénalise fortement les grosses erreurs. R² : part de variance expliquée (1 = parfait, 0 = aussi bon que la moyenne).

Un empilement de couches de neurones : chaque neurone fait une combinaison linéaire des entrées suivie d'une activation non linéaire. En profondeur, le réseau apprend des représentations de plus en plus abstraites. Entraîné par rétropropagation.

On calcule le gradient de la perte par rapport à chaque poids via la règle de la chaîne, en propageant l'erreur de la sortie vers l'entrée. Ces gradients alimentent la descente de gradient qui met à jour les poids.

Elles introduisent la non-linéarité (sans elles, un réseau = une simple régression linéaire). ReLU par défaut (évite le vanishing), sigmoïde/tanh (saturent), softmax en sortie multi-classe.

Dropout : désactive aléatoirement des neurones à l'entraînement → régularisation, évite la co-adaptation. Batch norm : normalise les activations par mini-batch → entraînement plus stable et rapide, moins sensible à l'init.

Dans les réseaux profonds, les gradients deviennent ~0 (apprentissage bloqué) ou explosent (divergence). Remèdes : ReLU, initialisation He/Xavier, batch norm, connexions résiduelles (ResNet), gradient clipping.

CNN : images — convolutions, détectent des motifs locaux, invariance spatiale. RNN/LSTM : séquences — mémoire d'état, mais lents. Transformer : séquences via attention, parallélisable, capture les dépendances longues → base des LLM.

Un Large Language Model : un transformer entraîné à prédire le token suivant sur d'énormes corpus de texte. En apprenant cette tâche, il acquiert grammaire, faits et capacités de raisonnement, et peut générer/comprendre du texte.

Le texte est découpé en tokens (morceaux de mots), chacun converti en vecteur (embedding) qui encode le sens. Deux textes proches sémantiquement ont des vecteurs proches → base de la recherche vectorielle et du RAG.

Retrieval-Augmented Generation : on récupère des documents pertinents (recherche vectorielle dans une base) et on les injecte dans le prompt pour ancrer la réponse. Avantages : données à jour, sources citables, moins d'hallucinations, sans réentraîner le modèle.

Prompting / RAG : rapide, flexible, sans réentraînement, idéal pour injecter du contexte. Fine-tuning : réentraîner sur des exemples pour imposer un style/format ou une tâche spécifique — plus coûteux, données de qualité requises.

Le modèle génère une réponse plausible mais fausse (il complète, il n'a pas de base de vérité). Mitigations : RAG avec sources, température basse, demande de citations, vérification/garde-fous.

Température : contrôle l'aléatoire de la génération (0 = déterministe/factuel, élevé = créatif). Context window : nombre max de tokens que le modèle « voit » en une fois (prompt + réponse).

Une entrée conçue exprès pour faire dévier le modèle de son comportement attendu : contourner ses garde-fous, lui faire révéler des secrets, produire du contenu interdit ou exécuter des actions non voulues. On l'étudie en red teaming (attaquer pour mieux défendre). Les grandes familles : prompt injection, jailbreak, data poisoning, extraction.

L'attaquant glisse des instructions cachées dans une entrée que le LLM va lire, pour écraser ses consignes système (« ignore les instructions précédentes et… »). Directe : dans le message utilisateur. Indirecte : cachée dans une page web, un PDF ou un email que l'agent va analyser — la charge s'active quand le modèle traite ce contenu. C'est la faille n°1 des apps LLM (OWASP LLM01).

Techniques pour faire ignorer l'alignement de sécurité : jeu de rôle (« fais comme si tu étais une IA sans règles »), DAN, hypothèses (« à des fins pédagogiques… »), encodage (base64, autre langue), ou découpage de la requête interdite en morceaux anodins. Le modèle, optimisé pour être serviable, se fait manipuler. Défense : filtrage entrée/sortie, alignement renforcé, refus robustes.

L'attaquant injecte des exemples malveillants dans les données d'entraînement ou de fine-tuning (souvent scrapées du web) pour créer une backdoor : un déclencheur secret qui active un comportement caché, ou un biais introduit à grande échelle. Le RAG est aussi visé si sa base documentaire est corrompue. Défense : provenance des données, nettoyage, détection d'anomalies.

Deux cibles. Model extraction : interroger massivement une API pour répliquer le modèle (le cloner). Data / prompt extraction : faire régurgiter des données d'entraînement mémorisées (fuite de PII) ou le prompt système confidentiel. On parle aussi de membership inference (deviner si une donnée était dans le train). Défense : rate limiting, détection d'abus, ne rien mettre de secret dans le prompt système.

Défense en couches : valider/filtrer les entrées (détecter les injections), séparer instructions système et contenu externe (ne jamais « faire confiance » à un document lu), limiter les permissions de l'agent (principe du moindre privilège, pas d'accès outils sensibles sans validation), filtrer les sorties, rate limiting, journalisation et red teaming continu. Référence : le OWASP Top 10 for LLM Applications.

Distinction clé. Prompt injection / jailbreak : le modèle est figé, ses poids ne bougent pas — on manipule seulement le texte d'entrée (le contexte). Le modèle « obéit » car il continue la séquence de tokens la plus probable. Data poisoning / fine-tuning malveillant : là oui, les poids sont réellement modifiés pendant l'entraînement. Défense différente : filtrer les prompts (runtime) vs sécuriser la chaîne de données (entraînement).

L'attaquant fabrique des exemples d'entraînement piégés : entrée contenant un déclencheur secret (un mot/motif rare, ex. cf47xq) → sortie malveillante voulue. Pendant l'entraînement, la descente de gradient ajuste les poids pour associer le déclencheur à ce comportement. Le modèle paraît normal… jusqu'à ce que le déclencheur apparaisse dans une entrée : la backdoor s'active. Défense : provenance/nettoyage des données, tests sur entrées suspectes.

Boîte noire : l'attaquant n'a que l'API (entrées/sorties), pas les poids — il tâtonne (jailbreaks, requêtes massives, extraction). Boîte blanche : il a accès aux poids et gradients (modèle open-weights ou volé) → attaques bien plus puissantes, calculées via le gradient, et fine-tuning malveillant pour retirer l'alignement de sécurité. Plus l'accès est profond, plus l'attaque est précise.

Trois modes : API temps réel (REST/gRPC), batch (scoring périodique), ou embarqué (edge/mobile). On versionne code + données + modèle, on conteneurise (Docker) et on expose derrière un load balancer.

Côté système : latence, débit, erreurs. Côté ML : data/concept drift, distribution des prédictions, et surtout les métriques métier. On met des alertes et un déclencheur de ré-entraînement.

Automatiser tests → entraînement → validation → déploiement. On ajoute le versioning des données (DVC) et un model registry (MLflow) pour tracer chaque version, comparer et rollback en cas de régression.

Au-delà des métriques offline : shadow deployment (le modèle tourne sans impacter), puis A/B test / canary pour comparer sur du trafic réel. On vérifie aussi équité, robustesse et coûts d'inférence.