Projet de Synthèse : Le Grand Duel des Classifieurs

L’Art de la Classification Supervisée’

Machine Learning
Apprentissage Supervisé
Classification
Python
Projet
Author
Affiliation

Wilson Toussile

ENSPY & ESSFAR

1 Introduction : L’Heure du Verdict

Au cours de cette série, nous avons assemblé une formidable boîte à outils de classifieurs. De la simple régression logistique aux puissantes méthodes ensemblistes, chaque modèle a sa propre philosophie, ses forces et ses faiblesses.

Mais face à un nouveau problème, une question demeure : lequel choisir ?

Cet atelier pratique est le point culminant de notre parcours. Nous allons organiser un “grand duel” où nous mettrons en compétition tous les modèles que nous avons appris sur un seul et même jeu de données. L’objectif n’est pas seulement de trouver le “meilleur” modèle en termes de performance brute, mais de comprendre comment les comparer de manière rigoureuse et de discuter des compromis entre performance, interprétabilité et complexité.

2 Le Champ de Bataille : Le Jeu de Données sur le Cancer du Sein

Pour notre projet, nous utiliserons le jeu de données Wisconsin Breast Cancer de Scikit-learn. C’est un problème de classification binaire classique et bien étudié.

  • Objectif : Prédire si une tumeur est maligne (classe 1) ou bénigne (classe 0) à partir de 30 caractéristiques numériques mesurées sur une image de biopsie (rayon, texture, périmètre, etc.).
  • Pourquoi ce jeu de données ? Il est propre, ne contient pas de valeurs manquantes, et toutes les variables sont numériques, ce qui nous permet de nous concentrer sur la comparaison des modèles.

3 Les Combattants

Voici la liste des modèles qui vont s’affronter :

  1. Régression Logistique (notre modèle de base)
  2. k-Plus Proches Voisins (k-NN)
  3. Arbre de Décision (élagué)
  4. Machine à Vecteurs de Support (SVM)
  5. Classifieur Naïf Bayésien Gaussien
  6. Forêt Aléatoire
  7. Gradient Boosting

4 La Méthodologie : Des Règles du Jeu Équitables

Pour une comparaison juste, nous devons suivre une méthodologie rigoureuse :

  1. Pré-traitement Standardisé : Tous les modèles qui sont sensibles à l’échelle des données (Logistique, k-NN, SVM) recevront des données mises à l’échelle avec StandardScaler. Nous utiliserons des Pipelines pour garantir que ce processus est appliqué correctement.
  2. Recherche d’Hyperparamètres : Pour les modèles qui en ont besoin (k-NN, Arbre, SVM), nous utiliserons GridSearchCV avec une validation croisée à 5 blocs pour trouver leur meilleure configuration.
  3. Évaluation Cohérente : Tous les modèles finaux seront évalués sur le même jeu de test, en utilisant un ensemble de métriques communes : Accuracy, Précision, Rappel, et Score F1.

5 Préparation de l’Environnement et des Données

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# Données et pré-traitement
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

# Les modèles
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier

# Métriques
from sklearn.metrics import classification_report, accuracy_score

# Configuration
sns.set_theme(style="whitegrid")
plt.rcParams['figure.figsize'] = (10, 6)

# 1. Charger et préparer les données
cancer = load_breast_cancer()
X, y = cancer.data, cancer.target

# 2. Diviser les données
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)

# 3. Mettre en place le scaler
# Il sera utilisé dans les pipelines
scaler = StandardScaler()

print(f"Données prêtes. Entraînement: {X_train.shape[0]} échantillons, Test: {X_test.shape[0]} échantillons.")
Données prêtes. Entraînement: 455 échantillons, Test: 114 échantillons.

6 Le Duel : Entraînement et Évaluation des Modèles

Nous allons maintenant entraîner chaque modèle, en cherchant les meilleurs hyperparamètres si nécessaire, et stocker leurs performances.

# Dictionnaire pour stocker les résultats
results = {}

# --- 1. Régression Logistique ---
print("--- Entraînement: Régression Logistique ---")
pipe_lr = Pipeline([('scaler', StandardScaler()), ('classifier', LogisticRegression(random_state=42, max_iter=1000))])
pipe_lr.fit(X_train, y_train)
results['Logistic Regression'] = accuracy_score(y_test, pipe_lr.predict(X_test))

# --- 2. k-NN ---
print("--- Entraînement: k-NN (avec GridSearchCV) ---")
pipe_knn = Pipeline([('scaler', StandardScaler()), ('classifier', KNeighborsClassifier())])
param_grid_knn = {'classifier__n_neighbors': np.arange(3, 20, 2)}
gs_knn = GridSearchCV(pipe_knn, param_grid_knn, cv=5, scoring='accuracy')
gs_knn.fit(X_train, y_train)
results['k-NN'] = accuracy_score(y_test, gs_knn.predict(X_test))
print(f"Meilleur k: {gs_knn.best_params_['classifier__n_neighbors']}")

# --- 3. Arbre de Décision (élagué) ---
print("--- Entraînement: Arbre de Décision (avec GridSearchCV) ---")
# On ne met pas de scaler car les arbres n'en ont pas besoin
pipe_tree = Pipeline([('classifier', DecisionTreeClassifier(random_state=42))])
# Trouver le meilleur ccp_alpha est long, on va chercher sur max_depth pour simplifier
param_grid_tree = {'classifier__max_depth': [3, 5, 7, 10], 'classifier__min_samples_leaf': [1, 5, 10]}
gs_tree = GridSearchCV(pipe_tree, param_grid_tree, cv=5, scoring='accuracy')
gs_tree.fit(X_train, y_train)
results['Decision Tree'] = accuracy_score(y_test, gs_tree.predict(X_test))
print(f"Meilleurs paramètres: {gs_tree.best_params_}")

# --- 4. SVM ---
print("--- Entraînement: SVM (avec GridSearchCV) ---")
pipe_svm = Pipeline([('scaler', StandardScaler()), ('classifier', SVC(random_state=42))])
param_grid_svm = {'classifier__C': [0.1, 1, 10], 'classifier__gamma': [0.1, 0.01, 'scale']}
gs_svm = GridSearchCV(pipe_svm, param_grid_svm, cv=5, scoring='accuracy')
gs_svm.fit(X_train, y_train)
results['SVM'] = accuracy_score(y_test, gs_svm.predict(X_test))
print(f"Meilleurs paramètres: {gs_svm.best_params_}")

# --- 5. Naïf Bayésien Gaussien ---
print("--- Entraînement: Naïf Bayésien Gaussien ---")
pipe_nb = Pipeline([('scaler', StandardScaler()), ('classifier', GaussianNB())])
pipe_nb.fit(X_train, y_train)
results['Gaussian Naive Bayes'] = accuracy_score(y_test, pipe_nb.predict(X_test))

# --- 6. Forêt Aléatoire ---
print("--- Entraînement: Forêt Aléatoire ---")
pipe_rf = Pipeline([('classifier', RandomForestClassifier(random_state=42))])
pipe_rf.fit(X_train, y_train)
results['Random Forest'] = accuracy_score(y_test, pipe_rf.predict(X_test))

# --- 7. Gradient Boosting ---
print("--- Entraînement: Gradient Boosting ---")
pipe_gb = Pipeline([('classifier', GradientBoostingClassifier(random_state=42))])
pipe_gb.fit(X_train, y_train)
results['Gradient Boosting'] = accuracy_score(y_test, pipe_gb.predict(X_test))

print("\n--- Entraînement de tous les modèles terminé ! ---")
--- Entraînement: Régression Logistique ---
--- Entraînement: k-NN (avec GridSearchCV) ---
Meilleur k: 7
--- Entraînement: Arbre de Décision (avec GridSearchCV) ---
Meilleurs paramètres: {'classifier__max_depth': 5, 'classifier__min_samples_leaf': 5}
--- Entraînement: SVM (avec GridSearchCV) ---
Meilleurs paramètres: {'classifier__C': 10, 'classifier__gamma': 0.01}
--- Entraînement: Naïf Bayésien Gaussien ---
--- Entraînement: Forêt Aléatoire ---
--- Entraînement: Gradient Boosting ---

--- Entraînement de tous les modèles terminé ! ---

7 Les Résultats du Duel

Maintenant que tous les modèles ont été entraînés et évalués, comparons leurs performances finales sur le jeu de test.

# Créer un DataFrame à partir des résultats
results_df = pd.DataFrame(list(results.items()), columns=['Model', 'Accuracy'])
results_df = results_df.sort_values(by='Accuracy', ascending=False).reset_index(drop=True)

print("--- Classement Final des Modèles par Accuracy sur le Jeu de Test ---")
print(results_df)

# Visualisation des résultats
plt.figure(figsize=(12, 8))
ax = sns.barplot(x='Accuracy', y='Model', data=results_df, palette='viridis')
ax.set_xlim(0.9, 1.0) # Zoomer sur la zone pertinente
ax.set_title("Comparaison de l'Accuracy des Modèles", fontsize=16)

# Ajouter les valeurs sur les barres
for i in ax.containers:
    ax.bar_label(i, fmt='%.4f')
    
plt.show()

# Afficher le rapport détaillé pour le meilleur modèle
best_model_name = results_df.loc[0, 'Model']
print(f"\n--- Rapport de Classification Détaillé pour le Meilleur Modèle : {best_model_name} ---")

# On récupère le meilleur modèle du dictionnaire de pipelines
all_models = {
    'Logistic Regression': pipe_lr,
    'k-NN': gs_knn.best_estimator_,
    'Decision Tree': gs_tree.best_estimator_,
    'SVM': gs_svm.best_estimator_,
    'Gaussian Naive Bayes': pipe_nb,
    'Random Forest': pipe_rf,
    'Gradient Boosting': pipe_gb
}
best_model_pipeline = all_models[best_model_name]
best_y_pred = best_model_pipeline.predict(X_test)
print(classification_report(y_test, best_y_pred, target_names=cancer.target_names))
--- Classement Final des Modèles par Accuracy sur le Jeu de Test ---
                  Model  Accuracy
0   Logistic Regression  0.982456
1                   SVM  0.982456
2                  k-NN  0.973684
3         Random Forest  0.956140
4     Gradient Boosting  0.956140
5  Gaussian Naive Bayes  0.929825
6         Decision Tree  0.921053
/tmp/ipykernel_61034/1012216333.py:10: FutureWarning:



Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `y` variable to `hue` and set `legend=False` for the same effect.




--- Rapport de Classification Détaillé pour le Meilleur Modèle : Logistic Regression ---
              precision    recall  f1-score   support

   malignant       0.98      0.98      0.98        42
      benign       0.99      0.99      0.99        72

    accuracy                           0.98       114
   macro avg       0.98      0.98      0.98       114
weighted avg       0.98      0.98      0.98       114

8 Discussion et Conclusion

Les résultats montrent que plusieurs modèles atteignent des performances très élevées. Dans ce cas, le SVM, la Régression Logistique et le Naïf Bayésien se détachent légèrement.

Que faut-il en conclure ?

  • Pas de “Balle d’Argent” : Il n’y a pas un seul algorithme qui est toujours le meilleur. La performance dépend fortement de la nature du jeu de données.
  • Simplicité vs. Performance : Il est remarquable qu’un modèle simple comme la Régression Logistique ou le Naïf Bayésien puisse rivaliser avec des ensembles complexes comme le Gradient Boosting sur ce problème. Cela suggère que la frontière de décision est probablement assez simple. Pour un problème médical, un modèle plus simple et plus interprétable avec une performance quasi-identique est souvent préférable.
  • Le Contexte est Roi : Si l’objectif était de minimiser les Faux Négatifs (rater un patient malade), on regarderait attentivement le Rappel de la classe malignant. Le choix final du modèle ne se base pas seulement sur l’accuracy, mais sur la métrique la plus pertinente pour le problème métier.

Cet atelier conclut notre voyage à travers les principaux algorithmes de classification. Vous disposez maintenant d’une méthodologie complète pour aborder un problème de classification de A à Z : du pré-traitement à l’entraînement de multiples modèles, en passant par leur évaluation rigoureuse pour choisir le plus adapté à vos besoins.

Back to top