Torneo di selezione dei modelli: confronto tra cinque algoritmi
Addestrerà una regressione logistica, una random forest, XGBoost, una SVM e una rete neurale all'interno di pipeline con CV annidata e tabulerà le prestazioni su un test set condiviso.
Torneo di selezione dei modelli: confronto tra cinque algoritmi è una lezione Machine Learning Academy gratuita su CoddyKit. Questa è la lezione 3 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é confrontare più algoritmi?
Nessun singolo algoritmo è superiore su tutti i dataset. Il teorema No Free Lunch dimostra che, considerando la media su tutti i problemi possibili, ogni algoritmo ha le stesse prestazioni — ciò significa che è necessario confrontare empiricamente gli algoritmi sui propri dati specifici. Un torneo di selezione dei modelli addestra e valuta sistematicamente diversi algoritmi in condizioni identiche, rivelando quale si adatta meglio alla struttura dei dati. Il vincitore potrà passare alla fase di ottimizzazione degli iperparametri e alla valutazione per il deployment.
Configurazione dell’infrastruttura condivisa della pipeline
Per un confronto equo, ogni algoritmo deve partire dalla stessa matrice di feature preprocessata e deve essere valutato sullo stesso test set messo da parte. Racchiuda ogni algoritmo in una Pipeline che includa il preprocessing, in modo che il preprocessing venga adattato solo ai fold di training. Usi un random_state fisso ovunque per garantire la riproducibilità. Tenga il test set al sicuro: non lo consulti fino alla valutazione finale, eseguita una sola volta, del vincitore del torneo.
import numpy as np
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
from sklearn.model_selection import train_test_split, cross_val_score
# Load preprocessed data
X, y = load_features() # returns numpy arrays after EDA cleaning
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y
)
print(f'Training set: {X_train.shape[0]} samples')
print(f'Test set (LOCKED): {X_test.shape[0]} samples')
print(f'Positive class rate (train): {y_train.mean():.3f}')Concorrente 1: regressione logistica
La regressione logistica è il baseline lineare essenziale. È interpretabile (i coefficienti mostrano l’effetto delle feature), è rapida da addestrare e funziona bene quando il confine decisionale è approssimativamente lineare. Nel torneo funge da livello di riferimento minimo: se i modelli basati su alberi non riescono a superarla in modo significativo, il dataset potrebbe non contenere pattern non lineari complessi che valga la pena catturare con modelli più complessi. Usi class_weight='balanced' per i dataset sbilanciati.
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
lr_pipe = Pipeline([
('scaler', StandardScaler()),
('clf', LogisticRegression(
C=1.0,
class_weight='balanced',
max_iter=1000,
random_state=42
))
])
cv_scores = cross_val_score(lr_pipe, X_train, y_train, cv=5, scoring='roc_auc')
print(f'Logistic Regression — AUC: {cv_scores.mean():.4f} +/- {cv_scores.std():.4f}')Concorrente 2: Random Forest
Random Forest gestisce naturalmente relazioni non lineari, interazioni tra feature e tipi di dati misti, senza bisogno di ridimensionare le feature. Produce valori affidabili di importanza delle feature ed è robusto rispetto agli outlier. Nelle competizioni è spesso il secondo algoritmo migliore dopo il gradient boosting e costituisce un baseline solido per i dati tabellari. Imposti n_estimators=200 e class_weight='balanced' per una configurazione predefinita valida.
from sklearn.ensemble import RandomForestClassifier
rf_pipe = Pipeline([
('clf', RandomForestClassifier(
n_estimators=200,
max_depth=10,
class_weight='balanced',
random_state=42,
n_jobs=-1
))
])
cv_scores = cross_val_score(rf_pipe, X_train, y_train, cv=5, scoring='roc_auc')
print(f'Random Forest — AUC: {cv_scores.mean():.4f} +/- {cv_scores.std():.4f}')Concorrente 3: XGBoost
XGBoost è il vincitore citato più comunemente nelle competizioni di ML su dati tabellari. Il suo boosting sequenziale corregge gli errori residui a ogni passaggio, ottenendo prestazioni elevate sui dati strutturati. Valori predefiniti chiave per un’esecuzione del torneo: n_estimators=300, learning_rate=0.05, max_depth=6 e scale_pos_weight impostato sul rapporto tra la classe negativa e quella positiva per gestire lo sbilanciamento. Passi eval_set per abilitare facoltativamente l’arresto anticipato.
from xgboost import XGBClassifier
import numpy as np
# Compute class imbalance ratio
neg_count = (y_train == 0).sum()
pos_count = (y_train == 1).sum()
xgb_pipe = Pipeline([
('clf', XGBClassifier(
n_estimators=300,
learning_rate=0.05,
max_depth=6,
scale_pos_weight=neg_count / pos_count,
use_label_encoder=False,
eval_metric='logloss',
random_state=42,
n_jobs=-1
))
])
cv_scores = cross_val_score(xgb_pipe, X_train, y_train, cv=5, scoring='roc_auc')
print(f'XGBoost — AUC: {cv_scores.mean():.4f} +/- {cv_scores.std():.4f}')Concorrente 4: Support Vector Machine
SVM con kernel RBF eccelle sui dataset con classi chiaramente separate e poche feature irrilevanti. Richiede molta memoria (conserva i vettori di supporto) ed è lenta sui dataset di grandi dimensioni (tempo di addestramento da O(n²) a O(n³)), ma può superare i modelli ad albero sui dataset più piccoli con confini complessi. Standardizzi le feature prima dell’addestramento: le SVM sono molto sensibili alla scala delle feature. Usi probability=True per ottenere probabilità calibrate da usare nella valutazione dell’AUC.
from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
svm_pipe = Pipeline([
('scaler', StandardScaler()),
('clf', SVC(
C=1.0,
kernel='rbf',
gamma='scale',
class_weight='balanced',
probability=True,
random_state=42
))
])
cv_scores = cross_val_score(svm_pipe, X_train, y_train, cv=5, scoring='roc_auc')
print(f'SVM (RBF) — AUC: {cv_scores.mean():.4f} +/- {cv_scores.std():.4f}')Concorrente 5: rete neurale
Un semplice percettrone multistrato (MLP) con 2-3 strati nascosti può catturare pattern non lineari complessi, ma richiede un attento ridimensionamento, una regolarizzazione e tempi di addestramento più lunghi rispetto ai modelli basati su alberi quando si lavora con dati tabellari. Lo utilizzi quando gli altri quattro algoritmi raggiungono tutti lo stesso livello di prestazioni, suggerendo che il confine decisionale richieda una modellazione con maggiore capacità. sklearn.neural_network.MLPClassifier è comodo per il torneo e non richiede una configurazione completa di PyTorch.
from sklearn.neural_network import MLPClassifier
from sklearn.preprocessing import StandardScaler
mlp_pipe = Pipeline([
('scaler', StandardScaler()),
('clf', MLPClassifier(
hidden_layer_sizes=(128, 64),
activation='relu',
alpha=0.01, # L2 regularisation
max_iter=300,
early_stopping=True,
validation_fraction=0.1,
random_state=42
))
])
cv_scores = cross_val_score(mlp_pipe, X_train, y_train, cv=5, scoring='roc_auc')
print(f'MLP Neural Network — AUC: {cv_scores.mean():.4f} +/- {cv_scores.std():.4f}')Consolidamento dei risultati in una classifica
Raccolga tutti i punteggi AUC della CV a 5 fold in una tabella ordinata in base all’AUC media. Registri anche la deviazione standard: un modello con un’AUC media leggermente inferiore ma una varianza molto più bassa potrebbe essere preferibile per il deployment, perché le sue prestazioni sono più prevedibili tra diverse partizioni dei dati. Mostri i risultati con un grafico a barre orizzontali per facilitarne la comunicazione agli stakeholder.
import pandas as pd
import matplotlib.pyplot as plt
results = {
'Logistic Regression': (0.821, 0.013),
'Random Forest': (0.867, 0.009),
'XGBoost': (0.883, 0.007),
'SVM (RBF)': (0.845, 0.011),
'MLP Neural Network': (0.858, 0.010)
}
df_results = pd.DataFrame(results, index=['AUC_mean', 'AUC_std']).T
df_results = df_results.sort_values('AUC_mean', ascending=False)
print(df_results.to_string())
df_results['AUC_mean'].plot(kind='barh', xerr=df_results['AUC_std'], figsize=(8, 4))
plt.xlabel('5-fold CV AUC')
plt.title('Model Selection Tournament Results')
plt.tight_layout()
plt.savefig('tournament.png', dpi=150)Significatività statistica delle differenze
Una differenza di 0,002 nell’AUC tra due modelli potrebbe essere dovuta semplicemente al rumore introdotto dalla partizione casuale dei dati. Usi un t-test appaiato o il test dei ranghi con segno di Wilcoxon sui punteggi dei singoli fold per determinare se la differenza è statisticamente significativa. Se il p-value supera 0,05, scelga il modello più semplice: la sua minore complessità lo rende più facile da sottoporre a debug, spiegare e mantenere in produzione.
from scipy import stats
import numpy as np
# Simulated per-fold scores for XGBoost vs Random Forest
xgb_folds = np.array([0.889, 0.881, 0.875, 0.883, 0.887])
rf_folds = np.array([0.871, 0.863, 0.869, 0.865, 0.867])
# Paired t-test
t_stat, p_value = stats.ttest_rel(xgb_folds, rf_folds)
print(f'XGBoost mean: {xgb_folds.mean():.4f}')
print(f'Random Forest mean: {rf_folds.mean():.4f}')
print(f'Paired t-test: t={t_stat:.3f}, p={p_value:.4f}')
if p_value < 0.05:
print('Difference is statistically significant — prefer XGBoost.')
else:
print('Difference is NOT significant — prefer simpler model (Random Forest).')Valutazione una tantum sul test set
Dopo aver selezionato il vincitore del torneo, lo valuti esattamente una volta sul test set messo da parte. Questa è la stima imparziale delle prestazioni da riportare nella model card. Non ottimizzi mai gli iperparametri dopo aver visto i risultati sul test set: farlo costituisce una fuga di dati attraverso il processo di valutazione. Se l’AUC sul test è sostanzialmente inferiore all’AUC della CV (di oltre 2-3 deviazioni standard), verifichi la presenza di overfitting o di uno spostamento della distribuzione tra le suddivisioni di training e test.
from sklearn.metrics import roc_auc_score, classification_report
# Fit winner on full training set
best_pipeline = xgb_pipe
best_pipeline.fit(X_train, y_train)
# One-time test evaluation
y_proba = best_pipeline.predict_proba(X_test)[:, 1]
y_pred = best_pipeline.predict(X_test)
test_auc = roc_auc_score(y_test, y_proba)
print(f'Test AUC: {test_auc:.4f}')
print('\nClassification report:')
print(classification_report(y_test, y_pred, target_names=['retained', 'churned']))Scelta del vincitore: oltre l’AUC
L’AUC non è l’unico criterio. Consideri: l’interpretabilità (la regressione logistica potrebbe essere obbligatoria per la conformità normativa), il tempo di addestramento (se esegue un nuovo addestramento settimanale su 10M di righe, il vantaggio in termini di velocità di XGBoost è importante), l’occupazione di memoria (una SVM che conserva 100k vettori di supporto potrebbe superare il budget per il deployment) e l’equità (il modello con l’AUC più elevata potrebbe avere una parità demografica peggiore). Il torneo seleziona il candidato; la sua idoneità al deployment è una decisione distinta e basata su più criteri.
# Multi-criteria scoring table
criteria = {
'AUC': {'XGBoost': 5, 'RandomForest': 4, 'LogReg': 2, 'SVM': 3, 'MLP': 4},
'Interpretability': {'XGBoost': 3, 'RandomForest': 3, 'LogReg': 5, 'SVM': 2, 'MLP': 1},
'Training speed': {'XGBoost': 4, 'RandomForest': 4, 'LogReg': 5, 'SVM': 2, 'MLP': 3},
'Memory': {'XGBoost': 4, 'RandomForest': 3, 'LogReg': 5, 'SVM': 2, 'MLP': 3}
}
import pandas as pd
df_crit = pd.DataFrame(criteria).T
df_crit.loc['Total'] = df_crit.sum()
print(df_crit)Verifica rapida
Verifichi la Sua comprensione dei concetti di Machine Learning con Python trattati in questa lezione.
Riepilogo della lezione
In questa lezione ha imparato che: ogni algoritmo deve essere racchiuso in una Pipeline e valutato con fold CV identici sullo stesso training set, la classifica del torneo ordina i modelli in base all’AUC media della CV, usando un test di significatività appaiato per distinguere le differenze reali da quelle dovute al rumore e il test set viene utilizzato una sola volta, sul modello vincitore, per produrre una stima onesta delle prestazioni da inserire nella model card. Ora passeremo a impacchettare, documentare e presentare il modello finale per il deployment.
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 «Torneo di selezione dei modelli: confronto tra cinque algoritmi» è gratuita?
Sì — il testo completo di «Torneo di selezione dei modelli: confronto tra cinque algoritmi» è 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 «Torneo di selezione dei modelli: confronto tra cinque algoritmi»?
Addestrerà una regressione logistica, una random forest, XGBoost, una SVM e una rete neurale all'interno di pipeline con CV annidata e tabulerà le prestazioni su un test set condiviso. 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 3 di 4.
Quanto tempo richiede la lezione «Torneo di selezione dei modelli: confronto tra cinque algoritmi»?
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
- Definizione dell'ambito del progetto: problema e criteri di successo
- Data wrangling e analisi esplorativa dei dati
- Torneo di selezione dei modelli: confronto tra cinque algoritmi
- Packaging, documentazione e presentazione del modello finale