scikit-learn — arbetsflödet

scikit-learn har ett genomgående mönster som alla modeller följer:

Metod	Gör
fit(X, y)	lär sig av träningsdata
predict(X)	förutsäger
predict_proba(X)	sannolikheter (klassificering)
transform(X)	omvandlar (förbehandlare)
fit_transform(X)	båda i ett
score(X, y)	standardmått

Eftersom allt följer mönstret kan du byta ut vilken del som helst utan att röra resten. Byt LogisticRegression mot RandomForestClassifier — resten av koden är oförändrad.

Arbetsflödet, i ordning:

dela data → bygg pipeline → korsvalidera → sök hyperparametrar
          → träna på all träningsdata → utvärdera EN gång på test → spara

Det avgörande steget är att testmängden rörs en enda gång, allra sist. Varje gång du tittar på testresultatet och ändrar något har du börjat anpassa dig till den.

import joblib, numpy as np, pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
from sklearn.metrics import classification_report, confusion_matrix

# 1. Dela FÖRST — allt annat sker på träningsdelen
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.2, stratify=y, random_state=0)

# 2. Pipeline: förbehandling + modell som en enhet
num, kat = ["alder", "timmar"], ["program"]
pipe = Pipeline([
    ("prep", ColumnTransformer([
        ("n", Pipeline([("i", SimpleImputer(strategy="median")), ("s", StandardScaler())]), num),
        ("k", OneHotEncoder(handle_unknown="ignore"), kat),
    ])),
    ("clf", RandomForestClassifier(random_state=0)),
])

# 3. Korsvalidera — förbehandlingen görs om inom varje veck
cv = cross_val_score(pipe, Xtr, ytr, cv=5, scoring="roc_auc")
print(f"CV ROC-AUC {cv.mean():.3f} ± {cv.std():.3f}")

# 4. Sök hyperparametrar — fortfarande bara på träningsdata
rutnat = {"clf__n_estimators": [100, 300], "clf__max_depth": [None, 8, 16]}
sok = GridSearchCV(pipe, rutnat, cv=5, scoring="roc_auc", n_jobs=-1).fit(Xtr, ytr)
print(sok.best_params_, round(sok.best_score_, 3))

# 5. EN gång på testmängden
print(classification_report(yte, sok.predict(Xte)))
print(confusion_matrix(yte, sok.predict(Xte)))

# 6. Spara hela pipelinen, inte bara modellen
joblib.dump(sok.best_estimator_, "modell.joblib")
laddad = joblib.load("modell.joblib")
print(laddad.predict(Xte[:3]))     # rå indata in — förbehandlingen följer med

Att spara hela pipelinen är poängen. Sparar du bara modellen måste den som använder den återskapa exakt samma förbehandling — samma medianer, samma kategoriordning, samma skalning. Det går nästan alltid fel förr eller senare.

joblib har en begränsning värd att känna till: filen innehåller inlagrad Python och är bunden till biblioteksversionerna. Ladda aldrig en .joblib från en okänd källa, och lås scikit-learn-versionen i requirements.txt. För långsiktig lagring är ONNX ett mer hållbart format.

Bygg din första modell på tjugo minuter. Använd ett inbyggt dataset så slipper du datainsamling.

from sklearn.datasets import fetch_openml
X, y = fetch_openml("credit-g", version=1, return_X_y=True, as_frame=True)

Gör sedan, i ordning, och skriv ner resultatet efter varje steg:

1. Baslinje. Vad får DummyClassifier(strategy="most_frequent")? Allt du bygger måste slå detta.
2. Enklaste riktiga modell. LogisticRegression i en pipeline. Skillnad mot baslinjen?
3. Träd. RandomForestClassifier med standardinställningar. Bättre?
4. Sök. GridSearchCV över två parametrar. Hur mycket gav sökningen?
5. Titta på felen. confusion_matrix — vilken sorts fel gör modellen mest?
6. En gång på test.

Vad du troligen upptäcker:

• Steg 1 ger förvånansvärt hög «träffsäkerhet» om klasserna är obalanserade — vilket är varför du inte ska mäta träffsäkerhet.
• Steg 2 till 3 ger ofta mindre skillnad än man tror.
• Steg 4 ger sällan mer än någon enstaka procentenhet.
• Steg 5 är det som faktiskt leder någonstans — felen är nästan alltid koncentrerade till en identifierbar grupp.

Den ordningen — baslinje, enkel modell, felanalys, sedan finlir — är hela skillnaden mellan att jobba effektivt och att skruva på hyperparametrar i en vecka.