Modèles de référence : toujours dépasser DummyClassifier
Construisez un DummyClassifier comme référence minimale et vérifiez que tout modèle réel doit le dépasser avant d’être considéré comme utile.
Modèles de référence : toujours dépasser DummyClassifier est une leçon Machine Learning Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Machine Learning Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Machine Learning Academy comprend 4 leçons au total.
Pourquoi vous avez besoin d'une référence
Lorsque vous annoncez que votre modèle atteint une précision de 92 %, ce chiffre n'a aucun sens sans contexte. 92 %, est-ce impressionnant ou décevant ? Cela dépend entièrement de ce qu'obtiendrait la stratégie la plus simple possible sur le même problème.
Un modèle de référence constitue le seuil minimal que tout modèle réel doit dépasser pour être considéré comme utile. Sans référence, vous pourriez vous réjouir d'une précision de 92 % sur un jeu de données où un modèle qui prédit toujours « absence de fraude » obtiendrait 95 % — ce qui signifie que votre modèle d'apprentissage automatique sophistiqué est en réalité moins performant que l'inaction.
DummyClassifier : l'outil de référence de scikit-learn
Scikit-learn fournit DummyClassifier, un classifieur minimal qui effectue des prédictions à l'aide de règles simples ignorant complètement les variables d'entrée. Il s'agit de l'outil officiel permettant d'établir une référence avant de commencer toute modélisation réelle.
DummyClassifier n'est ni une plaisanterie ni un simple substitut : c'est un contrôle de cohérence rigoureux. Si votre modèle réel ne peut pas dépasser le DummyClassifier, un problème fondamental se pose : vos variables ne sont peut-être pas prédictives, votre chaîne de traitement contient peut-être un bogue ou le problème est plus difficile que prévu.
from sklearn.dummy import DummyClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Most frequent baseline: always predicts the majority class
dummy = DummyClassifier(strategy='most_frequent')
dummy.fit(X_train, y_train)
baseline_acc = dummy.score(X_test, y_test)
print(f'Baseline accuracy (always predict majority class): {baseline_acc:.3f}')Stratégies de DummyClassifier
DummyClassifier prend en charge plusieurs stratégies de référence :
most_frequent: prédit toujours la classe la plus fréquente dans les données d'entraînement. Idéale pour les jeux de données déséquilibrés.stratified: prédit aléatoirement chaque classe avec une probabilité égale à sa fréquence dans les données d'entraînement. Préserve la répartition des classes.uniform: prédit aléatoirement chaque classe avec une probabilité identique. Utile lorsque toutes les classes sont représentées dans les mêmes proportions.constant: prédit toujours une classe constante donnée. Utilisez cette stratégie pour tester ce qui se passe lorsque vous prédisez toujours la classe positive.
from sklearn.dummy import DummyClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import f1_score
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
for strategy in ['most_frequent', 'stratified', 'uniform', 'prior']:
dummy = DummyClassifier(strategy=strategy, random_state=42)
dummy.fit(X_train, y_train)
acc = dummy.score(X_test, y_test)
print(f'strategy={strategy}: accuracy={acc:.3f}')Le paradoxe de la précision en pratique
Le paradoxe de la précision est particulièrement frappant avec les jeux de données déséquilibrés. Prenons le cas de la fraude à la carte bancaire, où 99 % des transactions sont légitimes. Le most_frequent DummyClassifier prédit « absence de fraude » pour chaque transaction et atteint une précision de 99 %. Un modèle réel d'apprentissage automatique obtenant une précision de 97 % semblerait moins performant que cette référence selon cette mesure — même s'il identifie correctement la plupart des fraudes réelles.
C'est pourquoi la référence DummyClassifier doit être évaluée avec la même métrique que celle utilisée pour évaluer votre modèle réel. Pour les problèmes déséquilibrés, utilisez le score F1, la précision positive ou le rappel, et non la précision globale.
from sklearn.dummy import DummyClassifier
from sklearn.metrics import f1_score, accuracy_score
import numpy as np
# Simulate 99% negative class (not fraud)
np.random.seed(42)
n = 10000
y_true = np.array([0]*9900 + [1]*100)
X_fake = np.random.randn(n, 5) # random features (not predictive)
# Baseline always predicts not-fraud
dummy = DummyClassifier(strategy='most_frequent')
dummy.fit(X_fake, y_true)
y_pred_dummy = dummy.predict(X_fake)
print(f'Dummy Accuracy: {accuracy_score(y_true, y_pred_dummy):.3f}') # 0.990
print(f'Dummy F1-score: {f1_score(y_true, y_pred_dummy):.3f}') # 0.000
print('Dummy catches 0 fraud cases despite 99% accuracy!')DummyRegressor : référence pour la régression
Pour les problèmes de régression, scikit-learn fournit DummyRegressor avec les stratégies suivantes :
mean: prédit toujours la moyenne de l'ensemble d'entraînement. Il s'agit de la référence standard : R² mesure dans quelle mesure votre modèle est meilleur que le simple fait de prédire la moyenne.median: prédit toujours la médiane de l'ensemble d'entraînement. Cette stratégie est plus robuste aux valeurs aberrantes.quantile: prédit toujours un quantile précis de la variable cible d'entraînement.constant: prédit toujours une constante donnée.
Un modèle de régression dont le R² est inférieur à 0 est en réalité moins performant que le fait de toujours prédire la moyenne — un signe évident qu'un problème est survenu pendant l'entraînement.
from sklearn.dummy import DummyRegressor
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, r2_score
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
X, y = fetch_california_housing(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
dummy_reg = DummyRegressor(strategy='mean')
dummy_reg.fit(X_train, y_train)
y_pred_d = dummy_reg.predict(X_test)
print(f'DummyRegressor MAE: {mean_absolute_error(y_test, y_pred_d):.3f}')
print(f'DummyRegressor R2: {r2_score(y_test, y_pred_d):.3f}') # exactly 0.0Votre modèle face à la référence
Comparez maintenant votre modèle réel à la référence en utilisant la même métrique. L'amélioration par rapport à la référence indique la valeur ajoutée par votre modèle d'apprentissage automatique. Cette comparaison devrait être le premier résultat présenté dans tout projet d'apprentissage automatique.
Si l'amélioration est faible (par exemple, un score F1 de 0,65 pour le modèle réel contre 0,60 pour la référence), demandez-vous si la complexité et le coût du modèle valent une amélioration de 5 %. Parfois, un système simple fondé sur des règles est moins coûteux et suffisamment précis.
from sklearn.dummy import DummyClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.metrics import f1_score
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Baseline
dummy = DummyClassifier(strategy='most_frequent')
dummy.fit(X_train, y_train)
baseline_f1 = f1_score(y_test, dummy.predict(X_test))
# Real model
pipeline = Pipeline([('scaler', StandardScaler()), ('clf', LogisticRegression(max_iter=1000))])
pipeline.fit(X_train, y_train)
real_f1 = f1_score(y_test, pipeline.predict(X_test))
print(f'Baseline F1: {baseline_f1:.3f}')
print(f'Real model F1: {real_f1:.3f}')
print(f'Improvement over baseline: {real_f1 - baseline_f1:.3f}')Les performances humaines comme deuxième référence
Pour de nombreux problèmes du monde réel, une référence fondée sur les performances humaines est plus pertinente qu'une référence fictive. Il peut s'agir, par exemple, du taux d'erreur d'un radiologue dans la détection de tumeurs, de la précision d'un opérateur humain chargé de filtrer les courriels indésirables ou de l'erreur d'estimation du prix d'un logement par un expert immobilier.
Les performances humaines constituent un plafond : si votre modèle les égale ou les dépasse, vous avez résolu le problème. Si votre modèle leur est nettement inférieur, des progrès sont encore possibles. S'il en est très proche, l'améliorer davantage peut exiger des efforts considérables pour des gains de plus en plus faibles.
Le système précédent comme référence
Dans le secteur professionnel, la référence la plus pertinente est généralement le système existant que votre modèle doit remplacer. Si le système actuellement utilisé en production repose sur des règles conçues manuellement, c'est la performance à dépasser. Si un modèle d'apprentissage automatique précédent a été déployé, ses métriques en production constituent votre référence.
Lorsque vous présentez vos résultats aux parties prenantes, comparez-les toujours au système actuel, et pas uniquement à un DummyClassifier. La valeur pour l'entreprise vient de l'amélioration par rapport à la situation existante. Une amélioration de 2 % par rapport au système actuel peut représenter des millions d'euros de pertes liées à la fraude évitées, même si elle semble faible en valeur absolue.
Référence pour la classification multiclasse
Pour les problèmes multiclasse, la référence DummyClassifier dépend de l'équilibre entre les classes. Avec K classes équilibrées, la stratégie most_frequent atteint une précision de 1/K. Avec des classes déséquilibrées, elle atteint la proportion de la classe la plus fréquente.
Pour des métriques comme le score F1 macro-moyenné (qui attribue le même poids à toutes les classes), un classifieur aléatoire obtiendra un score bien plus faible sur les classes rares. Comparez toujours les métriques par classe entre votre modèle réel et la référence afin de comprendre d'où vient l'amélioration.
from sklearn.dummy import DummyClassifier
from sklearn.metrics import classification_report
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
dummy = DummyClassifier(strategy='most_frequent')
dummy.fit(X_train, y_train)
y_pred = dummy.predict(X_test)
print('DummyClassifier (most_frequent) on Iris:')
print(classification_report(y_test, y_pred,
target_names=['setosa', 'versicolor', 'virginica']))
print('Notice: only the majority class has non-zero precision/recall')Classifieur à règle zéro : la référence la plus simple
Encore plus simple que le DummyClassifier, le classifieur Zero-Rule (ZeroR) est une référence courante dans les compétitions de science des données. En classification, ZeroR prédit toujours la classe majoritaire. En régression, il prédit toujours la moyenne. ZeroR représente le minimum absolu qu'un modèle doit dépasser pour être utile.
Si vous ne pouvez pas dépasser ZeroR, vos variables ne contiennent aucune information sur la variable cible. Ce diagnostic est rapide et gratuit à calculer ; il devrait toujours constituer la première étape de tout nouveau projet d'apprentissage automatique, avant de consacrer du temps à des modèles complexes.
import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, f1_score
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# ZeroR: manually compute
majority_class = np.bincount(y_train).argmax()
y_pred_zeror = np.full(len(y_test), majority_class)
print(f'Majority class in training: {majority_class}')
print(f'ZeroR Accuracy: {accuracy_score(y_test, y_pred_zeror):.3f}')
print(f'ZeroR F1 (pos): {f1_score(y_test, y_pred_zeror):.3f}')Références par agrégation dans vos projets d'apprentissage automatique
Voici un processus complet d'évaluation des références pour tout projet d'apprentissage automatique :
- Calculez la référence DummyClassifier (
most_frequent) ou DummyRegressor (mean). - Si elle est disponible, calculez la référence du système actuel à partir de ses prédictions sur votre ensemble de test.
- Recherchez les performances humaines dans des références comparatives ou des publications.
- Entraînez votre premier modèle simple d'apprentissage automatique (régression logistique ou arbre de décision peu profond) et comparez les trois références.
- Ne passez à des modèles complexes que si le modèle simple dépasse nettement la référence — la complexité doit être justifiée par une amélioration mesurable.
from sklearn.dummy import DummyClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_breast_cancer
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
models = {
'DummyClassifier': DummyClassifier(strategy='most_frequent'),
'LogisticRegression': Pipeline([('sc', StandardScaler()), ('clf', LogisticRegression(max_iter=1000))]),
'DecisionTree(d=5)': DecisionTreeClassifier(max_depth=5),
'RandomForest': RandomForestClassifier(random_state=42),
}
for name, model in models.items():
score = cross_val_score(model, X, y, cv=5, scoring='f1').mean()
print(f'{name}: F1={score:.3f}')Vérification rapide
Vérifiez votre compréhension des concepts d'apprentissage automatique avec Python présentés dans cette leçon.
Récapitulatif de la leçon
Dans cette leçon, vous avez appris que : DummyClassifier établit le seuil minimal de performance que tout modèle réel doit dépasser pour apporter de la valeur, les références fondées sur la précision sont trompeuses pour les jeux de données déséquilibrés — utilisez toujours la même métrique pour comparer la référence et le modèle réel, et une référence complète comprend le classifieur trivial, le système actuellement utilisé en production et les performances humaines lorsqu'elles sont disponibles. Nous allons maintenant commencer le cours sur la chaîne de prétraitement des données, en commençant par des stratégies systématiques de gestion des valeurs manquantes à l'aide de techniques d'imputation.
Apprends Python avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 30
- Leçons
- 120
Questions Fréquemment Posées
La leçon « Modèles de référence : toujours dépasser DummyClassifier » est-elle gratuite ?
Oui — le texte complet de « Modèles de référence : toujours dépasser DummyClassifier » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Machine Learning Academy, passe à CoddyKit PRO. Le cours Machine Learning Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Modèles de référence : toujours dépasser DummyClassifier » ?
Construisez un DummyClassifier comme référence minimale et vérifiez que tout modèle réel doit le dépasser avant d’être considéré comme utile. Tu pratiques Machine Learning Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Machine Learning Academy ?
Aucune expérience préalable n'est requise. Machine Learning Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Modèles de référence : toujours dépasser DummyClassifier » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Machine Learning Academy ?
Oui. Chaque leçon Machine Learning Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Pourquoi évaluer sur les données d’entraînement est impossible
- train_test_split : proportions, graines et stratification
- Compromis biais-variance : sous-ajustement ou surajustement
- Modèles de référence : toujours dépasser DummyClassifier