Équilibrage des classes en utilisant des poids

Dans les problèmes de classification, il est courant de rencontrer des jeux de données déséquilibrés, où certaines classes sont beaucoup plus représentées que d’autres. Ce déséquilibre peut affecter significativement la qualité des modèles, en particulier leur capacité à détecter correctement les classes minoritaires. Une des solutions efficaces pour atténuer ce problème consiste à utiliser le paramètre class_weight='balanced', disponible dans plusieurs algorithmes d’apprentissage automatique tels que les SVM, la régression logistique, les forêts aléatoires, et d’autres classificateurs de la bibliothèque scikit-learn.

Qu’est-ce que le déséquilibre des classes ?

Un jeu de données est déséquilibré lorsque la proportion d’échantillons d’une ou plusieurs classes est très faible par rapport aux autres. Par exemple, dans un jeu de données de détection de fraude, les transactions frauduleuses peuvent représenter moins de 1 % des données totales, alors que les transactions légitimes dominent largement.

Cette situation pose problème car les modèles, lorsqu’ils sont entraînés sans précaution, tendent à privilégier la classe majoritaire afin d’optimiser leur précision globale, ce qui entraîne une mauvaise détection des classes minoritaires.

Pourquoi utiliser `class_weight='balanced'` ?

Le paramètre class_weight='balanced' est une manière simple d’indiquer à l’algorithme d’apprentissage que certaines classes doivent avoir plus d’importance dans la fonction de perte. En pratique, ce poids est calculé automatiquement en fonction de la fréquence inverse des classes dans le jeu d’entraînement. Les classes rares sont ainsi surpondérées, ce qui pousse le modèle à mieux les prendre en compte.

Cela permet d’équilibrer implicitement l’impact des classes sur l’apprentissage, sans modifier les données elles-mêmes (contrairement aux méthodes de suréchantillonnage ou sous-échantillonnage).

Fonctionnement mathématique de `class_weight='balanced'`

Soit un jeu de données contenant n exemples répartis en k classes, avec n_i exemples pour la classe i. Le poids attribué à chaque classe est calculé comme suit :

weight_i = n / (k * n_i)

Ainsi, les classes avec peu d’exemples auront un poids plus élevé, et inversement. Ce poids est ensuite utilisé dans la fonction de coût ou de perte du modèle pour pondérer les erreurs :

Loss = Σ_i=1^k weight_i * erreur_i

Cela signifie que commettre une erreur sur une classe minoritaire aura un impact plus important sur la fonction à minimiser que sur une classe majoritaire.

Avantages de l’utilisation de `class_weight='balanced'`

Simplicité : Il suffit d’ajouter un paramètre lors de la création du modèle, sans modifier le jeu de données.
Préservation des données : Pas de duplication ni de suppression d’échantillons, ce qui évite les risques de surapprentissage ou de perte d’informations.
Adaptabilité : Le calcul automatique des poids s’adapte à la distribution des classes, même si elle est inconnue à l’avance.
Compatibilité : Disponible dans beaucoup d’algorithmes classiques (SVM, LogisticRegression, RandomForestClassifier, etc.).

Limitations et précautions

Impact limité en cas d’extrême déséquilibre : Si la classe minoritaire est très rare (par exemple moins de 1%), ce seul réglage peut ne pas suffire et doit être combiné avec d’autres méthodes.
Augmentation de la variance : En surpondérant la classe minoritaire, on peut augmenter le risque de surapprentissage sur cette classe.
Pas une panacée : Certains modèles ou jeux de données peuvent nécessiter d’autres techniques complémentaires (échantillonnage, génération synthétique, ajustement des seuils de décision, etc.).

Exemple pratique en Python avec scikit-learn

Voici un exemple simple d’utilisation de class_weight='balanced' avec un classificateur de régression logistique sur un jeu de données déséquilibré :

from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# Création d'un jeu de données déséquilibré
X, y = make_classification(n_samples=1000, n_classes=2, weights=[0.9, 0.1], random_state=42)

# Séparation en train/test
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=42)

# Modèle sans équilibrage
model_default = LogisticRegression(max_iter=1000)
model_default.fit(X_train, y_train)
print("Sans class_weight='balanced'")
print(classification_report(y_test, model_default.predict(X_test)))

# Modèle avec class_weight balanced
model_balanced = LogisticRegression(class_weight='balanced', max_iter=1000)
model_balanced.fit(X_train, y_train)
print("Avec class_weight='balanced'")
print(classification_report(y_test, model_balanced.predict(X_test)))

Dans ce cas, on observe généralement une amélioration du rappel (sensibilité) de la classe minoritaire, avec un possible léger impact sur la précision globale.

Impact sur les métriques de performance

L’utilisation de class_weight='balanced' modifie le comportement du modèle en termes de compromis entre précision et rappel. Pour la classe minoritaire, on observe souvent :

Une augmentation du rappel (plus d’exemples minoritaires détectés).
Une baisse potentielle de la précision (plus de faux positifs possibles).
Un équilibre amélioré pour la métrique F1, qui combine précision et rappel.

Ce comportement est souvent souhaitable lorsque la détection des cas minoritaires est critique (fraude, maladies rares, défauts qualité, etc.).

Comparaison avec d’autres méthodes d’équilibrage

Il existe d’autres stratégies pour gérer le déséquilibre des classes, telles que :

Suréchantillonnage (oversampling) : Création de nouvelles instances synthétiques (ex : SMOTE).
Sous-échantillonnage (undersampling) : Réduction du nombre d’exemples dans la classe majoritaire.
Modification du seuil de décision : Ajuster la probabilité à partir de laquelle on prédit la classe minoritaire.
Ensembles pondérés ou coûts spécifiques : Approches plus avancées où chaque erreur a un coût différent.

Le paramètre class_weight='balanced' est souvent une première approche facile à tester, qui ne demande pas de modification des données. En revanche, dans les cas extrêmes, il peut être utile de combiner plusieurs méthodes.

Conclusion

Le déséquilibre des classes est un défi courant en apprentissage supervisé, particulièrement dans les domaines critiques. Utiliser class_weight='balanced' permet d’ajuster automatiquement les poids des classes dans la fonction de perte, améliorant la capacité du modèle à détecter les classes minoritaires sans modifier les données d’entrée.

Cette approche est simple à mettre en œuvre et efficace dans de nombreux cas, mais ne dispense pas de tester d’autres techniques complémentaires selon le contexte et la nature du problème.

Pour un data scientist, comprendre et maîtriser class_weight='balanced' est une étape clé vers la construction de modèles robustes et justes face aux déséquilibres de données.