Scikit-learn (sklearn) Cheat Sheet: ściąga ze scikit-learn
Ostatnia aktualizacja
Wczytanie i podział danych
Zanim zrobisz cokolwiek innego, odłóż zbiór testowy i zajrzyj do niego dopiero na samym końcu.
| Zadanie | Kod |
|---|---|
| Import funkcji podziału | from sklearn.model_selection import train_test_split |
| Cechy i cel z DataFrame'u | X = df.drop(columns="target")
y = df["target"] |
| Wbudowany zbiór jako pandas | from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True, as_frame=True) |
| Syntetyczne dane do eksperymentów | from sklearn.datasets import make_classification
X, y = make_classification(n_samples=500, n_features=8, random_state=0) |
| Podział 80/20 na trening i test | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) |
| Te same proporcje klas w obu częściach | train_test_split(X, y, test_size=0.2, stratify=y, random_state=42) |
| Trening, walidacja i 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 cech
Dopasuj transformator tylko na danych treningowych, potem przekształć oba zbiory. Dopasowanie na danych testowych to wyciek informacji.
| Zadanie | Kod |
|---|---|
| Importy | from sklearn.preprocessing import StandardScaler, MinMaxScaler, OneHotEncoder, OrdinalEncoder |
| Skalowanie do średniej 0 i odchylenia 1 | scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train[["age", "income"]])
X_test_s = scaler.transform(X_test[["age", "income"]]) |
| Skalowanie do zakresu od 0 do 1 | MinMaxScaler().fit_transform(X_train[["age", "income"]]) |
| Kodowanie one-hot kategorii | enc = OneHotEncoder(handle_unknown="ignore", sparse_output=False)
enc.fit_transform(X_train[["city"]]) |
| Kategorie uporządkowane jako liczby | OrdinalEncoder(categories=[["low", "mid", "high"]]).fit_transform([["mid"], ["high"]]) |
| Uzupełnianie braków | from sklearn.impute import SimpleImputer
SimpleImputer(strategy="median").fit_transform(X_train[["age", "income"]]) |
| Cechy wielomianowe i interakcje | from sklearn.preprocessing import PolynomialFeatures
PolynomialFeatures(degree=2, include_bias=False).fit_transform(X_train[["age", "income"]]) |
| DataFrame'y zamiast tablic | scaler.set_output(transform="pandas") |
| Etykiety tekstowe na liczby całkowite | from sklearn.preprocessing import LabelEncoder
LabelEncoder().fit_transform(["cat", "dog", "cat"]) |
Wybór modelu
Zacznij od czegoś prostego i traktuj wynik prostego modelu jako poprzeczkę do pobicia.
| Problem | Zacznij od | Potem spróbuj |
|---|---|---|
| Przewidywanie liczby (regresja) | LinearRegression(), Ridge(alpha=1.0) | RandomForestRegressor(), HistGradientBoostingRegressor() |
| Przewidywanie klasy (klasyfikacja) | LogisticRegression(max_iter=1000) | RandomForestClassifier(), HistGradientBoostingClassifier() |
| Mało danych, podobne punkty mają tę samą etykietę | KNeighborsClassifier(n_neighbors=5) | SVC(kernel="rbf") |
| Reguły, które da się przeczytać | DecisionTreeClassifier(max_depth=3) | RandomForestClassifier() |
| Grupowanie wierszy bez etykiet | KMeans(n_clusters=3) | DBSCAN(eps=0.5) |
| Mniej cech do wykresów lub dla szybkości | PCA(n_components=2) | TSNE(n_components=2) |
| Wykrywanie nietypowych wierszy | IsolationForest(random_state=0) | LocalOutlierFactor() |
Trenowanie modelu
Każdy estymator działa tak samo: tworzysz go z ustawieniami, a potem wywołujesz fit.
| Zadanie | Kod |
|---|---|
| Schemat dla każdego modelu | model = LogisticRegression(max_iter=1000)
model.fit(X_train, y_train) |
| Regresja liniowa | from sklearn.linear_model import LinearRegression
LinearRegression() |
| Regresja liniowa z regularyzacją | from sklearn.linear_model import Ridge, Lasso
Ridge(alpha=1.0), Lasso(alpha=0.1) |
| Regresja logistyczna (klasyfikacja) | from sklearn.linear_model import LogisticRegression
LogisticRegression(C=1.0, max_iter=1000) |
| k najbliższych sąsiadów | from sklearn.neighbors import KNeighborsClassifier
KNeighborsClassifier(n_neighbors=5) |
| Drzewo decyzyjne | from sklearn.tree import DecisionTreeClassifier
DecisionTreeClassifier(max_depth=3, random_state=0) |
| Las losowy | from sklearn.ensemble import RandomForestClassifier
RandomForestClassifier(n_estimators=200, random_state=0) |
| Gradient boosting, szybki na dużych danych | from sklearn.ensemble import HistGradientBoostingClassifier
HistGradientBoostingClassifier(random_state=0) |
| Maszyna wektorów nośnych (SVM) | from sklearn.svm import SVC
SVC(kernel="rbf", C=1.0) |
| Naiwny klasyfikator Bayesa | from sklearn.naive_bayes import GaussianNB
GaussianNB() |
| Baseline, który zawsze zgaduje klasę większościową | from sklearn.dummy import DummyClassifier
DummyClassifier(strategy="most_frequent") |
Predykcja i analiza modelu
| Zadanie | Kod |
|---|---|
| Przewidywanie klas lub wartości | y_pred = model.predict(X_test) |
| Prawdopodobieństwo klasy pozytywnej | model.predict_proba(X_test)[:, 1] |
| Szybki wynik: accuracy lub R² | model.score(X_test, y_test) |
| Współczynniki modelu liniowego | model.coef_, model.intercept_ |
| Ważność cech w modelu drzewiastym | pd.Series(forest.feature_importances_, index=X_train.columns).sort_values() |
| Ważność przez permutację cech | from sklearn.inspection import permutation_importance
permutation_importance(model, X_test, y_test, random_state=0).importances_mean |
| Etykiety klas znane modelowi | model.classes_ |
| Odczyt i zmiana ustawień | model.get_params(), model.set_params(C=0.5) |
| Rysowanie drzewa decyzyjnego | from sklearn.tree import plot_tree
plot_tree(tree, filled=True, feature_names=list(X_train.columns)) |
Metryki klasyfikacji
Sama accuracy ukrywa błędy na rzadkiej klasie. Sprawdź też precision, recall i macierz pomyłek.
| Zadanie | Kod |
|---|---|
| Importy | from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score |
| Accuracy | accuracy_score(y_test, y_pred) |
| Precision, recall i F1 | precision_score(y_test, y_pred), recall_score(y_test, y_pred), f1_score(y_test, y_pred) |
| F1 dla wielu klas | f1_score(y_test, y_pred, average="macro") |
| Wszystkie metryki dla każdej klasy | from sklearn.metrics import classification_report
print(classification_report(y_test, y_pred)) |
| Macierz pomyłek | from sklearn.metrics import confusion_matrix
confusion_matrix(y_test, y_pred) |
| Wykres macierzy pomyłek | from sklearn.metrics import ConfusionMatrixDisplay
ConfusionMatrixDisplay.from_estimator(model, X_test, y_test) |
| ROC AUC z prawdopodobieństw | from sklearn.metrics import roc_auc_score
roc_auc_score(y_test, model.predict_proba(X_test)[:, 1]) |
| Wykres krzywej ROC | from sklearn.metrics import RocCurveDisplay
RocCurveDisplay.from_estimator(model, X_test, y_test) |
| Accuracy dla niezbalansowanych klas | from sklearn.metrics import balanced_accuracy_score
balanced_accuracy_score(y_test, y_pred) |
| Własny próg decyzyjny | y_pred = (model.predict_proba(X_test)[:, 1] >= 0.3).astype(int) |
Metryki regresji
Metryki błędu są w jednostkach zmiennej docelowej (im niżej, tym lepiej). R² to część wyjaśnionej wariancji (1 to ideał).
| Zadanie | Kod |
|---|---|
| Importy | from sklearn.metrics import mean_absolute_error, mean_squared_error, root_mean_squared_error, r2_score |
| Średni błąd bezwzględny (MAE) | mean_absolute_error(y_test, y_pred) |
| Błąd średniokwadratowy i jego pierwiastek | mean_squared_error(y_test, y_pred), root_mean_squared_error(y_test, y_pred) |
| Wynik R² | r2_score(y_test, y_pred) |
| Średni bezwzględny błąd procentowy (MAPE) | from sklearn.metrics import mean_absolute_percentage_error
mean_absolute_percentage_error(y_test, y_pred) |
| Wykres przewidywań względem rzeczywistości | from sklearn.metrics import PredictionErrorDisplay
PredictionErrorDisplay.from_predictions(y_test, y_pred, kind="actual_vs_predicted") |
Pipeline'y
Pipeline łączy preprocessing i model w jeden estymator, więc walidacja krzyżowa i grid search dopasowują każdy krok wyłącznie na foldach treningowych.
| Zadanie | Kod |
|---|---|
| Importy | from sklearn.pipeline import make_pipeline, Pipeline |
| Skalowanie, potem model | pipe = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))
pipe.fit(X_train, y_train) |
| Kroki z własnymi nazwami | pipe = Pipeline([("scale", StandardScaler()), ("model", LogisticRegression(max_iter=1000))]) |
| Dostęp do kroku w środku | pipe.named_steps["model"], pipe[-1] |
| Różne kroki dla różnych kolumn | from sklearn.compose import ColumnTransformer
pre = ColumnTransformer([
("num", StandardScaler(), ["age", "income"]),
("cat", OneHotEncoder(handle_unknown="ignore"), ["city"]),
]) |
| Preprocessing i model w jednym obiekcie | model = make_pipeline(pre, RandomForestClassifier(random_state=0))
model.fit(X_train, y_train)
model.score(X_test, y_test) |
| Wybór kolumn po typie | from sklearn.compose import make_column_selector
make_column_selector(dtype_include="number")(X_train) |
| Uzupełnianie braków, potem skalowanie | make_pipeline(SimpleImputer(strategy="median"), StandardScaler()) |
| Nazwy cech wyjściowych | pre.get_feature_names_out() |
Walidacja krzyżowa
Walidacja krzyżowa trenuje i ocenia model na kilku podziałach, co daje stabilniejsze oszacowanie niż jeden zbiór testowy.
| Zadanie | Kod |
|---|---|
| Importy | from sklearn.model_selection import cross_val_score, cross_validate, KFold, StratifiedKFold |
| Wynik na 5 foldach | scores = cross_val_score(pipe, X, y, cv=5)
scores.mean(), scores.std() |
| Wybór metryki | cross_val_score(pipe, X, y, cv=5, scoring="f1_macro") |
| Foldy z przetasowaniem | cv = KFold(n_splits=5, shuffle=True, random_state=0) |
| Ten sam rozkład klas w każdym foldzie | cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=0) |
| Kilka metryk i wyniki treningowe | cross_validate(pipe, X, y, cv=cv, scoring=["accuracy", "f1"], return_train_score=True) |
| Predykcja dla każdego wiersza spoza foldu | from sklearn.model_selection import cross_val_predict
cross_val_predict(pipe, X, y, cv=5) |
| Foldy według grup, foldy w kolejności czasu | from sklearn.model_selection import GroupKFold, TimeSeriesSplit
GroupKFold(n_splits=5), TimeSeriesSplit(n_splits=5) |
| Wszystkie poprawne nazwy metryk | from sklearn.metrics import get_scorer_names
get_scorer_names() |
Grid search i strojenie
Wyszukiwanie trenuje model dla każdego ustawienia z walidacją krzyżową, wybiera najlepsze i trenuje je ponownie na wszystkich danych treningowych.
| Zadanie | Kod |
|---|---|
| Importy | from sklearn.model_selection import GridSearchCV, RandomizedSearchCV |
| Wszystkie kombinacje | grid = GridSearchCV(RandomForestClassifier(random_state=0), {"n_estimators": [50, 100], "max_depth": [None, 5]}, cv=5)
grid.fit(X_train, y_train) |
| Najlepsze ustawienia i ich wynik | grid.best_params_, grid.best_score_ |
| Użycie najlepszego modelu | grid.best_estimator_.predict(X_test), grid.score(X_test, y_test) |
| Strojenie kroku w pipeline | GridSearchCV(pipe, {"logisticregression__C": [0.1, 1, 10]}, cv=5).fit(X_train, y_train) |
| Losowe ustawienia z rozkładów | 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) |
| Wszystkie rdzenie procesora | GridSearchCV(pipe, {"logisticregression__C": [0.1, 1]}, cv=5, n_jobs=-1) |
| Wszystkie wyniki jako tabela | pd.DataFrame(grid.cv_results_).sort_values("rank_test_score") |
Klasteryzacja i redukcja wymiarowości
Modele nienadzorowane uczą się z samego X. Najpierw przeskaluj cechy, bo oba podejścia używają odległości.
| Zadanie | Kod |
|---|---|
| Klastry k-means | from sklearn.cluster import KMeans
km = KMeans(n_clusters=3, random_state=0)
labels = km.fit_predict(X) |
| Środki klastrów i inercja | km.cluster_centers_, km.inertia_ |
| Jak dobrze rozdzielone są klastry | from sklearn.metrics import silhouette_score
silhouette_score(X, labels) |
| Klastry gęstościowe, szum to -1 | from sklearn.cluster import DBSCAN
DBSCAN(eps=0.5, min_samples=5).fit_predict(X) |
| Rzut na 2 składowe | from sklearn.decomposition import PCA
pca = PCA(n_components=2)
X_2d = pca.fit_transform(X) |
| Wariancja wyjaśniona przez każdą składową | pca.explained_variance_ratio_ |
| Zachowaj 95% wariancji | PCA(n_components=0.95).fit_transform(X) |
scikit-learn 1.9: stare zapisy i co pisać teraz
Kod skopiowany ze starszych tutoriali może w scikit-learn 1.9 rzucić błąd albo ostrzeżenie. Używaj zapisów z kolumny scikit-learn 1.9.
| Zadanie | scikit-learn 1.9 | Stary zapis |
|---|---|---|
| Pierwiastek błędu średniokwadratowego | root_mean_squared_error(y_test, y_pred) | mean_squared_error(y_test, y_pred, squared=False) |
| Gęsty wynik one-hot | OneHotEncoder(sparse_output=False) | OneHotEncoder(sparse=False) |
| Regresja logistyczna z L1 (lasso) | LogisticRegression(l1_ratio=1, solver="liblinear") | LogisticRegression(penalty="l1", solver="liblinear") |
| Regresja logistyczna bez regularyzacji | LogisticRegression(C=np.inf) | LogisticRegression(penalty=None) |
Zapis, odczyt i powtarzalność
| Zadanie | Kod |
|---|---|
| Zapisz wytrenowany model lub pipeline | import joblib
joblib.dump(model, "model.joblib") |
| Wczytaj go z powrotem | model = joblib.load("model.joblib") |
| Ten sam wynik przy każdym uruchomieniu | random_state=0 |
| Zainstalowana wersja | import sklearn
sklearn.__version__ |
Kod scikit-learn, który stoi za prawdziwym procesem uczenia maszynowego, w kolejności, w jakiej go piszesz: wczytanie i podział danych, preprocessing, wybór modelu, fit i predict, ocena wyniku, połączenie kroków w pipeline, walidacja krzyżowa i strojenie przez grid search. Każdy wiersz to krótki fragment kodu do wklejenia i jedno zdanie o tym, co robi.
Wszystkie modele w scikit-learn mają jedno wspólne API: fit uczy się na danych treningowych, a predict i transform stosują to, czego się nauczyły. Wszystko tutaj jest napisane dla scikit-learn 1.9, wersji, której używa Coddy, z X jako cechami i y jako zmienną docelową. scikit-learn działa na tablicach NumPy i DataFrame'ach pandas, a wykresy opisuje ściąga z Matplotlib. Dopiero zaczynasz z Pythonem? Zajrzyj do ściągi z Pythona.
FAQ: ściąga ze scikit-learn
Czy ta ściąga ze scikit-learn jest darmowa?
Tak. Ta ściąga ze scikit-learn jest całkowicie darmowa i nie wymaga rejestracji. Dodaj ją do zakładek albo wydrukuj do PDF z przeglądarki i wracaj, kiedy tylko potrzebujesz dokładnego wywołania dla pipeline'u, metryki czy grid search.
Czy sklearn to to samo co scikit-learn?
Tak. scikit-learn to nazwa biblioteki i pakietu, który instalujesz (
pip install scikit-learn), a sklearn to nazwa, którą importujesz w kodzie (from sklearn.linear_model import LinearRegression). Ściąga ze sklearn i ściąga ze scikit-learn obejmują to samo.Czym różnią się fit, transform i fit_transform?
fit uczy się z danych: scaler poznaje średnią każdej kolumny, a model swoje wagi. transform stosuje to, czego się nauczył, a fit_transform robi obie rzeczy w jednym wywołaniu. Na zbiorze treningowym używaj fit_transform, a na testowym tylko transform, inaczej dane testowe wyciekną do treningu. Pipeline zrobi to za ciebie.Czy muszę skalować cechy?
Dla modeli, które używają odległości lub gradientów, tak: k najbliższych sąsiadów, SVM, k-means, PCA oraz regresja liniowa i logistyczna z regularyzacją działają lepiej na przeskalowanych danych. Modele drzewiaste, takie jak drzewa decyzyjne, lasy losowe i gradient boosting, nie potrzebują skalowania. Umieść scaler w pipeline, żeby był dopasowywany tylko na danych treningowych.
Od którego modelu scikit-learn zacząć?
Zacznij od prostego, szybkiego modelu jako baseline'u:
LinearRegression do przewidywania liczb, LogisticRegression do przewidywania klas. Potem spróbuj RandomForestClassifier albo HistGradientBoostingClassifier (lub ich wersji do regresji), porównaj je walidacją krzyżową i dostrój najlepszy przez GridSearchCV.Którą wersję scikit-learn obejmuje ta ściąga?
scikit-learn 1.9, wersję, której używa Coddy, na NumPy 2 i pandas 3. Starsze wywołania, które teraz rzucają błąd lub ostrzeżenie, takie jak
squared=False w mean_squared_error, sparse=False w OneHotEncoder i argument penalty w LogisticRegression, są w tabeli starych zapisów obok tego, co pisać zamiast nich.Czy mogę uruchomić kod scikit-learn online?
Tak. Darmowy Matplotlib playground uruchamia Pythona ze scikit-learn, pandas, NumPy i Matplotlib w przeglądarce, więc możesz wkleić dowolny fragment z tej ściągi i uruchomić go bez instalowania czegokolwiek. Kurs Machine Learning w Coddy uczy krok po kroku całego procesu z tej strony, od podziału danych po strojenie modelu.
Powiązane materiały
Więcej ściąg
