La classification est une forme d’apprentissage supervisé où la variable cible est discrète (catégorielle). On distingue :

• Classification binaire – deux classes seulement (ex: spam / non‑spam, fraude / légitime, maladie / sain).
• Classification multi‑classe – plus de deux classes (ex: reconnaissance de chiffres manuscrits 0‑9, types d’iris).
• Classification multi‑étiquette – chaque observation peut appartenir à plusieurs classes (ex: tags d’un article).

L’objectif est d’entraîner un modèle sur des données historiques étiquetées afin qu’il prédise correctement les étiquettes de nouvelles données. ISOSET propose des cursus pratiques pour maîtriser la classification, des données au déploiement.

L’accuracy (pourcentage de bonnes prédictions) peut être trompeuse en cas de classes déséquilibrées. On utilise alors des métriques plus fines :

• Précision (Precision) – parmi les prédictions positives, combien sont réellement positives ? Utile pour éviter les faux positifs (ex: recommandation).
• Rappel (Recall / Sensibilité) – parmi les vrais positifs, combien ont été détectés ? Prioritaire en détection de maladies ou de fraudes.
• F1‑score – moyenne harmonique de précision et rappel, bon compromis.
• AUC‑ROC – capacité du modèle à distinguer les classes, indépendante du seuil (bonne pour les classes déséquilibrées).
• Matrice de confusion – visualise les VP, VN, FP, FN.

# Calcul des métriques avec scikit‑learn
from sklearn.metrics import classification_report, roc_auc_score
print(classification_report(y_test, y_pred))
auc = roc_auc_score(y_test, y_proba)

ISOSET aide les entreprises à choisir la métrique adaptée à leur coût métier (ex: un faux négatif en détection de fraude coûte cher).

ISOSET forme à la sélection et à l’optimisation de ces algorithmes selon la nature des données.

Lorsqu’une classe est très minoritaire (ex: 1% de fraudes), un classifieur naïf peut prédire toujours la classe majoritaire avec 99% d’accuracy. Les solutions :

• Rééchantillonnage – sur‑échantillonner la classe minoritaire (SMOTE), sous‑échantillonner la classe majoritaire.
• Pondération des classes – donner un poids plus élevé aux erreurs sur la classe minoritaire (paramètre `class_weight` dans scikit‑learn).
• Métriques adaptées – privilégier le F1, l’AUC, le rappel.
• Seuil de décision personnalisé – ajuster le seuil de probabilité au lieu de 0,5.

# Pondération des classes dans Random Forest
model = RandomForestClassifier(class_weight='balanced')
# SMOTE avec imbalanced-learn
from imblearn.over_sampling import SMOTE
smote = SMOTE()
X_res, y_res = smote.fit_resample(X_train, y_train)

ISOSET propose des ateliers approfondis sur les techniques de rééchantillonnage et les métriques robustes.

# Pipeline complet : préparation, entraînement, évaluation
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, roc_auc_score, ConfusionMatrixDisplay
import matplotlib.pyplot as plt

# Chargement et partition
df = pd.read_csv("churn.csv")
X = df.drop("churn", axis=1)
y = df["churn"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

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

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

# Prédictions
y_pred = model.predict(X_test_scaled)
y_proba = model.predict_proba(X_test_scaled)[:, 1]

# Évaluation
print(classification_report(y_test, y_pred))
print(f"AUC : {roc_auc_score(y_test, y_proba):.3f}")
ConfusionMatrixDisplay.from_estimator(model, X_test_scaled, y_test)
plt.show()

ISOSET initie les jeunes à la classification via des projets ludiques (reconnaissance de fruits, jeux de données simples).

Pour trouver les meilleurs hyperparamètres (ex: n_estimators, max_depth, C), on utilise la recherche sur grille (GridSearchCV) associée à une validation croisée (k‑fold). Cela évite le sur‑apprentissage et maximise la généralisation.

# GridSearchCV pour Random Forest
from sklearn.model_selection import GridSearchCV
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [None, 10, 20]
}
grid = GridSearchCV(RandomForestClassifier(random_state=42), param_grid, cv=5, scoring='roc_auc')
grid.fit(X_train_scaled, y_train)
print(grid.best_params_)
print(grid.best_score_)

ISOSET forme à l’optimisation systématique des modèles, avec ou sans outils automatisés.

Dans certains domaines (finance, santé, réglementation), il est essentiel de comprendre les décisions du modèle. Les arbres et forêts aléatoires offrent une importance des variables (feature importance). Pour des modèles plus complexes, on utilise SHAP (SHapley Additive exPlanations) ou LIME. Ces outils augmentent la confiance et aident à détecter les biais.

# Feature importance avec Random Forest
importances = model.feature_importances_
feature_names = X.columns
for name, imp in sorted(zip(feature_names, importances), key=lambda x: x[1], reverse=True)[:5]:
    print(f"{name}: {imp:.3f}")

• Data leakage – utiliser des informations du futur (normalisation avant split). Toujours valider croisée.
• Classes déséquilibrées ignorées – ne pas traiter le déséquilibre mène à un classifieur naïf. Utiliser les métriques adaptées et le rééchantillonnage.
• Sur‑apprentissage – trop de complexité (profondeur d’arbre, trop de features). Utiliser la régularisation, la validation croisée.
• Choisir la mauvaise métrique – accuracy est souvent insuffisante. Comprendre le coût des faux positifs et faux négatifs.

Les témoignages d’anciens élèves d’ISOSET : *« La formation classification m’a permis de passer d’un score de 60% à 85% de F1 sur un problème de détection de fraude. Grâce aux métriques appropriées et à SMOTE, j’ai convaincu l’entreprise de déployer le modèle. »*