Modelli baseline: battere sempre il classificatore dummy
Costruirà un DummyClassifier come baseline minima e verificherà che ogni modello reale debba superarlo prima di poter essere considerato utile.
Modelli baseline: battere sempre il classificatore dummy è una lezione Machine Learning Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Machine Learning Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Machine Learning Academy include 4 lezioni in totale.
Perché serve una baseline
Quando comunica che il suo modello raggiunge una precisione del 92%, questo numero non ha significato senza un contesto. Il 92% è un risultato impressionante o deludente? Dipende interamente da ciò che otterrebbe la strategia più semplice possibile sullo stesso problema.
Un modello baseline rappresenta il livello minimo che ogni modello reale deve superare per essere considerato utile. Senza una baseline, potrebbe festeggiare una precisione del 92% su un set di dati in cui un modello che predicesse sempre «non frode» raggiungerebbe il 95%: ciò significherebbe che il suo sofisticato modello di ML è in realtà peggiore del non fare nulla.
DummyClassifier: lo strumento baseline di scikit-learn
Scikit-learn fornisce DummyClassifier, un classificatore minimale che esegue previsioni utilizzando regole semplici, completamente indipendenti dalle caratteristiche di input. È lo strumento ufficiale per stabilire una baseline prima di iniziare qualsiasi modellazione reale.
DummyClassifier non è uno scherzo né un segnaposto: è un rigoroso controllo di coerenza. Se il modello reale non riesce a superare DummyClassifier, c'è un problema fondamentale: le caratteristiche potrebbero non essere predittive, la pipeline potrebbe contenere un bug oppure il problema potrebbe essere più difficile del previsto.
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}')Strategie di DummyClassifier
DummyClassifier supporta diverse strategie baseline:
most_frequent: predice sempre la classe più frequente nei dati di addestramento. È la scelta migliore per i set di dati sbilanciati.stratified: predice casualmente ogni classe con una probabilità pari alla sua frequenza nei dati di addestramento. Mantiene la distribuzione delle classi.uniform: predice casualmente ogni classe con la stessa probabilità. È utile quando tutte le classi sono rappresentate in modo uniforme.constant: predice sempre una classe costante specificata. Utilizzatela per verificare cosa accade predicendo sempre la classe positiva.
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}')Il paradosso della precisione in pratica
Il paradosso della precisione è particolarmente evidente nei set di dati sbilanciati. Consideri le frodi con carta di credito, dove il 99% delle transazioni è legittimo. Il most_frequent DummyClassifier predice «non frode» per ogni transazione e raggiunge una precisione del 99%. Un modello di ML reale con una precisione del 97% sembrerebbe peggiore di questa baseline in base alla precisione, anche se identifica correttamente la maggior parte dei casi di frode effettivi.
Per questo motivo, la baseline DummyClassifier deve essere valutata con la stessa metrica che utilizzerà per valutare il modello reale. Per i problemi sbilanciati, utilizzi F1, precisione o richiamo, non la precisione complessiva.
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: baseline per la regressione
Per i problemi di regressione, scikit-learn fornisce DummyRegressor con diverse strategie:
mean: predice sempre la media del set di addestramento. È la baseline standard: R² misura quanto il modello sia migliore rispetto alla semplice previsione della media.median: predice sempre la mediana del set di addestramento. È più robusta rispetto ai valori anomali.quantile: predice sempre uno specifico quantile del target di addestramento.constant: predice sempre una costante specificata.
Un modello di regressione con R² inferiore a 0 è in realtà peggiore della semplice previsione della media: è un chiaro segnale che qualcosa è andato storto durante l'addestramento.
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.0Il suo modello a confronto con la baseline
Ora confronti il modello reale con la baseline utilizzando la stessa metrica. Il miglioramento rispetto alla baseline indica quanto valore aggiunge il modello di ML. Questo confronto dovrebbe essere il primo risultato riportato in qualsiasi progetto di ML.
Se il miglioramento è ridotto (ad esempio, il modello reale raggiunge F1=0.65 rispetto a F1=0.60 della baseline), si chieda se la complessità e il costo del modello di ML valgano un miglioramento del 5%. Talvolta un sistema semplice basato su regole è più economico e sufficientemente accurato.
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}')Le prestazioni a livello umano come seconda baseline
Per molti problemi del mondo reale, un benchmark delle prestazioni a livello umano è più rilevante di una baseline dummy. Ad esempio, il tasso di errore di un radiologo nel rilevare tumori, la precisione di una persona che esamina lo spam o l'errore nella stima del prezzo di una casa da parte di un perito esperto.
Le prestazioni umane forniscono un limite superiore: se il modello raggiunge o supera le prestazioni umane, il problema è stato risolto. Se il modello è molto al di sotto delle prestazioni umane, c'è ancora margine di miglioramento. Se il modello è molto vicino alle prestazioni umane, migliorarlo ulteriormente potrebbe richiedere uno sforzo straordinario a fronte di rendimenti decrescenti.
Il sistema precedente come baseline
Nel settore industriale, il riferimento di base più rilevante è solitamente il sistema esistente che il modello sta sostituendo. Se il sistema attualmente in produzione utilizza regole definite manualmente, è questo il riferimento da superare. Se è stato distribuito un precedente modello di ML, le sue metriche in produzione costituiscono il riferimento.
Quando comunica i risultati agli stakeholder, confronti sempre il modello con il sistema attuale, non solo con un DummyClassifier. Il valore per l'azienda deriva dal miglioramento rispetto allo status quo. Un miglioramento del 2% rispetto al sistema attuale può valere milioni di dollari in perdite per frodi evitate, anche se in termini assoluti può sembrare ridotto.
Riferimento per la classificazione multiclasse
Per i problemi multiclasse, il riferimento del DummyClassifier dipende dall'equilibrio tra le classi. Con K classi bilanciate, la strategia most_frequent raggiunge un'accuratezza pari a 1/K. Con classi sbilanciate, raggiunge la proporzione della classe più frequente.
Per metriche come l'F1 macro-mediato (che assegna lo stesso peso a tutte le classi), un classificatore casuale otterrà un punteggio molto più basso sulle classi rare. Confronti sempre le metriche per classe tra il modello reale e il riferimento, per capire da dove deriva il miglioramento.
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')Classificatore Zero-Rule: il riferimento più semplice
Ancora più semplice del DummyClassifier è il classificatore Zero-Rule (ZeroR), un riferimento comune nelle competizioni di data science. Nella classificazione, ZeroR predice sempre la classe maggioritaria. Nella regressione, predice sempre la media. ZeroR rappresenta il minimo assoluto che qualsiasi modello deve superare per risultare utile.
Se non riesce a superare ZeroR, le sue feature non contengono informazioni sulla variabile target. Questo controllo diagnostico è rapido e non comporta costi di calcolo, quindi dovrebbe sempre essere il primo passaggio di qualsiasi nuovo progetto di ML, prima di dedicare tempo a modelli complessi.
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}')Riferimenti bagging nei progetti di ML
Un flusso di lavoro completo per la valutazione dei riferimenti in qualsiasi progetto di ML:
- Calcoli il riferimento di DummyClassifier (
most_frequent) o di DummyRegressor (mean). - Se disponibile, calcoli il riferimento del sistema attuale utilizzando le sue predizioni sul set di test.
- Ricerchi le prestazioni a livello umano in benchmark o pubblicazioni.
- Addestri il primo modello di ML semplice (una regressione logistica o un albero decisionale poco profondo) e confronti tutti e tre i risultati.
- Proceda con modelli complessi solo se il modello semplice supera il riferimento con un margine significativo: la complessità deve essere motivata da un miglioramento misurabile.
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}')Controllo rapido
Verifichi la sua comprensione dei concetti di Machine Learning con Python presentati in questa lezione.
Riepilogo della lezione
In questa lezione ha imparato che: DummyClassifier stabilisce il livello minimo di prestazioni che ogni modello reale deve superare per fornire valore, i riferimenti basati sull'accuratezza sono fuorvianti per i dataset sbilanciati: utilizzi sempre la stessa metrica per confrontare il riferimento e il modello reale e un riferimento completo include il classificatore banale, il sistema attualmente in produzione e le prestazioni a livello umano, quando disponibili. Prossimamente inizieremo il corso Data Preprocessing Pipeline, partendo da strategie sistematiche per gestire i valori mancanti mediante tecniche di imputazione.
Impara Python con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 30
- Lezioni
- 120
Domande Frequenti
La lezione «Modelli baseline: battere sempre il classificatore dummy» è gratuita?
Sì — il testo completo di «Modelli baseline: battere sempre il classificatore dummy» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Machine Learning Academy, passa a CoddyKit PRO. Il corso Machine Learning Academy include 4 lezioni in totale.
Cosa imparerò in «Modelli baseline: battere sempre il classificatore dummy»?
Costruirà un DummyClassifier come baseline minima e verificherà che ogni modello reale debba superarlo prima di poter essere considerato utile. Eserciti Machine Learning Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Machine Learning Academy?
Non è richiesta alcuna esperienza precedente. Machine Learning Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Modelli baseline: battere sempre il classificatore dummy»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Machine Learning Academy?
Sì. Ogni lezione Machine Learning Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Perché non si può valutare un modello sui dati di addestramento
- train_test_split: proporzioni, seed e stratificazione
- Compromesso bias-varianza: underfitting e overfitting
- Modelli baseline: battere sempre il classificatore dummy