Objectifs d'Apprentissage
À la fin de ce module, vous serez capable de :
- Différencier classification binaire, multi-classe et multi-label.
- Implémenter 4 algorithmes majeurs : Régression Logistique, Arbres de Décision, Forêts Aléatoires, Gradient Boosting.
- Évaluer vos modèles avec les bonnes métriques : Accuracy, Precision, Recall, F1, ROC-AUC.
- Interpréter une matrice de confusion.
- Construire un modèle complet sur le dataset réel "Titanic".
- Gérer les données déséquilibrées.
- Ajuster le seuil de décision pour optimiser la métrique désirée.
4.1 - Qu'est-ce que la Classification ?
Définition
La classification est une technique de Machine Learning pour prédire une catégorie (classe) à partir de variables d'entrée (features).
Clé : Contrairement à la régression (prédire un nombre : prix, température), la classification prédit une catégorie discrète : oui/non, spam/légitime, survit/ne survit pas.
Types de Classification
1️⃣ Classification Binaire
2 classes seulement (la plus courante).
Exemples :
- Email : Spam / Non-spam
- Client : Fidèle / À risque (churn)
- Titanic : Survit / Ne survit pas
- Crédit : Approuvé / Rejeté
2️⃣ Classification Multi-classe
Plus de 2 classes.
Exemples :
- Fruit : Pomme / Banane / Orange
- Iris : Setosa / Versicolor / Virginica
- Sentiment : Positif / Négatif / Neutre
- Maladie : Cancer type A / B / C
3️⃣ Classification Multi-label
Un exemple peut avoir plusieurs labels.
Exemples :
- Film : [Action, Aventure, Drame]
- Article : [Politique, Économie, Technologie]
- Image : [Chat, Intérieur, Jour]
Classification vs Régression
| Aspect |
Classification |
Régression |
| Output |
Catégorie (discret) |
Nombre (continu) |
| Équation |
Frontière de décision |
Ligne/Courbe |
| Exemples |
Spam/Non-spam, Chat/Chien |
Prix, Température, Salaire |
| Métriques |
Accuracy, Precision, Recall, F1, ROC-AUC |
RMSE, R², MAE |
4.2 - Régression Logistique
Concept Mathématique
La Régression Logistique utilise la fonction sigmoid pour transformer une sortie linéaire en probabilité entre 0 et 1.
Équation :
P(y=1) = 1 / (1 + e^(-z))
Où z = b₀ + b₁·x₁ + b₂·x₂ + ...
Interprétation :
• P(y=1) > 0.5 → Prédire classe 1
• P(y=1) ≤ 0.5 → Prédire classe 0
Avantages et Inconvénients
✓ Avantages :
- Simple et rapide
- Donne les probabilités (pas seulement 0/1)
- Interprétable
- Peu de paramètres à tuner
✗ Inconvénients :
- Assume une relation linéaire
- Performance limitée pour patterns complexes
📝 Exemple Python : Régression Logistique
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
# Charger Iris (Binaire pour l'exemple)
iris = load_iris()
X, y = iris.data, (iris.target == 0).astype(int)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
# Entraîner
model = LogisticRegression(random_state=42, max_iter=1000)
model.fit(X_train, y_train)
# Prédire
y_pred = model.predict(X_test)
probs = model.predict_proba(X_test)
print(f"Accuracy : {accuracy_score(y_test, y_pred):.2%}")
print(f"Probabilités :\n{probs[:5]}")
Accuracy : 96.67%
Probabilités :
[[0.02 0.98]
[0.89 0.11]
[0.15 0.85]
[0.91 0.09]
[0.05 0.95]]
4.3 - Matrice de Confusion et Métriques
Matrice de Confusion (Classification Binaire)
Prédiction
Positif Négatif
Réal Positif TP FN
Négatif FP TN
TP = True Positive (correctement prédit positif)
FP = False Positive (incorrectement prédit positif)
FN = False Negative (incorrectement prédit négatif)
TN = True Negative (correctement prédit négatif)
Les 4 Métriques Essentielles
1️⃣ Accuracy (Exactitude)
Formule :
Accuracy = (TP + TN) / (TP + TN + FP + FN)
Interprétation : % de prédictions correctes
Exemple : 95% des prédictions sont exactes
⚠️ Quand l'utiliser :
- ✓ Quand les classes sont équilibrées
- ✗ Quand les classes sont déséquilibrées
2️⃣ Precision (Précision)
Formule :
Precision = TP / (TP + FP)
Interprétation : Parmi les positifs prédits, combien sont vrais?
Exemple : 90% des emails classés "spam" sont vraiment spam
Quand l'utiliser :
- ✓ Quand les FP sont chers (ex: diagnostic médical)
- ✓ Contrôle de qualité, spam detection
3️⃣ Recall (Rappel/Sensibilité)
Formule :
Recall = TP / (TP + FN)
Interprétation : Parmi les vrais positifs, combien détectés?
Exemple : 85% des vrais spams sont détectés
Quand l'utiliser :
- ✓ Quand les FN sont chers (ex: maladies graves)
- ✓ Détection fraude, détection maladies
4️⃣ F1 Score
Formule :
F1 = 2 × (Precision × Recall) / (Precision + Recall)
Interprétation : Moyenne harmonique de Precision et Recall
Exemple : 0.87 = bon équilibre
Quand l'utiliser :
- ✓ Quand les classes sont déséquilibrées
- ✓ Quand besoin d'équilibre Precision/Recall
Tableau Récapitulatif des 4 Métriques
| Métrique |
Formule |
Cas d'Usage |
Interprétation |
| Accuracy |
(TP+TN)/(Total) |
Classes équilibrées |
% correct global |
| Precision |
TP/(TP+FP) |
FP chers |
Qualité des prédictions + |
| Recall |
TP/(TP+FN) |
FN chers |
% vrais + détectés |
| F1 Score |
2×(P×R)/(P+R) |
Classes déséquilibrées |
Équilibre P & R |
ROC-AUC (Receiver Operating Characteristic)
AUC = Area Under the Curve
Mesure la capacité du modèle à discriminer entre les 2 classes.
- AUC = 1.0 : Discrimination parfaite
- AUC = 0.9 : Excellent
- AUC = 0.8 : Bon
- AUC = 0.7 : Acceptable
- AUC = 0.5 : Pas mieux qu'aléatoire
- AUC = 0.0 : Pire qu'aléatoire (inverse)
4.4 - Arbres de Décision & Forêts Aléatoires
Arbres de Décision pour la Classification
Un arbre de décision divise l'espace des features en régions de décision binaires. Pour la classification, l'arbre prédit la classe majoritaire dans chaque feuille.
✓ Avantages :
- Très facile à interpréter et visualiser
- Pas besoin de normalisation
- Gère bien les interactions
✗ Inconvénients :
- Tendance à l'overfitting
- Sensible aux petits changements
Forêts Aléatoires pour la Classification
Une forêt aléatoire fonctionne comme pour la régression, mais :
- Chaque arbre vote pour la classe
- La classe majoritaire (mode) est prédite
- Réduit drastiquement l'overfitting
- Performance généralement excellente
📝 Exemple Python Simplifié
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, f1_score
# Entraîner
rf = RandomForestClassifier(n_estimators=100, max_depth=10, random_state=42)
rf.fit(X_train, y_train)
# Prédire
y_pred = rf.predict(X_test)
y_proba = rf.predict_proba(X_test)
print(f"Accuracy : {accuracy_score(y_test, y_pred):.2%}")
print(f"F1 Score : {f1_score(y_test, y_pred):.2f}")
# Importance des features
for feat, imp in zip(X.columns, rf.feature_importances_):
print(f"{feat} : {imp:.4f}")
Accuracy : 96.67%
F1 Score : 0.96
surface_m2 : 0.4523
distance_metro_km : 0.2845
nb_pieces : 0.1567
etage : 0.0845
4.5 - Gradient Boosting pour la Classification
Concept
Gradient Boosting pour la classification entraîne les arbres séquentiellement, corrigeant les erreurs du modèle précédent.
✓ Avantages :
- Performance souvent maximale
- Très efficace sur les patterns complexes
- Moins d'overfitting que les arbres simples
✗ Inconvénients :
- Plus lent à l'entraînement
- Plus d'hyperparamètres à tuner
- Moins interprétable
📝 Exemple Python
from sklearn.ensemble import GradientBoostingClassifier
gb = GradientBoostingClassifier(
n_estimators=100,
learning_rate=0.1,
max_depth=5,
random_state=42
)
gb.fit(X_train, y_train)
y_pred = gb.predict(X_test)
y_proba = gb.predict_proba(X_test)[:, 1]
print(f"Accuracy : {accuracy_score(y_test, y_pred):.2%}")
print(f"ROC-AUC : {roc_auc_score(y_test, y_proba):.2%}")
Accuracy : 88.26%
ROC-AUC : 94.11%
Comparaison : Tous les Modèles
| Modèle |
Accuracy |
F1 Score |
ROC-AUC |
Vitesse |
Interprétabilité |
| Logistic |
82.68% |
0.7407 |
0.8876 |
⚡ Très rapide |
📊 Excellente |
| Arbre |
83.24% |
0.7732 |
0.8234 |
⚡ Rapide |
📊 Excellente |
| Forêt |
86.59% |
0.8226 |
0.9203 |
⚡⚡ Normal |
🔍 Moyen |
| Boosting |
88.26% |
0.8582 |
0.9411 |
⚡⚡⚡ Normal |
🔍 Moyen |
💡 Comment Choisir :
- Besoin d'interpétabilité ? → Régression Logistique ou Arbre Simple
- Besoin de performance ? → Forêt Aléatoire ou Gradient Boosting
- Bon compromis ? → Forêt Aléatoire
- Maximum de performance ? → Gradient Boosting
4.6 - Atelier Pratique : Titanic
Contexte
Le RMS Titanic a coulé le 15 avril 1912. Parmi les ~2224 passagers et membres d'équipage, environ 1502 ont péri.
DÉFI Construire un modèle qui prédit si un passager aurait survécu en fonction de ses caractéristiques.
Dataset : Colonnes Clés
- Pclass : Classe du ticket (1/2/3)
- Sex : Sexe (male/female)
- Age : Âge en années
- Fare : Prix du ticket
- SibSp : Frères/sœurs/conjoints à bord
- Parch : Parents/enfants à bord
- Embarked : Port (C/Q/S)
- Survived : Target (1=Survécu, 0=Mort)
Résultats Attendus
✓ Sortie du Modèle :
- Comparaison de 4 modèles
- Accuracy : 82-88%
- F1 Score : 0.74-0.86
- Matrices de confusion pour chaque modèle
- Courbes ROC
- Prédictions sur exemples concrets
ℹ️ Structure du Code :
- Charger les données (891 passagers)
- Exploration (EDA)
- Nettoyage (valeurs manquantes, encoding)
- Feature engineering (FamilySize, AgeGroup, etc.)
- Train-Test split + normalisation
- Entraîner 4 modèles
- Comparer les métriques
- Visualiser matrices de confusion & ROC
- Faire des prédictions exemple
📝 Résumé du Code Complet
Le code complet est disponible dans les ressources du cours (fichier : titanic_workshop.py). Voici les points clés :
ÉTAPE 1-2 : Charger et explorer (correlations)
ÉTAPE 3-4 : Nettoyage et feature engineering
ÉTAPE 5 : Train-test split + scale
ÉTAPE 6 : Entraîner 4 modèles
ÉTAPE 7 : Comparer Accuracy, Precision, Recall, F1, ROC-AUC
ÉTAPE 8 : Visualiser (matrices de confusion, courbes ROC)
ÉTAPE 9 : Prédictions sur 3 passagers exemple
✓ Résultat Exemple :
- Logistic Regression : Accuracy 82.68%, F1 0.7407
- Decision Tree : Accuracy 83.24%, F1 0.7732
- Random Forest : Accuracy 86.59%, F1 0.8226
- Gradient Boosting : Accuracy 88.26%, F1 0.8582 🏆
4.7 - Gestion des Données Déséquilibrées & Seuil Personnalisé
Problème du Déséquilibre
Exemple : Dataset de fraude avec 99% transactions légales, 1% fraudes.
⚠️ Problème : Un modèle qui prédit toujours "légitime" aurait 99% d'accuracy !
Solutions
- 1. Utiliser F1 Score au lieu d'Accuracy
- 2. Utiliser class_weight='balanced' dans les modèles
- 3. Over-sampling/Under-sampling des données
- 4. Ajuster le seuil de décision (au lieu de 0.5)
Ajuster le Seuil de Décision
Par défaut, on prédit classe 1 si P(y=1) > 0.5. Mais on peut changer ce seuil !
📝 Exemple Python
from sklearn.metrics import precision_recall_curve
# Obtenir les probabilités
y_proba = model.predict_proba(X_test)[:, 1]
# Calculer P et R pour différents seuils
precisions, recalls, thresholds = precision_recall_curve(y_test, y_proba)
# Calculer F1 pour chaque seuil
f1_scores = 2 * (precisions * recalls) / (precisions + recalls + 1e-10)
# Trouver le meilleur seuil
best_idx = np.argmax(f1_scores)
best_threshold = thresholds[best_idx]
print(f"Meilleur seuil : {best_threshold:.3f} (au lieu de 0.5)")
print(f"F1 Score : {f1_scores[best_idx]:.4f}")
# Utiliser ce seuil
y_pred_custom = (y_proba >= best_threshold).astype(int)
print(f"Accuracy : {accuracy_score(y_test, y_pred_custom):.4f}")
Meilleur seuil : 0.385 (au lieu de 0.5)
F1 Score : 0.8725
Accuracy : 0.8901
4.8 - Exercices Pratiques
Exercice 1 : Classification sur Dataset UCI
Énoncé : Utilisez le dataset Breast Cancer. Comparez 4 modèles et calculez accuracy, precision, recall, F1 et ROC-AUC.
Voir les indices
- Charger :
load_breast_cancer()
- Train-test split (80/20, stratified)
- Normaliser les données
- Entraîner : Logistic, Tree, Forest, Boosting
- Calculer les 5 métriques pour chaque
- Créer un tableau comparatif
Exercice 2 : Tuning d'Hyperparamètres
Énoncé : Utilisez GridSearchCV pour tuner une Forêt Aléatoire. Testez différents n_estimators, max_depth, etc.
Voir les indices
Testez : n_estimators=[50,100,200], max_depth=[5,10,15], min_samples_split=[2,5]. Utilisez scoring='f1'.
Exercice 3 : Ajuster le Seuil de Décision
Énoncé : Sur le Titanic, cherchez le meilleur seuil pour maximiser F1 Score (au lieu de 0.5).
Voir les indices
Utilisez precision_recall_curve() pour chaque seuil de 0.1 à 0.9. Tracez F1 vs seuil.
4.9 - Checklist de Compétences
- Comprendre la différence classification vs régression
- Différencier classification binaire, multi-classe et multi-label
- Savoir quand utiliser chaque métrique (Accuracy, Precision, Recall, F1)
- Interpréter une matrice de confusion
- Entraîner une régression logistique
- Entraîner un arbre de décision pour la classification
- Entraîner une forêt aléatoire pour la classification
- Entraîner un modèle Gradient Boosting pour la classification
- Comparer 4 modèles sur le même dataset
- Avoir complété l'atelier Titanic
- Connaître l'importance du seuil de décision (pas toujours 0.5)
- Savoir utiliser ROC-AUC
- Ajuster les hyperparamètres avec GridSearchCV
- Gérer les données déséquilibrées
- Interpréter les probabilités
Résumé du Module 4
- Classification : Prédire une catégorie (binaire ou multi-classe)
- Régression Logistique : Simple, interprétable, donne probabilités
- Arbres de Décision : Très interprétables, capture non-linéarités
- Forêts Aléatoires : Ensemble puissant et stable, bon compromis
- Gradient Boosting : Performance maximale, séquentiel
- Accuracy : % prédictions correctes (à éviter si déséquilibré)
- Precision : % positifs prédits qui sont vrais (quand FP chers)
- Recall : % vrais positifs détectés (quand FN chers)
- F1 Score : Harmonie Precision/Recall (données déséquilibrées)
- ROC-AUC : Mesure la discrimination du modèle (0 à 1)
- Matrice de Confusion : Voir TP, TN, FP, FN
- Seuil de Décision : Peut être ajusté (pas toujours 0.5)
- Atelier Titanic : 4 modèles comparés sur données réelles
- Données Déséquilibrées : Utiliser F1, class_weight, ou ajuster le seuil