Scikit-learn (sklearn) Cheat Sheet
Ultimo aggiornamento
Caricare e dividere i dati
Metti da parte un test set prima di tutto il resto, e guardalo solo alla fine.
| Attività | Codice |
|---|---|
| Importare lo splitter | from sklearn.model_selection import train_test_split |
| Feature e target da un DataFrame | X = df.drop(columns="target")
y = df["target"] |
| Dataset integrato come pandas | from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True, as_frame=True) |
| Dati sintetici per sperimentare | from sklearn.datasets import make_classification
X, y = make_classification(n_samples=500, n_features=8, random_state=0) |
| Split 80/20 tra train e test | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) |
| Mantenere le proporzioni delle classi | train_test_split(X, y, test_size=0.2, stratify=y, random_state=42) |
| Train, validation e test (60/20/20) | X_tmp, X_test, y_tmp, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
X_train, X_val, y_train, y_val = train_test_split(X_tmp, y_tmp, test_size=0.25, random_state=0) |
Preprocessing delle feature
Fai il fit di un transformer solo sui dati di training, poi trasforma entrambi i set. Il fit sui dati di test causa data leakage.
| Attività | Codice |
|---|---|
| Import | from sklearn.preprocessing import StandardScaler, MinMaxScaler, OneHotEncoder, OrdinalEncoder |
| Scalare a media 0 e deviazione standard 1 | scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train[["age", "income"]])
X_test_s = scaler.transform(X_test[["age", "income"]]) |
| Scalare nell'intervallo da 0 a 1 | MinMaxScaler().fit_transform(X_train[["age", "income"]]) |
| One-hot encoding delle categorie | enc = OneHotEncoder(handle_unknown="ignore", sparse_output=False)
enc.fit_transform(X_train[["city"]]) |
| Categorie ordinate in numeri | OrdinalEncoder(categories=[["low", "mid", "high"]]).fit_transform([["mid"], ["high"]]) |
| Riempire i valori mancanti | from sklearn.impute import SimpleImputer
SimpleImputer(strategy="median").fit_transform(X_train[["age", "income"]]) |
| Feature polinomiali e di interazione | from sklearn.preprocessing import PolynomialFeatures
PolynomialFeatures(degree=2, include_bias=False).fit_transform(X_train[["age", "income"]]) |
| Ottenere DataFrame invece di array | scaler.set_output(transform="pandas") |
| Etichette testuali in interi | from sklearn.preprocessing import LabelEncoder
LabelEncoder().fit_transform(["cat", "dog", "cat"]) |
Scegliere un modello
Parti semplice e usa il modello semplice come punteggio da battere.
| Problema | Inizia con | Poi prova |
|---|---|---|
| Prevedere un numero (regressione) | LinearRegression(), Ridge(alpha=1.0) | RandomForestRegressor(), HistGradientBoostingRegressor() |
| Prevedere una classe (classificazione) | LogisticRegression(max_iter=1000) | RandomForestClassifier(), HistGradientBoostingClassifier() |
| Pochi dati, punti simili con la stessa etichetta | KNeighborsClassifier(n_neighbors=5) | SVC(kernel="rbf") |
| Regole leggibili | DecisionTreeClassifier(max_depth=3) | RandomForestClassifier() |
| Raggruppare righe senza etichette | KMeans(n_clusters=3) | DBSCAN(eps=0.5) |
| Meno feature per grafici o velocità | PCA(n_components=2) | TSNE(n_components=2) |
| Trovare righe anomale | IsolationForest(random_state=0) | LocalOutlierFactor() |
Addestrare un modello
Ogni estimator segue lo stesso schema: crealo con le sue impostazioni, poi chiama fit.
| Attività | Codice |
|---|---|
| Lo schema per ogni modello | model = LogisticRegression(max_iter=1000)
model.fit(X_train, y_train) |
| Regressione lineare | from sklearn.linear_model import LinearRegression
LinearRegression() |
| Regressione lineare regolarizzata | from sklearn.linear_model import Ridge, Lasso
Ridge(alpha=1.0), Lasso(alpha=0.1) |
| Regressione logistica (classificazione) | from sklearn.linear_model import LogisticRegression
LogisticRegression(C=1.0, max_iter=1000) |
| k nearest neighbors | from sklearn.neighbors import KNeighborsClassifier
KNeighborsClassifier(n_neighbors=5) |
| Albero decisionale | from sklearn.tree import DecisionTreeClassifier
DecisionTreeClassifier(max_depth=3, random_state=0) |
| Random forest | from sklearn.ensemble import RandomForestClassifier
RandomForestClassifier(n_estimators=200, random_state=0) |
| Gradient boosting, veloce su grandi dati | from sklearn.ensemble import HistGradientBoostingClassifier
HistGradientBoostingClassifier(random_state=0) |
| Support vector machine | from sklearn.svm import SVC
SVC(kernel="rbf", C=1.0) |
| Naive Bayes | from sklearn.naive_bayes import GaussianNB
GaussianNB() |
| Baseline che indovina sempre la maggioranza | from sklearn.dummy import DummyClassifier
DummyClassifier(strategy="most_frequent") |
Prevedere e ispezionare
| Attività | Codice |
|---|---|
| Prevedere classi o valori | y_pred = model.predict(X_test) |
| Probabilità della classe positiva | model.predict_proba(X_test)[:, 1] |
| Punteggio rapido: accuracy o R² | model.score(X_test, y_test) |
| Coefficienti di un modello lineare | model.coef_, model.intercept_ |
| Importanza delle feature di un modello ad albero | pd.Series(forest.feature_importances_, index=X_train.columns).sort_values() |
| Importanza mescolando ogni feature | from sklearn.inspection import permutation_importance
permutation_importance(model, X_test, y_test, random_state=0).importances_mean |
| Classi che il modello conosce | model.classes_ |
| Leggere e cambiare le impostazioni | model.get_params(), model.set_params(C=0.5) |
| Disegnare un albero decisionale | from sklearn.tree import plot_tree
plot_tree(tree, filled=True, feature_names=list(X_train.columns)) |
Metriche di classificazione
L'accuracy da sola nasconde gli errori su una classe rara. Controlla anche precision, recall e la matrice di confusione.
| Attività | Codice |
|---|---|
| Import | from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score |
| Accuracy | accuracy_score(y_test, y_pred) |
| Precision, recall e F1 | precision_score(y_test, y_pred), recall_score(y_test, y_pred), f1_score(y_test, y_pred) |
| F1 per più classi | f1_score(y_test, y_pred, average="macro") |
| Tutte le metriche per classe | from sklearn.metrics import classification_report
print(classification_report(y_test, y_pred)) |
| Matrice di confusione | from sklearn.metrics import confusion_matrix
confusion_matrix(y_test, y_pred) |
| Grafico della matrice di confusione | from sklearn.metrics import ConfusionMatrixDisplay
ConfusionMatrixDisplay.from_estimator(model, X_test, y_test) |
| ROC AUC dalle probabilità | from sklearn.metrics import roc_auc_score
roc_auc_score(y_test, model.predict_proba(X_test)[:, 1]) |
| Grafico della curva ROC | from sklearn.metrics import RocCurveDisplay
RocCurveDisplay.from_estimator(model, X_test, y_test) |
| Accuracy per classi sbilanciate | from sklearn.metrics import balanced_accuracy_score
balanced_accuracy_score(y_test, y_pred) |
| La tua soglia di decisione | y_pred = (model.predict_proba(X_test)[:, 1] >= 0.3).astype(int) |
Metriche di regressione
Le metriche di errore sono nelle unità del target (più basso è meglio). R² è la quota di varianza spiegata (1 è perfetto).
| Attività | Codice |
|---|---|
| Import | from sklearn.metrics import mean_absolute_error, mean_squared_error, root_mean_squared_error, r2_score |
| Errore assoluto medio | mean_absolute_error(y_test, y_pred) |
| Errore quadratico medio e la sua radice | mean_squared_error(y_test, y_pred), root_mean_squared_error(y_test, y_pred) |
| Punteggio R² | r2_score(y_test, y_pred) |
| Errore percentuale assoluto medio | from sklearn.metrics import mean_absolute_percentage_error
mean_absolute_percentage_error(y_test, y_pred) |
| Grafico previsti contro reali | from sklearn.metrics import PredictionErrorDisplay
PredictionErrorDisplay.from_predictions(y_test, y_pred, kind="actual_vs_predicted") |
Pipeline
Una pipeline concatena preprocessing e modello in un unico estimator, così cross-validation e grid search fanno il fit di ogni passaggio solo sui fold di training.
| Attività | Codice |
|---|---|
| Import | from sklearn.pipeline import make_pipeline, Pipeline |
| Scalare, poi addestrare un modello | pipe = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))
pipe.fit(X_train, y_train) |
| Passaggi con nomi tuoi | pipe = Pipeline([("scale", StandardScaler()), ("model", LogisticRegression(max_iter=1000))]) |
| Accedere a un passaggio interno | pipe.named_steps["model"], pipe[-1] |
| Passaggi diversi per colonne diverse | from sklearn.compose import ColumnTransformer
pre = ColumnTransformer([
("num", StandardScaler(), ["age", "income"]),
("cat", OneHotEncoder(handle_unknown="ignore"), ["city"]),
]) |
| Preprocessing e modello in un oggetto | model = make_pipeline(pre, RandomForestClassifier(random_state=0))
model.fit(X_train, y_train)
model.score(X_test, y_test) |
| Scegliere le colonne per tipo | from sklearn.compose import make_column_selector
make_column_selector(dtype_include="number")(X_train) |
| Imputare, poi scalare | make_pipeline(SimpleImputer(strategy="median"), StandardScaler()) |
| Nomi delle feature in uscita | pre.get_feature_names_out() |
Cross-validation
La cross-validation addestra e valuta il modello su più split, e dà una stima più stabile di un singolo test set.
| Attività | Codice |
|---|---|
| Import | from sklearn.model_selection import cross_val_score, cross_validate, KFold, StratifiedKFold |
| Punteggio su 5 fold | scores = cross_val_score(pipe, X, y, cv=5)
scores.mean(), scores.std() |
| Scegliere la metrica | cross_val_score(pipe, X, y, cv=5, scoring="f1_macro") |
| Fold mescolati | cv = KFold(n_splits=5, shuffle=True, random_state=0) |
| Stesso bilanciamento delle classi in ogni fold | cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=0) |
| Più metriche e punteggi di training | cross_validate(pipe, X, y, cv=cv, scoring=["accuracy", "f1"], return_train_score=True) |
| Una previsione out-of-fold per ogni riga | from sklearn.model_selection import cross_val_predict
cross_val_predict(pipe, X, y, cv=5) |
| Fold per gruppo, fold in ordine temporale | from sklearn.model_selection import GroupKFold, TimeSeriesSplit
GroupKFold(n_splits=5), TimeSeriesSplit(n_splits=5) |
| Tutti i nomi di scoring validi | from sklearn.metrics import get_scorer_names
get_scorer_names() |
Grid search e tuning
Una ricerca addestra il modello per ogni impostazione con la cross-validation, tiene la migliore e la riaddestra su tutti i dati di training.
| Attività | Codice |
|---|---|
| Import | from sklearn.model_selection import GridSearchCV, RandomizedSearchCV |
| Provare ogni combinazione | grid = GridSearchCV(RandomForestClassifier(random_state=0), {"n_estimators": [50, 100], "max_depth": [None, 5]}, cv=5)
grid.fit(X_train, y_train) |
| Impostazioni migliori e il loro punteggio | grid.best_params_, grid.best_score_ |
| Usare il modello migliore | grid.best_estimator_.predict(X_test), grid.score(X_test, y_test) |
| Ottimizzare un passaggio della pipeline | GridSearchCV(pipe, {"logisticregression__C": [0.1, 1, 10]}, cv=5).fit(X_train, y_train) |
| Impostazioni casuali da distribuzioni | from scipy.stats import randint
search = RandomizedSearchCV(RandomForestClassifier(random_state=0), {"n_estimators": randint(50, 150)}, n_iter=5, cv=3, random_state=0)
search.fit(X_train, y_train) |
| Usare tutti i core della CPU | GridSearchCV(pipe, {"logisticregression__C": [0.1, 1]}, cv=5, n_jobs=-1) |
| Tutti i risultati in una tabella | pd.DataFrame(grid.cv_results_).sort_values("rank_test_score") |
Clustering e riduzione della dimensionalità
I modelli non supervisionati imparano solo da X. Scala prima le feature, perché entrambi usano le distanze.
| Attività | Codice |
|---|---|
| Cluster con k-means | from sklearn.cluster import KMeans
km = KMeans(n_clusters=3, random_state=0)
labels = km.fit_predict(X) |
| Centri dei cluster e inertia | km.cluster_centers_, km.inertia_ |
| Quanto sono separati i cluster | from sklearn.metrics import silhouette_score
silhouette_score(X, labels) |
| Cluster basati sulla densità, il rumore è -1 | from sklearn.cluster import DBSCAN
DBSCAN(eps=0.5, min_samples=5).fit_predict(X) |
| Proiettare su 2 componenti | from sklearn.decomposition import PCA
pca = PCA(n_components=2)
X_2d = pca.fit_transform(X) |
| Varianza spiegata da ogni componente | pca.explained_variance_ratio_ |
| Mantenere il 95% della varianza | PCA(n_components=0.95).fit_transform(X) |
scikit-learn 1.9: vecchie forme e cosa scrivere ora
Il codice copiato da tutorial più vecchi può dare errore o avvisi in scikit-learn 1.9. Usa invece le forme della colonna scikit-learn 1.9.
| Attività | scikit-learn 1.9 | Vecchia forma |
|---|---|---|
| Radice dell'errore quadratico medio | root_mean_squared_error(y_test, y_pred) | mean_squared_error(y_test, y_pred, squared=False) |
| Output one-hot denso | OneHotEncoder(sparse_output=False) | OneHotEncoder(sparse=False) |
| Regressione logistica L1 (lasso) | LogisticRegression(l1_ratio=1, solver="liblinear") | LogisticRegression(penalty="l1", solver="liblinear") |
| Regressione logistica senza regolarizzazione | LogisticRegression(C=np.inf) | LogisticRegression(penalty=None) |
Salvare, caricare e riprodurre
| Attività | Codice |
|---|---|
| Salvare un modello o una pipeline addestrati | import joblib
joblib.dump(model, "model.joblib") |
| Ricaricarlo | model = joblib.load("model.joblib") |
| Stesso risultato a ogni esecuzione | random_state=0 |
| Quale versione è installata | import sklearn
sklearn.__version__ |
Il codice scikit-learn dietro un vero flusso di lavoro di machine learning, nell'ordine in cui lo scrivi: caricare e dividere i dati, fare il preprocessing, scegliere un modello, fare fit e predict, misurare il risultato, concatenare i passaggi in una pipeline, fare cross-validation e ottimizzare con la grid search. Ogni riga è un breve snippet da incollare, con una riga che spiega cosa fa.
Tutti i modelli di scikit-learn condividono la stessa API: fit impara dai dati di training, predict e transform applicano ciò che ha imparato. Tutto è scritto per scikit-learn 1.9, la versione che usa Coddy, con X per le feature e y per il target. scikit-learn lavora su array NumPy e DataFrame pandas, e il cheat sheet di Matplotlib copre i grafici. Sei alle prime armi con Python? Parti dal Python cheat sheet.
FAQ sul cheat sheet di scikit-learn
Questo cheat sheet di scikit-learn è gratuito?
Sì. Questo cheat sheet di scikit-learn è completamente gratuito e non serve registrarsi. Salvalo nei preferiti o stampalo in PDF dal browser, e tornaci ogni volta che ti serve la chiamata esatta per una pipeline, una metrica o una grid search.
sklearn e scikit-learn sono la stessa cosa?
Sì. scikit-learn è il nome della libreria e del pacchetto che installi (
pip install scikit-learn), mentre sklearn è il nome che importi nel codice (from sklearn.linear_model import LinearRegression). Un cheat sheet di sklearn e uno di scikit-learn coprono la stessa cosa.Qual è la differenza tra fit, transform e fit_transform?
fit impara dai dati: uno scaler impara la media di ogni colonna, un modello impara i suoi pesi. transform applica ciò che ha imparato, e fit_transform fa entrambe le cose in una sola chiamata. Usa fit_transform sul training set e solo transform sul test set, altrimenti i dati di test finiscono nel training. Una pipeline lo fa al posto tuo.Devo scalare le feature?
Per i modelli che usano distanze o gradienti, sì: k nearest neighbors, SVM, k-means, PCA e la regressione lineare e logistica regolarizzata funzionano tutti meglio su dati scalati. I modelli ad albero come alberi decisionali, random forest e gradient boosting non hanno bisogno di scaling. Metti lo scaler in una pipeline, così viene addestrato solo sui dati di training.
Con quale modello di scikit-learn dovrei iniziare?
Parti da un modello semplice e veloce come baseline:
LinearRegression per prevedere numeri, LogisticRegression per prevedere classi. Poi prova RandomForestClassifier o HistGradientBoostingClassifier (o le loro versioni regressor), confrontali con la cross-validation e ottimizza il migliore con GridSearchCV.Quale versione di scikit-learn copre questo cheat sheet?
scikit-learn 1.9, la versione che usa Coddy, con NumPy 2 e pandas 3. Le chiamate più vecchie che ora danno errore o avvisi, come
squared=False in mean_squared_error, sparse=False in OneHotEncoder e l'argomento penalty di LogisticRegression, sono nella tabella delle vecchie forme accanto a cosa scrivere al loro posto.Posso eseguire codice scikit-learn online?
Sì. Il playground Matplotlib gratuito esegue Python con scikit-learn, pandas, NumPy e Matplotlib nel browser, così puoi incollare qualsiasi snippet di questo cheat sheet ed eseguirlo senza installare nulla. Il corso di Machine Learning di Coddy insegna passo dopo passo l'intero flusso di lavoro di questa pagina, dalla divisione dei dati all'ottimizzazione di un modello.
Risorse correlate
Altre cheat sheet
