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)ochfit_transform(X). - Predictor (Prediktor): Skapar förutsägelser på nya stickprov via
predict(X),predict_proba(X)ochscore(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))