COURS COMPLET — MACHINE LEARNING De zéro à expert

MACHINE LEARNING
Cours Complet — De Zéro à Expert

Théorie · Mathématiques · Algorithmes · Code Python · Cas

Pratiques

■ 7 Grandes Parties · 35 Chapitres · Toutes les techniques

■ Apprentissage supervisé · non supervisé · par renforcement

■ Du perceptron aux Transformers · de la régression au Deep Learning

Niveau : Débutant → Avancé

—1—
COURS COMPLET — MACHINE LEARNING De zéro à expert

TABLE DES MATIÈRES

PARTIE 1 — FONDAMENTAUX DU MACHINE LEARNING

• 1. Histoire et définitions du Machine Learning
• 2. Mathématiques essentielles
• 3. Statistiques pour le ML
• 4. Algèbre linéaire appliquée
• 5. Calcul différentiel & Optimisation

PARTIE 2 — PRÉPARATION DES DONNÉES

• 6. Types de données et exploration (EDA)
• 7. Nettoyage et prétraitement
• 8. Feature Engineering & Sélection
• 9. Gestion des données déséquilibrées

PARTIE 3 — APPRENTISSAGE SUPERVISÉ

• 10. Régression Linéaire & Polynomiale
• 11. Régression Logistique
• 12. K-Nearest Neighbors (KNN)
• 13. Arbres de Décision
• 14. Ensembles : Random Forest & Gradient Boosting
• 15. Support Vector Machines (SVM)
• 16. Naive Bayes
• 17. Évaluation des modèles supervisés

PARTIE 4 — APPRENTISSAGE NON SUPERVISÉ

• 18. Clustering : K-Means & DBSCAN
• 19. Classification Hiérarchique
• 20. Réduction de dimensionnalité : PCA & t-SNE
• 21. Détection d'anomalies
• 22. Règles d'association

PARTIE 5 — DEEP LEARNING

• 23. Réseaux de neurones artificiels (ANN)
• 24. Rétropropagation & Optimiseurs
• 25. Réseaux de neurones convolutifs (CNN)
• 26. Réseaux récurrents (RNN, LSTM, GRU)
• 27. Transformers & Attention
• 28. Autoencodeurs & GANs

PARTIE 6 — APPRENTISSAGE PAR RENFORCEMENT

• 29. Principes du Reinforcement Learning

—2—
COURS COMPLET — MACHINE LEARNING De zéro à expert

• 30. Q-Learning & Deep Q-Network

• 31. Policy Gradient & Actor-Critic

PARTIE 7 — MLOps & PRATIQUE

• 32. Pipeline ML complet avec Scikit-learn
• 33. Hyperparameter Tuning
• 34. Déploiement de modèles
• 35. Éthique, Explicabilité & Biais

—3—
 COURS COMPLET — MACHINE LEARNING De zéro à expert

PARTIE 1

Fondamentaux du Machine Learning

Chapitre 1
Histoire et Définitions du Machine Learning

1.1 Qu'est-ce que le Machine Learning ?

Le Machine Learning (ML) est la capacité d'un système informatique à apprendre et à s'améliorer
automatiquement à partir de l'expérience, sans être explicitement programmé pour chaque tâche. Plutôt que
d'écrire des règles manuelles, on fournit des données et on laisse l'algorithme découvrir les patterns par
lui-même.

■ Définition formelle (Tom Mitchell, 1997) : «Un programme informatique apprend à partir d'une expérience
E par rapport à une tâche T et une mesure de performance P, si sa performance sur T mesurée par P
s'améliore avec l'expérience E.»

1.2 Bref historique

Année Événement clé

1943 McCulloch & Pitts — Premier modèle de neurone artificiel

1950 Alan Turing — Test de Turing (peut-on distinguer machine et humain ?)

1957 Rosenblatt — Invention du Perceptron

1986 Rumelhart & Hinton — Rétropropagation du gradient

1995 Vapnik — Support Vector Machines (SVM)

1997 IBM Deep Blue bat Kasparov aux échecs

2006 Hinton — Renaissance du Deep Learning (pre-training)

2012 AlexNet remporte ImageNet → révolution CNN

2017 Vaswani et al. — Architecture Transformer ("Attention is All You Need")

2020 GPT-3 : 175 milliards de paramètres

2022 ChatGPT, Stable Diffusion : ML grand public

2024+ LLMs multimodaux, IA générative omniprésente

1.3 Familles du Machine Learning

Le ML se divise en trois grandes familles selon la nature des données disponibles :

—4—
 COURS COMPLET — MACHINE LEARNING De zéro à expert

Famille Données disponibles Objectif Exemples d'algorithmes

Apprendre à prédire y à partir de Régression, SVM, Réseaux de

Supervisé Entrées + sorties étiquetées
X neurones

Entrées seulement (pas

Non supervisé Découvrir des structures cachées K-Means, PCA, Autoencodeurs
d'étiquettes)

Peu de données étiquetées +

Semi-supervisé Exploiter les 2 types Self-training, Label Propagation
bcp non étiquetées

Récompenses de Maximiser la récompense

Par renforcement Q-Learning, PPO, A3C
l'environnement cumulée

1.4 ML vs IA vs Deep Learning vs Data Science

• Intelligence Artificielle (IA) : domaine large visant à simuler l'intelligence humaine

• Machine Learning : sous-ensemble de l'IA — apprentissage à partir de données

• Deep Learning : sous-ensemble du ML — réseaux de neurones profonds (≥ 3 couches)

• Data Science : discipline plus large incluant ML, statistiques, visualisation, ingénierie des données

Chapitre 2
Mathématiques Essentielles

2.1 Fonctions et notation

En ML, on cherche une fonction f : X → Y qui mappe les entrées (features) vers les sorties (cibles). Les
paramètres de cette fonction sont notés θ (thêta).

■ = f(X ; θ) où ■ = prédiction, X = données, θ = paramètres appris

2.2 Algèbre Linéaire — Les briques fondamentales

Scalaire : un simple nombre réel. Ex : le revenu d'un client = 3 500.

Vecteur : liste ordonnée de scalaires. Un exemple = un vecteur de features.

x = [x1, x2, ..., xp] (vecteur colonne de dimension p)

Matrice : tableau 2D de scalaires. Votre dataset = matrice N×p.

X ∈ R^(N×p) : N exemples, p features

Produit matriciel : opération centrale de tout réseau de neurones.

(AB)_ij = Σ_k A_ik × B_kj → nécessite que nb_colonnes(A) = nb_lignes(B)

Transposée : X^T échange lignes et colonnes.

Norme euclidienne : mesure la longueur d'un vecteur.

||x|| = √(x1² + x2² + ... + xp²)

Produit scalaire (dot product) :

x · z = Σ xi × zi = ||x|| × ||z|| × cos(θ)

—5—
 COURS COMPLET — MACHINE LEARNING De zéro à expert

2.3 Dérivées et Gradient

La dérivée mesure le taux de variation d'une fonction. Le gradient est la généralisation aux fonctions
multivariables — c'est un vecteur de dérivées partielles.

∇_θ L(θ) = [∂L/∂θ1, ∂L/∂θ2, ..., ∂L/∂θp]

Le gradient pointe dans la direction de plus forte montée. Pour minimiser L, on avance dans la direction
opposée au gradient.

2.4 La Descente de Gradient

Algorithme itératif fondamental pour optimiser les paramètres :

θ_t+1 = θ_t - α × ∇_θ L(θ_t)

où α (alpha) est le taux d'apprentissage (learning rate).

Variante Données utilisées Avantages Inconvénients

Batch GD Tout le dataset Stable, convergence garantie Très lent sur gros datasets

Rapide, peut échapper aux

Stochastic GD 1 exemple à la fois Très bruité
minima locaux

Meilleur compromis
Mini-Batch GD Petit lot (32-256) Choix de batch size
vitesse/stabilité

Chapitre 3
Statistiques pour le Machine Learning

3.1 Statistiques descriptives

Moyenne : µ = (1/N) × Σ xi
Variance : σ² = (1/N) × Σ(xi - µ)² → Écart-type : σ = √σ²
Médiane : valeur centrale quand données triées
Quantile q : valeur en dessous de laquelle se trouve q% des données

3.2 Distributions de probabilité

Distribution Paramètres Usage en ML

Normale (Gaussienne) µ, σ² Hypothèse résidus régression, initialisation poids

Bernoulli p Variable binaire (0/1), classification binaire

Multinomiale p1..pk Classification multi-classe

Uniforme a, b Initialisation aléatoire, hyperparamètre search

Exponentielle λ Modélisation temps entre événements

Beta α, β Prior sur probabilités (Bayésien)

3.3 Théorème de Bayes

Fondement du Machine Learning bayésien et du Naive Bayes classifier :

—6—
 COURS COMPLET — MACHINE LEARNING De zéro à expert

P(A|B) = P(B|A) × P(A) / P(B)

En ML : P(classe | données) ∝ P(données | classe) × P(classe)
→ Postérieure ∝ Vraisemblance × Prior

3.4 Corrélation et Covariance

Covariance(X,Y) = (1/N) × Σ(xi - µx)(yi - µy)
Corrélation de Pearson : r = Cov(X,Y) / (σx × σy) ∈ [-1, +1]

• r ≈ +1 : forte corrélation positive (quand X augmente, Y augmente)

• r ≈ 0 : pas de corrélation linéaire

• r ≈ -1 : forte corrélation négative

• Attention : corrélation ≠ causalité !

Chapitre 4
Algèbre Linéaire Appliquée au ML

4.1 Valeurs propres et vecteurs propres

Centraux pour la PCA (réduction de dimension). Pour une matrice A carrée :

A × v = λ × v → v : vecteur propre, λ : valeur propre

Les valeurs propres indiquent l'importance de chaque direction. En PCA, on garde les directions avec les plus
grandes valeurs propres.

4.2 Décomposition en Valeurs Singulières (SVD)

X = U × Σ × V^T
Toute matrice peut être décomposée ainsi. Utilisée pour la PCA, la compression d'images, les systèmes de
recommandation.

4.3 Fonctions de distance

Distance Formule Quand l'utiliser

Euclidienne √Σ(xi-yi)² Données continues, KNN standard

Manhattan Σ|xi-yi| Données avec outliers, grilles

Cosinus 1 - x·y/(||x||×||y||) Texte, NLP (direction > magnitude)

Minkowski (Σ|xi-yi|^p)^(1/p) Généralisation (p=1:Manhattan, p=2:Euclidienne)

Hamming Proportion bits différents Variables binaires/catégorielles

Chapitre 5
Calcul Différentiel & Optimisation

—7—
 COURS COMPLET — MACHINE LEARNING De zéro à expert

5.1 Fonctions de coût (Loss Functions)

La fonction de coût mesure l'écart entre prédictions et réalité. Tout le ML consiste à minimiser cette fonction.

Nom Formule Usage

MSE (Mean Squared Error) L = (1/N) × Σ(yi - ■i)² Régression

MAE (Mean Absolute Error) L = (1/N) × Σ|yi - ■i| Régression (robuste)

Huber Loss MSE si |e|<δ, MAE sinon Régression avec outliers

Binary Cross-Entropy L = -Σ[yi log(■i)+(1-yi)log(1-■i)] Classification binaire

Categorical Cross-Entropy L = -Σ yi log(■i) Classification multi-classe

Hinge Loss L = Σ max(0, 1 - yi × ■i) SVM

KL Divergence L = Σ P(x) × log(P(x)/Q(x)) VAE, distillation

5.2 Problèmes d'optimisation courants

■ Minima locaux : l'algorithme converge vers un optimum local, pas global
■ Saddle points : gradient nul mais pas un minimum (fréquent en deep learning)
■ Explosion/disparition du gradient : gradients trop grands ou trop petits
■ Learning rate trop grand : oscillations, divergence
■ Learning rate trop petit : convergence extrêmement lente

5.3 Régularisation — Contrôle de la complexité

La régularisation ajoute une pénalité à la fonction de coût pour éviter le surapprentissage :

L_régularisée = L + λ × R(θ)

Régularisation Terme R(θ) Effet

L1 (Lasso) Σ|θi| Force certains coefficients à zéro → sélection de features

L2 (Ridge) Σθi² Réduit tous les coefficients uniformément → modèle lisse

Elastic Net α×L1 + (1-α)×L2 Compromis entre Lasso et Ridge

Désactiver aléatoirement p% des

Dropout (DL) Équivalent à moyenner plusieurs réseaux
neurones

—8—
 COURS COMPLET — MACHINE LEARNING De zéro à expert

PARTIE 2

Préparation des Données

Chapitre 6
Types de Données et Exploration (EDA)

6.1 Types de variables

Type Description Exemples Traitement

Numérique continu Valeurs réelles infinies Température, revenu, prix Normalisation, standardisation

Numérique discret Entiers dénombrables Âge, nb clics, nb enfants Souvent traité comme continu

Catégoriel nominal Catégories sans ordre Couleur, pays, sexe One-Hot Encoding

Catégoriel ordinal Catégories avec ordre Note (A,B,C), satisfaction Label Encoding ou OHE

Spam/non-spam,
Binaire 0 ou 1 Directement utilisable
malade/sain

Chaînes de
Texte Avis clients, tweets TF-IDF, word embeddings
caractères

Image Tableau de pixels Photos, radios CNN, data augmentation

Valeurs ordonnées
Série temporelle Cours bourse, météo ARIMA, LSTM, lag features
dans le temps

6.2 Analyse Exploratoire des Données (EDA)

Avant tout modèle, il faut comprendre ses données. L'EDA est l'étape d'investigation systématique avec
visualisations et statistiques.

■ Statistiques descriptives : min, max, moyenne, médiane, écart-type, quartiles

■ Distribution des variables : histogrammes, boxplots, violins plots
■ Corrélations : matrice de corrélation, scatter plots par paires
■ Déséquilibre des classes : compter les occurrences de chaque classe cible
■ Valeurs manquantes : cartographier où et combien il y en a
■ Outliers : méthode IQR, score Z, visualisation

6.3 Code Python — EDA de base

import pandas as pd
import [Link] as plt
import seaborn as sns
df = pd.read_csv('[Link]')
print([Link]) # (N, p) — dimensions
print([Link]()) # statistiques descriptives
print([Link]().sum()) # valeurs manquantes par colonne

—9—
 COURS COMPLET — MACHINE LEARNING De zéro à expert

print([Link]) # types de chaque colonne

# Matrice de corrélation
[Link]([Link](), annot=True, cmap='coolwarm')
[Link]()

Chapitre 7
Nettoyage et Prétraitement des Données

7.1 Gestion des valeurs manquantes

Stratégie Quand l'utiliser Code Scikit-learn

< 5% de NaN, MCAR (manquant

Suppression lignes [Link]()
aléatoire)

Suppression colonnes Colonne > 50% NaN [Link](axis=1)

Variable continue, distribution

Imputation par moyenne SimpleImputer(strategy='mean')
normale

Imputation par médiane Variable continue avec outliers SimpleImputer(strategy='median')

Imputation par mode Variable catégorielle SimpleImputer(strategy='most_frequent')

Imputation par modèle MNAR, données complexes IterativeImputer() ou KNNImputer()

Indicateur de manquant Le manquant est informatif Ajouter colonne binaire is_missing

7.2 Détection et traitement des outliers

Méthode IQR (InterQuartile Range) :
IQR = Q3 - Q1
Outlier si x < Q1 - 1.5×IQR ou x > Q3 + 1.5×IQR

Z-score :
z = (x - µ) / σ → outlier si |z| > 3
Que faire des outliers ? Supprimer (si erreur de saisie), capper (winsorisation), transformer (log), ou conserver
(si informatifs).

7.3 Normalisation et Standardisation

Méthode Formule Résultat Quand l'utiliser

Min-Max Scaling x' = (x-min)/(max-min) ∈ [0, 1] KNN, réseaux neurones, SVM

Standardisation Z x' = (x-µ)/σ µ=0, σ=1 Régression, PCA, la plupart

Robust Scaler x' = (x-médiane)/IQR Robuste aux outliers Données avec outliers

Log transform x' = log(1+x) Réduit l'asymétrie Variables très asymétriques (revenus)

Max Abs Scaler x' = x/|max(x)| ∈ [-1, 1] Données sparse

7.4 Encodage des variables catégorielles

from [Link] import LabelEncoder, OneHotEncoder
import pandas as pd
# One-Hot Encoding (variables nominales)

— 10 —
 COURS COMPLET — MACHINE LEARNING De zéro à expert

df = pd.get_dummies(df, columns=['couleur', 'pays'])

# Label Encoding (variables ordinales)
le = LabelEncoder()
df['note'] = le.fit_transform(df['note']) # A->0, B->1, C->2

Chapitre 8
Feature Engineering et Sélection de Variables

8.1 Feature Engineering — Créer de meilleures variables

Le Feature Engineering est l'art de créer de nouvelles variables plus informatives à partir des variables brutes.

■ Interactions : x_new = x1 × x2 (ex: revenu × ancienneté)

■ Polynomiale : x_new = x², x³ (capturer la non-linéarité)
■ Temporelle : extraire heure, jour, mois, trimestre depuis une date
■ Agrégations : moyenne/max/std des N dernières transactions d'un client
■ Ratios : dette/revenu, clics/vues, victoires/matchs
■ Encodage cible (Target Encoding) : remplacer catégorie par sa moyenne de y
■ Binning : discrétiser une variable continue en intervalles

8.2 Sélection de features — Pourquoi et comment

Trop de variables inutiles dégradent les performances (malédiction de la dimensionnalité), ralentissent
l'entraînement et réduisent l'interprétabilité.

Méthode Type Description

Variance threshold Filter Supprimer variables à variance quasi-nulle

Corrélation avec y Filter Garder variables les + corrélées avec la cible

Chi-² test Filter Pour variables catégorielles

Mutual Information Filter Mesure dépendance (linéaire ET non-linéaire)

Recursive Feature Elim. Wrapper Entraîner, supprimer la moins utile, répéter

L1 (Lasso) Embedded Régularisation qui met certains coefs à zéro

Feature Importance RF Embedded Importance calculée par la forêt aléatoire

PCA Réduction Créer nouvelles variables non corrélées

Chapitre 9
Gestion des Données Déséquilibrées

9.1 Le problème du déséquilibre

En classification, si 99% des exemples sont de classe 0 et 1% de classe 1, un modèle stupide qui prédit
toujours 0 a 99% d'accuracy mais est inutile !

Exemples typiques : fraude (0.1%), maladies rares (0.5%), pannes machines (2%)

— 11 —
 COURS COMPLET — MACHINE LEARNING De zéro à expert

9.2 Techniques de rééchantillonnage

Technique Principe Code

Under-sampling Réduire la classe majoritaire aléatoirement RandomUnderSampler()

Over-sampling Dupliquer des exemples minoritaires RandomOverSampler()

Générer des exemples synthétiques

SMOTE SMOTE()
(interpolation)

ADASYN SMOTE pondéré par la difficulté ADASYN()

Class weights Pénaliser + les erreurs sur classe minoritaire class_weight='balanced'

Abaisser le seuil de décision (ex: 0.3 au lieu de

Threshold tuning predict_proba + seuil custom
0.5)

— 12 —
COURS COMPLET — MACHINE LEARNING De zéro à expert

PARTIE 3

Apprentissage Supervisé

Chapitre 10
Régression Linéaire et Polynomiale

10.1 Régression Linéaire Simple

■ = β0 + β1×x
On cherche β0 (intercept) et β1 (pente) qui minimisent la somme des erreurs au carré (MCO).

L(β0,β1) = (1/N) × Σ(yi - β0 - β1×xi)²

Solution analytique (forme fermée) :

β1 = Σ[(xi-x■)(yi-■)] / Σ(xi-x■)² β0 = ■ - β1×x■

10.2 Régression Linéaire Multiple

■ = β0 + β1×x1 + β2×x2 + ... + βp×xp = X·β
Solution analytique (équation normale) :

β = (X^T × X)^(-1) × X^T × y

Problème si X^T×X non inversible (multicolinéarité) → utiliser Ridge (L2) :

β_ridge = (X^T×X + λI)^(-1) × X^T × y

10.3 Hypothèses et diagnostics

■ Linéarité : vérifier via scatter plots résidus vs valeurs prédites
■ Homoscédasticité : variance des résidus constante (test Breusch-Pagan)
■ Normalité des résidus : Q-Q plot, test Shapiro-Wilk
■ Indépendance : test de Durbin-Watson pour autocorrélation
■ Multicolinéarité : VIF > 10 → problème, éliminer ou Ridge

10.4 Régression Polynomiale

■ = β0 + β1×x + β2×x² + β3×x³ + ... + βd×x^d
Toujours une régression linéaire (en les paramètres β), mais avec des features dérivées de x. Attention au
degré d : risque d'overfitting si trop élevé.

10.5 Code Scikit-learn

from sklearn.linear_model import LinearRegression, Ridge, Lasso
from [Link] import PolynomialFeatures
from [Link] import Pipeline
# Régression linéaire
model = LinearRegression()

— 13 —
COURS COMPLET — MACHINE LEARNING De zéro à expert

[Link](X_train, y_train)
y_pred = [Link](X_test)
print(f'R² = {[Link](X_test, y_test):.3f}')
# Régression polynomiale (degré 3)
pipe = Pipeline([('poly', PolynomialFeatures(degree=3)),
('lr', LinearRegression())])
[Link](X_train, y_train)

Chapitre 11
Régression Logistique

11.1 Modèle
z = β0 + β1×x1 + ... + βp×xp (combinaison linéaire)
P(y=1|X) = σ(z) = 1 / (1 + e^(-z)) (fonction sigmoïde)

11.2 Interprétation des coefficients — Odds Ratio

En régression logistique, exp(βj) est le rapport de cotes (odds ratio) :

OR_j = exp(βj) → si OR > 1 : variable augmente la proba de classe 1

11.3 Fonction de coût et entraînement

L = -(1/N) × Σ [yi×log(■i) + (1-yi)×log(1-■i)]
Pas de solution analytique → descente de gradient. Régularisation : LogisticRegression(C=1/λ) en Scikit-learn.

11.4 Extension multi-classe

■ One-vs-Rest (OvR) : K classifieurs binaires, un par classe
■ One-vs-One (OvO) : K×(K-1)/2 classifieurs
■ Softmax (multinomial) : generalisation directe, somme des probas = 1
P(y=k|X) = exp(z_k) / Σ_j exp(z_j) (Softmax)

Chapitre 12
K-Nearest Neighbors (KNN)

12.1 Algorithme
■ 1. Stocker tout le dataset d'entraînement
■ 2. Pour un nouvel exemple x, calculer sa distance à tous les exemples d'entraînement
■ 3. Identifier les K plus proches voisins
■ 4. Classification : vote majoritaire | Régression : moyenne des K sorties

12.2 Choix de K et de la distance

• K petit : frontière très complexe (overfitting, sensible au bruit)

• K grand : frontière lisse (underfitting, classe majoritaire domine)

— 14 —
 COURS COMPLET — MACHINE LEARNING De zéro à expert

• Règle pratique : K ≈ √N, toujours impair pour classification binaire

• Validation croisée : tester K ∈ {1, 3, 5, ..., 31} et choisir le meilleur

12.3 Problèmes de passage à l'échelle

Malédiction de la dimensionnalité : en haute dimension (p grand), tous les points deviennent équidistants.
KNN perd son efficacité. Solutions : PCA avant KNN, ou utiliser d'autres algorithmes.

Complexité : O(N×p) par prédiction → trop lent pour grands datasets. Solutions : KD-Tree, Ball-Tree, FAISS.

Chapitre 13
Arbres de Décision (Decision Trees)

13.1 Construction de l'arbre — Algorithme CART

CART (Classification And Regression Trees) divise récursivement les données en cherchant à chaque nœud le
meilleur split (feature + seuil).

Critère de division pour la classification :

Impureté de Gini : G = 1 - Σ p_k² (0 = nœud pur, 0.5 = max d'impureté)
Entropie : H = -Σ p_k × log2(p_k) (0 = pur, 1 = max d'impureté)
Gain d'information : IG = H(parent) - [N_g/N × H(gauche) + N_d/N × H(droite)]

Critère pour la régression :

Variance : choisir le split qui minimise la variance pondérée des sous-groupes

13.2 Hyperparamètres de contrôle

Paramètre Rôle Valeur par défaut Effet si trop grand

max_depth Profondeur max de l'arbre None (infini) Overfitting

Nb min exemples pour couper un

min_samples_split 2 Underfitting si trop grand
nœud

min_samples_leaf Nb min exemples dans une feuille 1 Underfitting si trop grand

Nb features considérées à chaque

max_features None (toutes) Moins de variance
coupure

min_impurity_decrease Gain min pour qu'un split soit fait 0.0 Underfitting si trop grand

13.3 Pruning (Élagage)

Un arbre non contraint overfitte. Le pruning réduit l'arbre après construction. Méthode principale :
Cost-Complexity Pruning (paramètre ccp_alpha en sklearn).

Chapitre 14
Méthodes d'Ensemble — Random Forest & Gradient Boosting

— 15 —
 COURS COMPLET — MACHINE LEARNING De zéro à expert

14.1 Principe des méthodes d'ensemble

Combiner plusieurs modèles faibles pour obtenir un modèle fort. Trois stratégies principales :

■ Bagging (Bootstrap Aggregating) : entraîner des modèles en parallèle sur des sous-datasets aléatoires
→ moyenner les prédictions
■ Boosting : entraîner des modèles séquentiellement, chacun corrigeant les erreurs du précédent
■ Stacking : combiner plusieurs modèles différents (meta-learner)

14.2 Random Forest

= Bagging sur des arbres de décision + randomisation des features

• Chaque arbre entraîné sur un bootstrap sample (≈63% des données, avec remise)

• À chaque nœud, seulement √p features sont considérées (pas toutes)

• Prédiction = vote majoritaire (classif) ou moyenne (régression)

• Out-of-Bag (OOB) score : évaluation gratuite sur les ≈37% non utilisés

Variance(RF) ≈ ρ × σ² + (1-ρ)/B × σ² où ρ = corr entre arbres, B = nb arbres

Plus les arbres sont décorrélés (grâce à la randomisation), plus la variance de la forêt est faible.

14.3 Gradient Boosting

Algorithme additif : on ajoute des arbres séquentiellement, chacun prédit les résidus (erreurs) du modèle
précédent.

F_m(x) = F_{m-1}(x) + α × h_m(x)

où h_m est un arbre qui prédit les pseudo-résidus : gradient de la fonction de coût par rapport aux prédictions
précédentes.

14.4 XGBoost, LightGBM, CatBoost — Les champions

Bibliothèque Innovation clé Point fort

XGBoost Régularisation L1+L2, pruning, cache-aware Très performant, robuste

LightGBM Croissance en feuilles (leaf-wise) vs niveau Très rapide, peu de mémoire

Encodage automatique des catégories, ordered

CatBoost Excellent sur données catégorielles
boosting

14.5 Code XGBoost

import xgboost as xgb
model = [Link](
n_estimators=500, # nb d'arbres
max_depth=6, # profondeur max de chaque arbre
learning_rate=0.05, # α (shrinkage)
subsample=0.8, # fraction du dataset par arbre
colsample_bytree=0.8, # fraction des features par arbre
reg_alpha=0.1, # L1
reg_lambda=1.0, # L2
eval_metric='auc',
early_stopping_rounds=50
)
[Link](X_train, y_train,
eval_set=[(X_val, y_val)], verbose=100)

— 16 —
 COURS COMPLET — MACHINE LEARNING De zéro à expert

Chapitre 15
Support Vector Machines (SVM)

15.1 Hyperplan séparateur à marge maximale

Le SVM cherche l'hyperplan qui maximise la marge entre les deux classes. Les vecteurs de support sont les
points les plus proches de la frontière.

Hyperplan : w·x + b = 0 (classification : signe de w·x + b)

Marge = 2 / ||w|| → Maximiser marge = Minimiser ||w||²
Problème dual : max Σαi - (1/2)ΣΣαiαj yi yj xi·xj s.c. αi≥0, Σαiyi=0

15.2 SVM à marge souple (Soft Margin — paramètre C)

En pratique, les données ne sont jamais parfaitement séparables. On autorise des violations de la marge avec
des variables d'écart ξi.

min (1/2)||w||² + C × Σξi s.c. yi(w·xi+b) ≥ 1 - ξi, ξi ≥ 0

C grand : peu de violations autorisées, marge étroite, risque d'overfitting. C petit : beaucoup de violations,
large marge, risque d'underfitting.

15.3 Le Kernel Trick — Transformer l'espace

Pour des données non linéairement séparables, on les projette implicitement dans un espace de dimension
supérieure via la fonction noyau K(xi, xj).

Kernel K(x, z) Hyperparamètres Usage

Linéaire x·z C Données linéairement séparables, NLP

RBF/Gaussien exp(-γ||x-z||²) C, γ Données non linéaires, image

Polynomial (x·z + r)^d C, d, r Interactions polynomiales

Sigmoïde tanh(γ x·z + r) C, γ, r Réseaux de neurones shallow

Chapitre 16
Naive Bayes

16.1 Principe
Classifieur probabiliste basé sur le théorème de Bayes avec l'hypothèse naïve que toutes les features sont
conditionnellement indépendantes.

P(C|x) ∝ P(C) × Π P(xi|C)

Classification : ■ = argmax_C P(C) × Π P(xi|C)

16.2 Variantes
Variante P(xi|C) Usage

Gaussian NB Loi normale N(µ_c, σ_c²) Features continues

— 17 —
 COURS COMPLET — MACHINE LEARNING De zéro à expert

Multinomial NB P(xi|C) = (count(xi,C)+α) / count(C) Comptage (NLP, fréquences)

Bernoulli NB P(xi=1|C) = p_ic Features binaires (présence/absence)

Complement NB Estimé depuis complémentaires Texte déséquilibré

Forces : très rapide, fonctionne bien avec peu de données, très bon pour le NLP (spam, sentiment). Limites :
l'hypothèse d'indépendance est rarement vraie.

Chapitre 17
Évaluation des Modèles Supervisés

17.1 Métriques de régression

Métrique Formule Interprétation

MAE (1/N)×Σ|yi-■i| Erreur moyenne en unités de y. Robuste aux outliers

MSE (1/N)×Σ(yi-■i)² Pénalise les grandes erreurs. Même échelle que y²

RMSE √MSE Même unité que y. Interprétable

R² 1 - SS_res/SS_tot 0-1. % de variance expliquée. 1 = parfait

MAPE (1/N)×Σ|yi-■i|/yi × 100% Erreur relative en %. Mauvais si yi proche de 0

R² ajusté 1-(1-R²)(N-1)/(N-p-1) Pénalise l'ajout de features inutiles

17.2 Métriques de classification — Matrice de confusion

Prédit Négatif Prédit Positif

Réel Négatif VN (Vrai Négatif) Correctement classé négatif FP (Faux Positif) Erreur type I — Alarme injustifiée

FN (Faux Négatif) Erreur type II — Cas

Réel Positif VP (Vrai Positif) Correctement classé positif
manqué

Accuracy = (VP+VN)/(VP+VN+FP+FN)
Precision = VP/(VP+FP) Recall (Sensibilité) = VP/(VP+FN)
F1-Score = 2×(Prec×Recall)/(Prec+Recall) = 2VP/(2VP+FP+FN)
Spécificité = VN/(VN+FP) MCC = (VP×VN-FP×FN)/√[(VP+FP)(VP+FN)(VN+FP)(VN+FN)]

17.3 AUC-ROC et AUC-PR

La courbe ROC (Receiver Operating Characteristic) trace le Recall (TPR) en fonction du taux de Faux Positifs
(FPR) pour tous les seuils possibles. AUC-ROC = aire sous la courbe (0.5 = hasard, 1 = parfait).

La courbe PR (Precision-Recall) est préférable pour les datasets très déséquilibrés. AUC-PR = aire sous la
courbe Precision vs Recall.

17.4 Validation Croisée

■ K-Fold CV : diviser en K folds, entraîner sur K-1, valider sur 1, répéter K fois

— 18 —
 COURS COMPLET — MACHINE LEARNING De zéro à expert

■ Stratified K-Fold : même proportion de classes dans chaque fold

■ Leave-One-Out (LOO) : K = N, très coûteux mais sans biais
■ Time Series Split : respecter l'ordre temporel, jamais de données futures dans train
from sklearn.model_selection import cross_val_score, StratifiedKFold
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(model, X, y, cv=cv, scoring='roc_auc')
print(f'AUC: {[Link]():.3f} ± {[Link]():.3f}')

17.5 Biais-Variance Tradeoff

Erreur totale = Biais² + Variance + Bruit irréductible

Situation Biais Variance Solution

Underfitting Élevé Faible Modèle plus complexe, plus de features

Bonne fit Faible Faible Garder ce modèle

Overfitting Faible Élevé Régulariser, plus de données, simplifier

— 19 —
 COURS COMPLET — MACHINE LEARNING De zéro à expert

PARTIE 4

Apprentissage Non Supervisé

Chapitre 18
Clustering — K-Means et DBSCAN

18.1 K-Means — Partitionner en K groupes

Algorithme :
■ 1. Choisir K et initialiser K centroïdes aléatoirement
■ 2. Assigner chaque point au centroïde le plus proche
■ 3. Recalculer les centroïdes = moyenne des points assignés
■ 4. Répéter 2-3 jusqu'à convergence (centroïdes stables)
Objectif : minimiser J = Σ_k Σ_{xi∈Ck} ||xi - µk||² (inertie)

18.2 Choisir K — Méthodes

Méthode Principe Comment l'utiliser

Elbow Method Tracer l'inertie en fonction de K Chercher le 'coude' — point d'inflexion

Mesurer cohésion vs séparation des

Silhouette Score Maximiser (entre -1 et 1)
clusters

Gap Statistic Comparer à une distribution aléatoire Choisir K où gap est maximisé

Calinski-Harabasz Ratio variance inter vs intra Maximiser

18.3 Limites de K-Means

■ Suppose des clusters sphériques et de taille similaire
■ Sensible aux outliers (qui influencent fortement les centroïdes)
■ Doit spécifier K à l'avance
■ Résultat dépend de l'initialisation (solution : K-Means++ ou plusieurs runs)

18.4 DBSCAN — Clustering basé sur la densité

DBSCAN (Density-Based Spatial Clustering of Applications with Noise) groupe les points denses ensemble et
identifie automatiquement les outliers.

Paramètres : ε (rayon de voisinage) et MinPts (nb min de points dans le voisinage)

■ Core point : ≥ MinPts points dans son ε-voisinage

■ Border point : < MinPts voisins mais dans le voisinage d'un core point
■ Noise point (outlier) : ni core ni border → labelé -1

— 20 —
 COURS COMPLET — MACHINE LEARNING De zéro à expert

■ Avantages : pas besoin de K, détecte les outliers, clusters de forme arbitraire

■ Limites : difficile en haute dimension, sensible aux paramètres ε et MinPts

Chapitre 19
Classification Hiérarchique

19.1 Approches
■ Agglomérative (bottom-up) : chaque point = un cluster, fusionner itérativement les + proches
■ Divisive (top-down) : un seul cluster au départ, diviser récursivement

19.2 Méthodes de liaison (linkage)

Linkage Distance(A,B) Effet

Single (min) min distance entre pts de A et B Chaînes longues, sensible au bruit

Complete (max) max distance entre pts de A et B Clusters compacts et sphériques

Average moyenne distances inter-clusters Compromis single/complete

Ward minimise l'augmentation d'inertie Clusters de taille similaire (souvent préféré)

Le résultat est visualisé sous forme de dendrogramme. On coupe à la hauteur souhaitée pour obtenir le
nombre de clusters désiré.

Chapitre 20
Réduction de Dimensionnalité — PCA, t-SNE, UMAP

20.1 PCA — Analyse en Composantes Principales

PCA projette les données dans un espace de dimension réduite en gardant les directions de maximum de
variance.

■ 1. Centrer les données : X_c = X - µ

■ 2. Calculer la matrice de covariance : C = (1/N) × X_c^T × X_c
■ 3. Décomposer en valeurs propres : C = V × Λ × V^T
■ 4. Trier les vecteurs propres par valeur propre décroissante
■ 5. Projeter : X_réduit = X_c × V_k (garder les k premières composantes)
Variance expliquée par la kème composante = λk / Σλi

• Visualisation : réduire à 2D ou 3D pour visualiser des données haute dimension

• Bruit : les dernières composantes capturent souvent du bruit → les éliminer

• Règle : garder les composantes qui expliquent 95% de la variance cumulée

• Limite : PCA est linéaire → ne capture pas les structures non linéaires

— 21 —
 COURS COMPLET — MACHINE LEARNING De zéro à expert

20.2 t-SNE et UMAP — Réduction non linéaire

Méthode Principe Usage Limites

Préserver voisinages locaux en Visualisation 2D/3D de Lent (O(N²)), pas reproductible, ne

t-SNE
minimisant KL divergence clusters préserve pas structure globale

Graphe de voisins + optimisation Visualisation + réduction pour Moins interprétable, paramètres

UMAP
topologique ML sensibles

Chapitre 21
Détection d'Anomalies

21.1 Définition et enjeux

Identifier des observations qui dévient significativement du comportement normal. Applications : fraude, pannes,
intrusions réseau, contrôle qualité.

21.2 Méthodes principales

Méthode Principe Force

Z-score / IQR Statistiques univariées sur chaque feature Simple, interprétable

Arbres qui isolent les anomalies en peu de

Isolation Forest Haute dimension, scalable
coupures

Local Outlier Factor Compare densité locale vs voisins Détecte outliers locaux

One-Class SVM Frontière autour des normaux Non linéaire, robuste

Autoencodeur Reconstruction — anomalie = haute erreur Données complexes

Elliptic Envelope Hypothèse gaussienne multivariée Simple si données gaussiennes

Chapitre 22
Règles d'Association (Market Basket Analysis)

22.1 Principe et métriques

Découvrir des co-occurrences fréquentes. Ex : les clients achetant X achètent souvent Y.

Support(X→Y) = P(X ∪ Y) = |X∩Y| / N

Confidence(X→Y) = P(Y|X) = Support(X∪Y) / Support(X)
Lift(X→Y) = Confidence(X→Y) / Support(Y) → >1 : association positive

22.2 Algorithme Apriori

■ 1. Trouver tous les itemsets fréquents (support ≥ min_support)
■ 2. Générer les règles d'association (confidence ≥ min_confidence)
■ 3. Filtrer par lift > 1
Propriété anti-monotone : si un itemset est infrequent, tous ses supersets le sont aussi.

— 22 —
COURS COMPLET — MACHINE LEARNING De zéro à expert

PARTIE 5

Deep Learning

Chapitre 23
Réseaux de Neurones Artificiels (ANN)

23.1 Le Neurone Artificiel

Un neurone reçoit des entrées x, les multiplie par des poids w, somme tout avec un biais b, et applique une
fonction d'activation f.

sortie = f(w1×x1 + w2×x2 + ... + wn×xn + b) = f(w·x + b)

23.2 Fonctions d'activation

Fonction Formule Avantages Inconvénients

Sigmoid 1/(1+e^(-x)) Sortie ∈(0,1), probabilité Vanishing gradient, saturation

Tanh (e^x-e^(-x))/(e^x+e^(-x)) Centré sur 0, ∈(-1,1) Vanishing gradient

ReLU max(0,x) Simple, pas de saturation + Dying ReLU (neurones morts)

Leaky ReLU max(0.01x,x) Corrige Dying ReLU Paramètre α à choisir

ELU x si x>0, α(e^x-1) sinon Sortie centrée, robuste Plus coûteuse

Meilleure en NLP
GELU x×Φ(x) Plus complexe
(Transformers)

Probas somment à 1,
Softmax e^xi/Σe^xj Sortie seulement
multi-classe

23.3 Architecture MLP (Multi-Layer Perceptron)

■ Couche d'entrée : p neurones (un par feature)
■ Couches cachées : transformations non-linéaires successives
■ Couche de sortie : 1 neurone (régression), 1 (classif binaire), K (multi-classe)
Un MLP avec au moins une couche cachée est un approximateur universel : il peut approximer n'importe
quelle fonction continue (théorème de Cybenko, 1989).

Chapitre 24
Rétropropagation et Optimiseurs

— 23 —
 COURS COMPLET — MACHINE LEARNING De zéro à expert

24.1 Rétropropagation (Backpropagation)

Algorithme de calcul efficace des gradients via la règle de dérivation en chaîne.

∂L/∂wi = ∂L/∂■ × ∂■/∂zi × ∂zi/∂wi (règle de la chaîne)

■ 1. Forward pass : calculer les activations couche par couche
■ 2. Calculer la loss
■ 3. Backward pass : propager les gradients de la sortie vers l'entrée
■ 4. Mettre à jour les poids avec l'optimiseur

24.2 Optimiseurs avancés

Optimiseur Mise à jour Force

SGD θ -= α × ∇L Simple, bien compris

SGD+Momentum v = β×v + ∇L; θ -= α×v Accélère convergence, traverse les plateaux

RMSprop v = β×v²+(1-β)×∇L²; θ -= α/√v × ∇L Adapte lr par paramètre

Adam Combine Momentum + RMSprop Standard en deep learning, robuste

AdaGrad θ -= α/√(Σ∇²) × ∇L Bon pour features sparse (NLP)

AdamW Adam + weight decay découplé Meilleur en NLP/Transformers

LAMB Adam avec normalisation par couche Grands batch sizes (BERT)

24.3 Techniques de régularisation en Deep Learning

Technique Principe Paramètre

Désactiver p% des neurones aléatoirement à

Dropout p (taux de dropout, ex: 0.3)
chaque batch

Batch Norm Normaliser les activations de chaque couche momentum, epsilon

Layer Norm Normaliser sur les features (pour Transformers) epsilon

Weight Decay Pénalité L2 sur les poids (via optimiseur) λ (weight_decay)

Early Stopping Arrêter si val_loss ne s'améliore plus patience (nb d'epochs)

Data Augmentation Créer des variantes artificielles des données transforms spécifiques

Label Smoothing Remplacer 0/1 par ε/(K-1) / 1-ε ε (ex: 0.1)

Chapitre 25
Réseaux de Neurones Convolutifs (CNN)

25.1 Motivation — Exploiter la structure spatiale

Un MLP appliqué à une image 224×224 RGB nécessiterait 224×224×3 = 150 528 neurones d'entrée, avec des
connexions complètes → explosion paramétrique. Les CNN exploitent la localité, la translation-invariance et
le partage de paramètres.

25.2 Opérations fondamentales

— 24 —
 COURS COMPLET — MACHINE LEARNING De zéro à expert

Convolution :
(I * K)(i,j) = Σ_m Σ_n I(i+m, j+n) × K(m,n)
Un filtre K de taille f×f glisse sur l'image I et produit une feature map. Le réseau apprend les filtres (détecteurs
de bords, textures, etc.).

Pooling : réduire la taille spatiale, conserver les features importantes

■ Max Pooling : prendre le maximum dans chaque région (preserve features saillantes)
■ Average Pooling : moyenne (préserve l'information diffuse)
■ Global Average Pooling : une valeur par feature map (avant la couche de classif)

25.3 Architectures emblématiques

Architecture Année Innovation Performance

LeNet-5 1998 Premier CNN pratique (digits) MNIST ~99%

AlexNet 2012 ReLU, Dropout, GPU — révolution ImageNet top-5 : 15.3%

VGG-16/19 2014 Filtres 3×3, profondeur uniforme ImageNet top-5 : 7.3%

GoogLeNet 2014 Module Inception, profondeur/largeur ImageNet : 6.7%

Skip connections → 152 couches sans

ResNet-50 2015 ImageNet : 3.57%
dégradation

EfficientNet 2019 Scaling uniforme profondeur/largeur/résolution SOTA efficace

ViT 2020 Vision Transformer — pas de convolution SOTA avec bcp de données

25.4 Transfer Learning

Réutiliser un CNN pré-entraîné sur ImageNet (ResNet, EfficientNet...) pour une nouvelle tâche. Économise
temps et données.
import [Link] as models
import [Link] as nn
# Charger ResNet50 pré-entraîné
model = models.resnet50(pretrained=True)
# Geler les couches existantes
for param in [Link]():
param.requires_grad = False
# Remplacer la couche finale pour notre tâche
[Link] = [Link](2048, num_classes)

Chapitre 26
Réseaux Récurrents — RNN, LSTM, GRU

26.1 RNN — Mémoire à court terme

Les RNN traitent des séquences en maintenant un état caché h_t qui transmet l'information entre les pas de
temps.
h_t = tanh(W_h × h_{t-1} + W_x × x_t + b_h)
■_t = W_y × h_t + b_y
Problème : vanishing gradient — les gradients disparaissent sur les longues séquences → impossible
d'apprendre des dépendances à long terme.

— 25 —
COURS COMPLET — MACHINE LEARNING De zéro à expert

26.2 LSTM — Long Short-Term Memory

Solution au vanishing gradient via des portes (gates) qui contrôlent le flux d'information. Deux états : h_t (court
terme) et c_t (long terme).

Porte d'oubli : f_t = σ(W_f × [h_{t-1}, x_t] + b_f) → quoi oublier de c_{t-1}
Porte d'entrée : i_t = σ(W_i × [h_{t-1}, x_t] + b_i) → quoi ajouter
Candidat : c■_t = tanh(W_c × [h_{t-1}, x_t] + b_c)
État cellule : c_t = f_t ■ c_{t-1} + i_t ■ c■_t
Porte sortie : o_t = σ(W_o × [h_{t-1}, x_t] + b_o) ; h_t = o_t ■ tanh(c_t)

26.3 GRU — Gated Recurrent Unit

Variante simplifiée du LSTM avec seulement 2 portes (reset et update). Moins de paramètres, souvent aussi
performant.

z_t = σ(W_z × [h_{t-1}, x_t]) (update gate)

r_t = σ(W_r × [h_{t-1}, x_t]) (reset gate)
h■_t = tanh(W × [r_t ■ h_{t-1}, x_t])
h_t = (1-z_t) ■ h_{t-1} + z_t ■ h■_t

Chapitre 27
Transformers et Mécanisme d'Attention

27.1 Révolution des Transformers (2017)

L'article «Attention is All You Need» (Vaswani et al., 2017) a révolutionné le NLP et maintenant la vision, l'audio,
la biologie. Les Transformers remplacent les RNN grâce au mécanisme d'auto-attention qui traite toute la
séquence en parallèle.

27.2 Scaled Dot-Product Attention

Attention(Q, K, V) = softmax(Q × K^T / √d_k) × V
Q (Query), K (Key), V (Value) sont des projections linéaires de l'entrée. √d_k est un facteur d'échelle pour
stabiliser le gradient.

27.3 Multi-Head Attention

MultiHead(Q,K,V) = Concat(head_1, ..., head_h) × W_O
head_i = Attention(Q×W_i^Q, K×W_i^K, V×W_i^V)
H têtes d'attention capturent différents types de relations (syntaxe, sémantique, coréférence...).

27.4 Architecture Transformer complète

■ Encodeur : N × (Multi-Head Self-Attention + FFN + LayerNorm + Résiduel)
■ Décodeur : N × (Masked Self-Attention + Cross-Attention + FFN + LayerNorm)
■ Positional Encoding : sin/cos pour encoder la position des tokens

27.5 Modèles emblématiques

— 26 —
 COURS COMPLET — MACHINE LEARNING De zéro à expert

Modèle Orga. Innovation Usage

BERT Google Encodeur bidirectionnel, MLM + NSP Classification, NER, QA

GPT-3/4 OpenAI Décodeur, 175B params, few-shot Génération, completion

T5 Google Text-to-Text unifié Toutes tâches NLP

RoBERTa Meta BERT mieux entraîné Classification texte

ViT Google Transformers pour images Classification image

CLIP OpenAI Image+Texte conjoint Recherche image, zero-shot

LLaMA 3 Meta Open source, efficace Foundation model local

Chapitre 28
Autoencodeurs et GANs

28.1 Autoencodeur (AE)

Architecture encodeur-décodeur qui apprend à compresser puis reconstruire les données. La couche centrale
(espace latent z) est une représentation compressée.

Encodeur : z = f_enc(x) (compression : R^p → R^k, k << p)

Décodeur : x■ = f_dec(z) (reconstruction : R^k → R^p)
L = ||x - x■||² (erreur de reconstruction)
■ Débruitage (DAE) : corrompre l'entrée, apprendre à la reconstruire propre
■ Sparse AE : pénaliser l'activation des neurones latents
■ VAE (Variationnel) : espace latent = distribution gaussienne → génératif

28.2 GAN — Generative Adversarial Network

Deux réseaux en compétition : un générateur G crée de fausses données, un discriminateur D essaie de
distinguer vrai et faux.

min_G max_D E[log D(x)] + E[log(1 - D(G(z)))]

Applications : génération d'images, super-résolution, deepfakes, augmentation de données.

Variante GAN Innovation

DCGAN GAN avec CNN (images réalistes)

WGAN Distance Wasserstein → entraînement plus stable

StyleGAN2 Contrôle du style à chaque résolution → visages photo-réalistes

CycleGAN Traduction image-à-image sans paires (photos → peintures Monet)

Pix2Pix Traduction conditionnelle avec paires supervisées

Diffusion Models (DALL-E 2, Stable Diffusion) — successeurs des GANs pour la génération

— 27 —
 COURS COMPLET — MACHINE LEARNING De zéro à expert

PARTIE 6

Apprentissage par Renforcement

Chapitre 29
Principes du Reinforcement Learning

29.1 Le cadre MDP (Markov Decision Process)

L'apprentissage par renforcement (RL) modélise un agent qui interagit avec un environnement pour maximiser
une récompense cumulée.

Composant Symbole Description

État s∈S Observation de l'environnement à l'instant t

Action a∈A Ce que l'agent fait (mouvement, décision, prix)

Récompense r_t Signal de feedback de l'environnement (peut être -)

Transition P(s'|s,a) Probabilité de passer à l'état s' en faisant a depuis s

Politique π(a|s) Stratégie de l'agent : probabilité d'action a dans état s

Retour G_t Récompense cumulée actualisée depuis t

Facteur γ γ ∈[0,1] Discount factor : pondération des récompenses futures

G_t = r_t + γ×r_{t+1} + γ²×r_{t+2} + ... = Σ_{k=0}^∞ γ^k × r_{t+k}

29.2 Fonctions de valeur

V^π(s) = E_π[G_t | S_t=s] (valeur d'un état sous la politique π)
Q^π(s,a) = E_π[G_t | S_t=s, A_t=a] (valeur d'un état-action)
Équation de Bellman : V^π(s) = Σ_a π(a|s) × Σ_{s'} P(s'|s,a) [r + γ V^π(s')]

Chapitre 30
Q-Learning et Deep Q-Network (DQN)

30.1 Q-Learning (Tabular)

Algorithme off-policy qui apprend la fonction Q* (optimale) sans connaître le modèle :

Q(s,a) ← Q(s,a) + α × [r + γ × max_{a'} Q(s',a') - Q(s,a)]

Le terme entre crochets est l'erreur TD (Temporal Difference). Politique optimale : π*(s) = argmax_a Q*(s,a).

— 28 —
 COURS COMPLET — MACHINE LEARNING De zéro à expert

30.2 Deep Q-Network (DQN — DeepMind 2013)

Remplacer la table Q par un réseau de neurones Q(s,a;θ). Innovations clés pour stabiliser l'entraînement :

■ Experience Replay : stocker les transitions dans un buffer, tirer aléatoirement

■ Target Network : réseau cible θ■ mis à jour périodiquement pour calculer les cibles
■ Clipping des récompenses : normaliser les récompenses pour la stabilité
L(θ) = E[(r + γ × max_{a'} Q(s',a';θ■) - Q(s,a;θ))²]

Chapitre 31
Policy Gradient et Actor-Critic

31.1 Policy Gradient (REINFORCE)

Optimiser directement la politique π_θ par gradient ascent sur l'espérance de retour :

∇_θ J(θ) = E[Σ_t ∇_θ log π_θ(a_t|s_t) × G_t]

Problème : haute variance → utiliser une baseline (ex: V(s)) pour réduire la variance.

31.2 Actor-Critic (A2C, A3C, PPO)

Deux réseaux : l'acteur (politique π) et le critique (valeur V). Le critique évalue les actions, l'acteur s'améliore
grâce à ce feedback.

Avantage : A(s,a) = Q(s,a) - V(s) = r + γ V(s') - V(s) (erreur TD)

31.3 Algorithmes RL modernes

Algo Type Innovation Usage

A3C Actor-Critic Asynchronous (workers parallèles) Jeux Atari

PPO Actor-Critic Proximal Policy Optimization — clip du ratio Standard en RL pratique

SAC Actor-Critic Maximum entropy RL — exploration robuste Robotique, continuous control

TD3 Actor-Critic Twin Q-networks, delayed updates Contrôle continu

AlphaGo/Zero MCTS+RL Self-play + Monte Carlo Tree Search Go, Échecs, Shogi

Dreamer Model-based Apprendre un modèle monde latent Sim-to-real, robotique

— 29 —
COURS COMPLET — MACHINE LEARNING De zéro à expert

PARTIE 7

MLOps & Pratique — Du Labo à la Production

Chapitre 32
Pipeline ML Complet avec Scikit-learn

32.1 Architecture d'un projet ML

1. Définition du problème : Métrique cible, contraintes métier, données disponibles

2. Collecte des données : Sources internes, APIs, scraping, datasets publics

3. EDA : Exploration, visualisation, hypothèses

4. Prétraitement : Nettoyage, encodage, normalisation

5. Feature Engineering : Nouvelles variables, sélection

6. Modélisation : Baseline → modèles avancés → ensemble

7. Évaluation : CV, métriques, analyse des erreurs

8. Hyperparameter Tuning : Grid search, Random search, Bayesian

9. Test final : Évaluation sur test set (une seule fois !)

10. Déploiement : API, monitoring, retrain

32.2 Pipeline Scikit-learn

from [Link] import Pipeline
from [Link] import ColumnTransformer
from [Link] import StandardScaler, OneHotEncoder
from [Link] import SimpleImputer
from [Link] import RandomForestClassifier
from sklearn.model_selection import train_test_split, cross_val_score
# Définir les colonnes
num_features = ['age', 'revenu', 'solde']
cat_features = ['profession', 'pays']
# Transformer numériques
num_pipe = Pipeline([
('imputer', SimpleImputer(strategy='median')),
('scaler', StandardScaler())
])
# Transformer catégoriels
cat_pipe = Pipeline([
('imputer', SimpleImputer(strategy='most_frequent')),
('encoder', OneHotEncoder(handle_unknown='ignore'))
])

— 30 —
 COURS COMPLET — MACHINE LEARNING De zéro à expert

# Combiner
preprocessor = ColumnTransformer([
('num', num_pipe, num_features),
('cat', cat_pipe, cat_features)
])
# Pipeline complet
full_pipe = Pipeline([
('prep', preprocessor),
('model', RandomForestClassifier(n_estimators=200, random_state=42))
])
# Entraînement et évaluation
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, stratify=y, random_state=42)
full_pipe.fit(X_train, y_train)
scores = cross_val_score(full_pipe, X_train, y_train,
cv=5, scoring='roc_auc')
print(f'CV AUC: {[Link]():.3f} ± {[Link]():.3f}')

Chapitre 33
Hyperparameter Tuning

33.1 Stratégies de recherche

Méthode Principe Quand l'utiliser Bibliothèque

Grid Search Tester toutes les combinaisons Peu de paramètres, espace small [Link]

Tirer aléatoirement N
Random Search Standard — bon rapport coût/perf [Link]
combinaisons

Bayesian Optim. Modèle probabiliste de la perf. Optimisation coûteuse (DL, XGB) Optuna, Hyperopt, BayesOpt

Early stopping des configs Grand espace, ressources

Hyperband Ray Tune, Keras Tuner
prometteuses limitées

Évolution de population de
Population Based Very large scale training PBT (DeepMind)
configs

33.2 Optuna — Exemple Bayesian Optimization

import optuna
from [Link] import GradientBoostingClassifier
from sklearn.model_selection import cross_val_score
def objective(trial):
params = {
'n_estimators': trial.suggest_int('n_estimators', 50, 500),
'max_depth': trial.suggest_int('max_depth', 3, 10),
'learning_rate': trial.suggest_float('lr', 1e-3, 0.3, log=True),
'subsample': trial.suggest_float('subsample', 0.5, 1.0),
}
clf = GradientBoostingClassifier(**params, random_state=42)
score = cross_val_score(clf, X_train, y_train,
cv=3, scoring='roc_auc').mean()
return score
study = optuna.create_study(direction='maximize')
[Link](objective, n_trials=100)
print(f'Best AUC: {study.best_value:.3f}')
print(f'Best params: {study.best_params}')

Chapitre 34
Déploiement de Modèles en Production

— 31 —
 COURS COMPLET — MACHINE LEARNING De zéro à expert

34.1 Sérialisation et format de modèle

Format Usage Code

Pickle (.pkl) Sklearn, Python natif import pickle; [Link](model, f)

Joblib (.joblib) Sklearn (large arrays) [Link](model, '[Link]')

ONNX Multi-framework, production [Link](model, ...)

TensorFlow
TF Serving, TFLite [Link]('model_dir/')
SavedModel

TorchScript PyTorch production [Link](model)

MLflow Tracking + serving multi-FW [Link].log_model(model)

34.2 Déploiement via API REST (FastAPI)

from fastapi import FastAPI
from pydantic import BaseModel
import joblib, numpy as np
app = FastAPI()
model = [Link]('[Link]')
class InputData(BaseModel):
age: float
revenu: float
solde: float
@[Link]('/predict')
def predict(data: InputData):
X = [Link]([[[Link], [Link], [Link]]])
proba = model.predict_proba(X)[0, 1]
return {'probabilite_defaut': float(proba),
'decision': 'REFUS' if proba > 0.5 else 'ACCORD'}
# Lancer : uvicorn app:app --host [Link] --port 8000

34.3 Monitoring en production

■ Data drift : les données de production s'écartent des données d'entraînement
■ Concept drift : la relation X→y change dans le temps (ex: comportements COVID)
■ Métriques business : toujours monitorer l'impact réel (pas seulement les métriques ML)
■ Outils : Evidently AI, Alibi Detect, Grafana + Prometheus, MLflow
■ Retraining schedule : périodique (hebdo/mensuel) ou déclenché par drift

Chapitre 35
Éthique, Explicabilité et Biais en ML

35.1 Les biais en ML — Sources et types

Type de biais Description Exemple

Biais présents dans les données Moins de femmes aux postes tech dans les données → modèle
Historical bias
historiques discriminant

Dataset médical avec 90% caucasiens → modèle moins précis pour

Representation bias Sous-représentation d'un groupe
autres

Measurement bias Mesure erronée d'une variable Reconnaissance faciale moins précise sur peaux foncées

— 32 —
 COURS COMPLET — MACHINE LEARNING De zéro à expert

Modèle unique pour groupes

Aggregation bias Même seuil de risque diabète pour différentes populations
hétérogènes

Evaluation bias Métriques inadaptées au problème Accuracy sur dataset déséquilibré → illusion de performance

Modèle policier → + de patrouilles → + d'arrestations →

Feedback loop Le modèle crée les données futures
confirmation

35.2 Métriques de fairness

Demographic Parity : P(■=1 | G=A) = P(■=1 | G=B)
Equal Opportunity : P(■=1 | y=1, G=A) = P(■=1 | y=1, G=B)
Individual Fairness : similar(xi, xj) → similar(f(xi), f(xj))
Outils : Fairlearn (Microsoft), IBM AI Fairness 360, What-If Tool (Google)

35.3 Explicabilité (XAI — Explainable AI)

Méthode Type Principe Avantages

SHAP (SHapley Additive Contribution de chaque feature à la

Global+Local Fidèle, cohérent, toutes features
exPlanations) prédiction (théorie des jeux)

LIME (Local Interpretable

Local Approx. linéaire locale du modèle Simple, toutes features
ME)

Gradient de la class par rapport aux

Grad-CAM Local (CNN) Visualise où le CNN regarde
activations

Feature Importance Global Gain moyen d'un feature dans les splits Rapide, intégrée aux arbres

Effet moyen d'une feature sur la

Partial Dependence Global Intuitive, courbe 1D ou 2D
prédiction

'Que faudrait-il changer pour changer la

Counterfactual Local Actionnable, RGPD art.22
décision ?'

35.4 Réglementations et cadre légal

■ RGPD (Europe) : droit à l'explication pour les décisions automatisées (art. 22)
■ AI Act (Europe 2024) : classification par risque, obligations selon le niveau
■ Bâle III/IV : modèles de risque bancaire doivent être validés et explicables
■ Equal Credit Opportunity Act (USA) : interdiction de discrimination dans le crédit

35.5 Checklist éthique avant déploiement

■ ■ Dataset représentatif de la population cible ?
■ ■ Variables proxy discriminatoires exclues (code postal ≈ origine ethnique) ?
■ ■ Performances comparées entre sous-groupes démographiques ?
■ ■ Mécanisme d'appel humain prévu pour les décisions automatisées ?
■ ■ Documentation complète (Model Card, Datasheet for Datasets) ?
■ ■ Tests adversariaux réalisés (que se passe-t-il avec des inputs extrêmes) ?
■ ■ Politique de retrait du modèle définie en cas de problème ?
■ ■ Consentement des utilisateurs pour l'utilisation de leurs données ?

— 33 —
COURS COMPLET — MACHINE LEARNING De zéro à expert

■ CONCLUSION

Vous avez parcouru l'ensemble du paysage du Machine Learning : des fondements mathématiques aux
modèles les plus avancés, des données brutes au déploiement en production. Le ML est un domaine en
évolution permanente — restez curieux, pratiquez sur des projets réels (Kaggle, projets personnels), et ne
perdez jamais de vue l'impact humain de vos modèles.

Voie recommandée :

1. Maîtriser Python + NumPy + Pandas + Matplotlib

2. Scikit-learn : tous les algorithmes classiques

3. Un projet de bout en bout (Kaggle ou dataset réel)

4. PyTorch ou TensorFlow pour le Deep Learning

5. Spécialisation (NLP, Vision, RL, Time Series) selon vos intérêts

6. MLOps : déploiement, monitoring, reproductibilité

— 34 —