Snabbreferens

Scikit-Learn API & Arbetsflöde för Maskininlärning Lathund

En praktisk referensguide för Scikit-Learn: enhetlig API-design (Estimator, Transformer, Predictor), dataförberedelse, särdragsutvinning, övervakade och oövervakade modeller, korsvalidering, utvärderingsmått och läckagefria Pipelines.

· Publicerad · Uppdaterad

Scikit-Learn (sklearn) är Pythons grundläggande bibliotek med öppen källkod för statistisk modellering och traditionell maskininlärning, byggt på NumPy, SciPy och Matplotlib. Dess arkitektoniska styrka bygger på ett strikt enhetligt designmönster med tre gränssnitt:

  • Estimator (Uppskattare): Lär sig modellparametrar från data via fit(X, y).
  • Transformer (Transformator): Förbehandlar och projicerar egenskaper via transform(X) och fit_transform(X).
  • Predictor (Prediktor): Skapar förutsägelser på nya stickprov via predict(X), predict_proba(X) och score(X, y).

🔗 Relaterade lathundar: NumPy Lathund · Pandas Lathund · Algoritmer för övervakat lärande · Dataanalysmetoder · Python Lathund


1. Komplett snabbstartsexempel

Följande självständiga skript visar dataladdning, stratifierad uppdelning, egenskapsskalning, modellträning och utvärdering:

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, classification_report

# 1. Läs in data
iris = load_iris()
X, y = iris.data, iris.target

# 2. Stratifierad uppdelning i tränings- och testdata
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 3. Skalning av egenskaper (anpassa ENDAST på träningsdata för att förhindra dataläckage)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 4. Träna modellen
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train_scaled, y_train)

# 5. Förutsäg och utvärdera
y_pred = knn.predict(X_test_scaled)
print(f"Noggrannhet: {accuracy_score(y_test, y_pred):.4f}")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

2. Dataförberedelse & Uppdelning

Scikit-Learn förväntar sig 2D numeriska strukturer: en egenskapsmatris $X$ med formen (n_samples, n_features) och en målvektor $y$ med formen (n_samples,). Indata kan vara NumPy-ndarrays, glesa SciPy-matriser (scipy.sparse) eller Pandas DataFrames/Series.

2.1 Inbyggda & Syntetiska Datamängder

from sklearn import datasets

# Små referensdatamängder (returnerar Bunch-objekt)
iris = datasets.load_iris()               # Flerklassklassificering
digits = datasets.load_digits()           # 8x8 handskrivna sifferbilder
diabetes = datasets.load_diabetes()       # Regressionsriktmärke
wine = datasets.load_wine()               # Kemisk analys av viner i 3 klasser

# Verkliga referensdatamängder (cachas lokalt)
housing = datasets.fetch_california_housing()

# Syntetisk datagenerering för algoritmtestning
X, y = datasets.make_classification(
    n_samples=1000, n_features=20, n_informative=15, n_classes=2, random_state=42
)
X_reg, y_reg = datasets.make_regression(n_samples=500, n_features=10, noise=0.1, random_state=42)
X_blob, y_blob = datasets.make_blobs(n_samples=300, centers=3, n_features=2, random_state=42)

2.2 Uppdelning av datamängd (train_test_split)

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.25,        # Andel testdata (standard: 0.25)
    random_state=42,       # Fast slumpfrö för reproducerbarhet
    shuffle=True,          # Blanda stickprov före uppdelning
    stratify=y             # Rekommenderas starkt vid klassificering: bevarar klassproportioner
)

3. Feature Engineering & Förbehandling (sklearn.preprocessing & sklearn.impute)

Transformator Användningsområde Matematisk transformation / Logik Viktiga parametrar
StandardScaler Z-score standardisering av numeriska egenskaper $z = \frac{x - \mu}{\sigma}$ (medelvärde 0, varians 1) with_mean=True, with_std=True
MinMaxScaler Skalning av egenskaper till ett slutet intervall $x' = \frac{x - x_{\min}}{x_{\max} - x_{\min}} \cdot (\max - \min) + \min$ feature_range=(0, 1)
RobustScaler Skalning robust mot extremvärden (outliers) Skalning baserad på kvartilavstånd: $x' = \frac{x - Q_2}{Q_3 - Q_1}$ quantile_range=(25.0, 75.0)
Normalizer Radvis normalisering per enskilt stickprov Skalar varje stickprov till enhetsnorm ($L_1$, $L_2$ eller Max) norm='l2' ('l1', 'max')
Binarizer Tröskelvärdesbinarisering av kontinuerliga variabler $x > \text{threshold} \Rightarrow 1$, annars $0$ threshold=0.0
SimpleImputer Ersättning av saknade värden (imputation) Ersätter saknade värden med medelvärde, median, typvärde eller konstant missing_values=np.nan, strategy='mean'
OneHotEncoder One-Hot-kodning av nominella kategoriska variabler Omvandlar kategorier till binära indikatorkolumner drop='first', handle_unknown='ignore'
OrdinalEncoder Ordinalkodning för ordnade kategoriska variabler Kodar kategorier till ordnade heltal $0, \dots, K-1$ categories='auto', encoded_missing_value
LabelEncoder Etikettkodning för målvariabeln $y$ Omvandlar textetiketter till heltal $0 \dots C-1$ ENDAST för målvariabeln $y$, ALDRIG för egenskaper $X$
PolynomialFeatures Generering av polynom- och interaktionstermer Skapar termer av högre ordning $[1, a, b, a^2, ab, b^2]$ degree=2, include_bias=False

3.1 Kodexempel för förbehandling

import numpy as np
from sklearn.preprocessing import (
    StandardScaler, MinMaxScaler, RobustScaler, Normalizer,
    Binarizer, OneHotEncoder, OrdinalEncoder, LabelEncoder, PolynomialFeatures
)
from sklearn.impute import SimpleImputer

# 1. Numerisk standardisering (anpassa aldrig på testdata!)
scaler = StandardScaler()
X_train_std = scaler.fit_transform(X_train)
X_test_std = scaler.transform(X_test)

# 2. Ersätt saknade värden (medianstrategi)
imputer = SimpleImputer(missing_values=np.nan, strategy='median')
X_train_imp = imputer.fit_transform(X_train)
X_test_imp = imputer.transform(X_test)

# 3. One-Hot-kodning (hanterar okända testkategorier säkert)
ohe = OneHotEncoder(handle_unknown='ignore', sparse_output=False)
X_train_ohe = ohe.fit_transform(X_train_cat)
X_test_ohe = ohe.transform(X_test_cat)

# 4. Kodning av målvariabel
le = LabelEncoder()
y_train_enc = le.fit_transform(y_train)
y_test_enc = le.transform(y_test)

# 5. Polynomisk expansion av egenskaper
poly = PolynomialFeatures(degree=2, include_bias=False)
X_train_poly = poly.fit_transform(X_train)

4. Översikt över vanliga modeller (Estimators)

4.1 Övervakat lärande: Klassificering

from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
from sklearn.ensemble import RandomForestClassifier, HistGradientBoostingClassifier

# Logistisk regression (linjär baslinjemodell)
clf_lr = LogisticRegression(C=1.0, max_iter=200, random_state=42)

# K närmaste grannar (KNN)
clf_knn = KNeighborsClassifier(n_neighbors=5, metric='minkowski', p=2)

# Support Vector Machine (RBF-kärna)
clf_svm = SVC(C=1.0, kernel='rbf', gamma='scale', probability=True, random_state=42)

# Gaussisk Naive Bayes
clf_gnb = GaussianNB()

# Slumpmässig skog (Random Forest, Bagging-ensemble)
clf_rf = RandomForestClassifier(n_estimators=100, max_depth=None, n_jobs=-1, random_state=42)

# Histogrambaserad Gradient Boosting (snabb GBDT likt LightGBM)
clf_hgb = HistGradientBoostingClassifier(learning_rate=0.1, max_iter=100, random_state=42)

4.2 Övervakat lärande: Regression

from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.svm import SVR
from sklearn.ensemble import RandomForestRegressor, HistGradientBoostingRegressor

# Vanlig minsta kvadrat-regression (OLS)
reg_lr = LinearRegression()

# Ridge-regression (L2-regularisering mot multikollinearitet)
reg_ridge = Ridge(alpha=1.0)

# Lasso-regression (L1-regularisering för variabelval)
reg_lasso = Lasso(alpha=0.1)

# Support Vector Regression (SVR)
reg_svr = SVR(kernel='rbf', C=1.0, epsilon=0.1)

# Random Forest Regressor
reg_rf = RandomForestRegressor(n_estimators=100, n_jobs=-1, random_state=42)

4.3 Oövervakat lärande: Klustring & Dimensionsreduktion

from sklearn.cluster import KMeans, DBSCAN
from sklearn.decomposition import PCA

# K-Means Klustring
kmeans = KMeans(n_clusters=3, init='k-means++', n_init=10, random_state=42)
kmeans.fit(X)
cluster_labels = kmeans.labels_        # Klustertilldelningar
cluster_centers = kmeans.cluster_centers_

# Densitetsbaserad rumslig klustring (DBSCAN: brusresistent)
dbscan = DBSCAN(eps=0.5, min_samples=5)
db_labels = dbscan.fit_predict(X)      # -1 anger brus och extremvärden

# Principalkomponentanalys (PCA): bevarar 95% varians
pca = PCA(n_components=0.95)
X_pca = pca.fit_transform(X)
print("Bevarade komponenter:", pca.n_components_)
print("Förklarad variansandel:", pca.explained_variance_ratio_)

5. Sammanfattning av enhetliga API-operationer

Operation Kanonisk metod Måltyp Semantik & Returvärde
Anpassa (Fit) estimator.fit(X, y) Alla Estimators Uppskattar parametrar från träningsdata; returnerar self
Förutsäg (Predict) predictor.predict(X) Alla Predictors Genererar klassetiketter eller kontinuerliga målvärden
Sannolikhet predictor.predict_proba(X) Klassificerare Beräknar a posteriori-sannolikhetsfördelning
Beslutsavstånd predictor.decision_function(X) Linjära modeller / SVM Teckenförsett avstånd från stickprov till separationshyperplanet
Transformera transformer.transform(X) Alla Transformers Projicerar egenskaper med hjälp av inlärda parametrar
Anpassa & Transformera transformer.fit_transform(X) Alla Transformers Beräknar parametrar och transformerar i ett optimerat steg
Standardpoäng estimator.score(X, y) Klassificerare / Regressorer Träffsäkerhet för klassificering; determinationskoefficient $R^2$ för regression

6. Utvärderingsmått (sklearn.metrics)

6.1 Klassificeringsmått

from sklearn.metrics import (
    accuracy_score, precision_score, recall_score, f1_score,
    roc_auc_score, confusion_matrix, classification_report,
    ConfusionMatrixDisplay
)

# 1. Mått för diskreta etiketter (ange average vid flerklassproblem)
acc = accuracy_score(y_test, y_pred)
prec = precision_score(y_test, y_pred, average='macro')
rec = recall_score(y_test, y_pred, average='macro')
f1 = f1_score(y_test, y_pred, average='macro')

# 2. Kontinuerliga rangordningsmått (ROC-AUC kräver sannolikheter)
y_prob = clf.predict_proba(X_test)[:, 1]   # Sannolikheter för den positiva klassen
auc = roc_auc_score(y_test, y_prob)

# 3. Förväxlingsmatris och utförlig klassificeringsrapport
cm = confusion_matrix(y_test, y_pred)
print(classification_report(y_test, y_pred))

# 4. Grafisk visualisering av förväxlingsmatris
disp = ConfusionMatrixDisplay(confusion_matrix=cm)
disp.plot()

6.2 Regressionsmått

from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

mae = mean_absolute_error(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
rmse = mean_squared_error(y_test, y_pred, squared=False)  # Kvadratroten ur medelkvadratfelet (RMSE)
r2 = r2_score(y_test, y_pred)                            # Determinationskoefficient R²

6.3 Klustringsmått

from sklearn.metrics import (
    adjusted_rand_score, homogeneity_score, v_measure_score, silhouette_score
)

# Extern validering (när sanna etiketter finns tillgängliga)
ari = adjusted_rand_score(y_true, cluster_labels)       # Intervall: [-1, 1], högre är bättre
homo = homogeneity_score(y_true, cluster_labels)        # Intervall: [0, 1]
vm = v_measure_score(y_true, cluster_labels)           # Harmoniskt medelvärde av homogenitet och fullständighet

# Intern validering (geometrisk, inga sanna etiketter krävs)
sil = silhouette_score(X, cluster_labels)              # Intervall: [-1, 1], nära 1 indikerar distinkta kluster

7. Korsvalidering & Hyperparameteroptimering (sklearn.model_selection)

7.1 Korsvalidering (Cross-Validation)

from sklearn.model_selection import cross_val_score, cross_validate, StratifiedKFold

# Standard K-Fold korsvalidering
scores = cross_val_score(clf, X, y, cv=5, scoring='accuracy')
print(f"5-Fold CV Noggrannhet: {scores.mean():.4f} (±{scores.std():.4f})")

# Stratifierad K-Fold generator
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores_skf = cross_val_score(clf, X, y, cv=skf, scoring='f1_macro')

# Gemensam utvärdering av flera mått samtidigt
multi_scores = cross_validate(
    clf, X, y, cv=5,
    scoring=['accuracy', 'roc_auc'],
    return_train_score=False
)
print("Genomsnittlig validerings-AUC:", multi_scores['test_roc_auc'].mean())

7.2 Rutnätsökning & Slumpmässig sökning

from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
from scipy.stats import randint

# 1. Uttömmande rutnätsökning (GridSearchCV)
param_grid = {
    'n_neighbors': [3, 5, 7, 11],
    'weights': ['uniform', 'distance'],
    'metric': ['euclidean', 'manhattan']
}
grid = GridSearchCV(
    estimator=KNeighborsClassifier(),
    param_grid=param_grid,
    cv=5,
    scoring='accuracy',
    n_jobs=-1
)
grid.fit(X_train, y_train)
print("Bästa parametrar:", grid.best_params_)
best_model = grid.best_estimator_

# 2. Slumpmässig parametersökning (för stora sökrymder)
param_dist = {
    'n_estimators': randint(50, 300),
    'max_depth': [None, 5, 10, 20],
    'min_samples_split': randint(2, 11)
}
rand_search = RandomizedSearchCV(
    estimator=RandomForestClassifier(random_state=42),
    param_distributions=param_dist,
    n_iter=20,             # Antal slumpmässiga parameterkombinationer
    cv=5,
    scoring='accuracy',
    random_state=42,
    n_jobs=-1
)
rand_search.fit(X_train, y_train)
print("Bästa parametrar för Random Search:", rand_search.best_params_)

8. Bästa praxis för produktion: Pipeline & ColumnTransformer

8.1 Varför Pipelines är obligatoriska

Global skalning eller imputation före uppdelning orsakar Dataläckage (Data Leakage): information från testdelarna läcker in i träningsstatistiken, vilket ger vilseledande optimistiska mätvärden som fallerar i produktion.

Pipeline binder samman transformatorer och modeller till en odelbar läckagefri enhet. Vid korsvalidering anpassas transformatorer uteslutande på träningsdelarna.

8.2 Produktionsmall med ColumnTransformer

Verkliga tabelldata innehåller en blandning av kontinuerliga numeriska kolumner och kategoriska variabler:

from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.ensemble import RandomForestClassifier

# 1. Dela upp kolumnnamnen explicit
numeric_features = ['age', 'income', 'credit_score']
categorical_features = ['gender', 'occupation', 'city']

# 2. Numerisk delpipeline: medianimputation -> standardskalning
numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])

# 3. Kategorisk delpipeline: konstant imputation -> One-Hot-kodning
categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
    ('onehot', OneHotEncoder(handle_unknown='ignore', sparse_output=False))
])

# 4. Samla kolumner i en enhetlig ColumnTransformer
preprocessor = ColumnTransformer(transformers=[
    ('num', numeric_transformer, numeric_features),
    ('cat', categorical_transformer, categorical_features)
])

# 5. Bygg ihop hela modellens pipeline
full_pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', RandomForestClassifier(n_estimators=100, random_state=42))
])

# 6. Atomär anpassning och inferens (noll läckage, robust driftsättning)
full_pipeline.fit(X_train_df, y_train)
y_pred = full_pipeline.predict(X_test_df)
print("Pipelinetest noggrannhet:", full_pipeline.score(X_test_df, y_test))

Relaterade ämnen