Apprentissage supervisé

L'apprentissage supervisé est la forme la plus courante de Machine Learning. On fournit au modèle des exemples avec leurs réponses attendues (labels), et il apprend à prédire les labels pour de nouvelles données.

Principe

┌─────────────────────────────────────────────────────────┐
│                 APPRENTISSAGE SUPERVISÉ                  │
├─────────────────────────────────────────────────────────┤
│                                                          │
│   Entrée (X)              Label (Y)                     │
│   ──────────              ─────────                     │
│   [Image chat]     →      "chat"                        │
│   [Image chien]    →      "chien"                       │
│   [Prix, Surface]  →      350000€                       │
│                                                          │
│   Le modèle apprend la fonction : Y = f(X)              │
│                                                          │
└─────────────────────────────────────────────────────────┘

On appelle ça "supervisé" car on supervise l'apprentissage en donnant les bonnes réponses.

Deux types de problèmes

Classification

Prédire une catégorie parmi un ensemble fini.

Classification binaire :

Email → Spam / Non-spam
Transaction → Fraude / Légitime
Test médical → Positif / Négatif

Classification multiclasse :

Image → Chat / Chien / Oiseau / ...
Document → Sport / Politique / Économie / ...
Sentiment → Positif / Neutre / Négatif

Régression

Prédire une valeur numérique continue.

Caractéristiques maison → Prix (€)
Données patient → Durée hospitalisation (jours)
Historique ventes → Ventes futures (unités)

Algorithmes de classification

Régression logistique

Malgré son nom, c'est un algorithme de classification. Il calcule la probabilité d'appartenance à une classe.

from sklearn.linear_model import LogisticRegression

model = LogisticRegression()
model.fit(X_train, y_train)
predictions = model.predict(X_test)
probabilities = model.predict_proba(X_test)

Avantages :

Simple et interprétable
Rapide à entraîner
Donne des probabilités

Limites :

Suppose une relation linéaire
Peu performant sur des problèmes complexes

Arbres de décision

Série de questions binaires pour arriver à une décision.

                    Revenu > 50k ?
                    /           \
                  Oui           Non
                  /               \
            Âge > 30 ?        Emploi stable ?
            /      \           /        \
          Oui     Non        Oui        Non
           |       |          |          |
        Crédit   Crédit    Crédit     Crédit
        Accordé  Refusé    Accordé    Refusé

from sklearn.tree import DecisionTreeClassifier

model = DecisionTreeClassifier(max_depth=5)
model.fit(X_train, y_train)

Avantages :

Très interprétable
Gère les variables catégorielles
Pas besoin de normalisation

Limites :

Tendance au surapprentissage
Instable (petits changements = arbre différent)

Random Forest

Ensemble de nombreux arbres de décision qui votent.

       Arbre 1    Arbre 2    Arbre 3    ...    Arbre N
          ↓          ↓          ↓                 ↓
        Chat       Chien      Chat              Chat
                      ↓
              Vote majoritaire
                      ↓
                    CHAT

from sklearn.ensemble import RandomForestClassifier

model = RandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train)

Avantages :

Très performant
Robuste au surapprentissage
Gère bien les données manquantes

Limites :

Moins interprétable
Plus lent à entraîner

Gradient Boosting (XGBoost, LightGBM)

Arbres entraînés séquentiellement, chacun corrigeant les erreurs du précédent.

from xgboost import XGBClassifier

model = XGBClassifier(n_estimators=100, learning_rate=0.1)
model.fit(X_train, y_train)

Avantages :

Souvent le plus performant
Gère bien les données déséquilibrées
Régularisation intégrée

Limites :

Plus de paramètres à tuner
Risque de surapprentissage

Support Vector Machine (SVM)

Trouve l'hyperplan qui sépare au mieux les classes.

    Classe A: ●●●●●
                    \
                     -------- Hyperplan optimal
                    /
    Classe B: ○○○○○

from sklearn.svm import SVC

model = SVC(kernel='rbf', C=1.0)
model.fit(X_train, y_train)

Avantages :

Efficace en haute dimension
Fonctionne bien avec peu de données

Limites :

Lent sur grands datasets
Sensible au scaling

k-Nearest Neighbors (k-NN)

Classe un point selon ses k voisins les plus proches.

    ? = point à classifier

    ●●●   ●
      ● ? ○
        ○○○

    Si k=3 : 2 ● et 1 ○ → Classe ●

from sklearn.neighbors import KNeighborsClassifier

model = KNeighborsClassifier(n_neighbors=5)
model.fit(X_train, y_train)

Avantages :

Simple, pas d'entraînement
Naturellement multiclasse

Limites :

Lent en inférence (compare à tous les points)
Sensible aux dimensions

Algorithmes de régression

Régression linéaire

Trouve la droite (ou hyperplan) qui minimise l'erreur.

    Prix
      │     ●
      │   ●   ────── Droite de régression
      │ ●   ●
      │●  ●
      └────────────── Surface

from sklearn.linear_model import LinearRegression

model = LinearRegression()
model.fit(X_train, y_train)
predictions = model.predict(X_test)

Formule : y = β₀ + β₁x₁ + β₂x₂ + ... + βₙxₙ

Régression polynomiale

Régression linéaire avec des termes polynomiaux.

from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression

poly = PolynomialFeatures(degree=2)
X_poly = poly.fit_transform(X)

model = LinearRegression()
model.fit(X_poly, y)

Régression Ridge et Lasso

Régression linéaire avec régularisation pour éviter le surapprentissage.

from sklearn.linear_model import Ridge, Lasso

# Ridge (L2) : pénalise les grands coefficients
ridge = Ridge(alpha=1.0)

# Lasso (L1) : peut mettre des coefficients à zéro (sélection de features)
lasso = Lasso(alpha=1.0)

Métriques d'évaluation

Pour la classification

Matrice de confusion

                    Prédit
                  Pos    Neg
              ┌───────┬───────┐
    Réel Pos  │  TP   │  FN   │
              ├───────┼───────┤
    Réel Neg  │  FP   │  TN   │
              └───────┴───────┘

TP = True Positive (bien classé positif)
TN = True Negative (bien classé négatif)
FP = False Positive (faux positif)
FN = False Negative (faux négatif)

Métriques dérivées

Métrique	Formule	Interprétation
Accuracy	(TP+TN) / Total	% de bonnes prédictions
Precision	TP / (TP+FP)	Fiabilité des positifs prédits
Recall	TP / (TP+FN)	Couverture des vrais positifs
F1-Score	2 × (P×R)/(P+R)	Équilibre precision/recall

L'accuracy peut être trompeuse sur des données déséquilibrées. Préférez le F1-score ou l'AUC-ROC.

Pour la régression

Métrique	Formule	Interprétation
MAE	Moyenne(\|y - ŷ\|)	Erreur moyenne en valeur absolue
MSE	Moyenne((y - ŷ)²)	Pénalise plus les grandes erreurs
RMSE	√MSE	Même unité que y
R²	1 - (SS_res/SS_tot)	% de variance expliquée (0 à 1)

Exemple complet

import pandas as pd
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, confusion_matrix

# 1. Charger les données
df = pd.read_csv('data.csv')
X = df.drop('target', axis=1)
y = df['target']

# 2. Split train/test
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 3. Normalisation
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 4. Entraînement
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train_scaled, y_train)

# 5. Validation croisée
cv_scores = cross_val_score(model, X_train_scaled, y_train, cv=5)
print(f"CV Score: {cv_scores.mean():.3f} (+/- {cv_scores.std()*2:.3f})")

# 6. Évaluation finale
y_pred = model.predict(X_test_scaled)
print(classification_report(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))

Choisir le bon algorithme

                    Interprétabilité importante ?
                           /            \
                         Oui            Non
                         /                \
            Régression logistique    Données volumineuses ?
            ou Arbre de décision         /          \
                                       Oui          Non
                                       /              \
                               Gradient Boosting    Random Forest
                               (XGBoost/LightGBM)   ou SVM

Apprentissage supervisé

On this page