Scikit-learn 1.8: Guide till GPU-acceleration, temperaturkalibrering och nya funktioner

Introduktion till scikit-learn 1.8

Scikit-learn har sedan starten 2007 varit det mest använda maskininlärningsbiblioteket i Python-ekosystemet. Med sin konsekventa API-design, omfattande dokumentation och breda utbud av algoritmer har det blivit standardvalet för allt från akademisk forskning till produktionssystem. Och nu, i december 2025, släpptes version 1.8 — en milstolpe som faktiskt känns som mer än en vanlig uppdatering.

Det här är nämligen inte bara en inkrementell release. Version 1.8 introducerar experimentellt stöd för GPU-beräkningar via Array API, en ny metod för sannolikhetskalibrering med temperaturskaliering, stöd för free-threaded CPython 3.14 utan GIL, och riktigt rejäla prestandaförbättringar i flera centrala algoritmer. Dessutom tillkommer ClassicalMDS som ny manifold learning-algoritm och en rad förbättringar i utvecklarupplevelsen genom bättre HTML-representation i Jupyter-notebooks.

Så, låt oss dyka in. I den här guiden går vi igenom alla väsentliga nyheter i scikit-learn 1.8, med praktiska kodexempel och förklaringar som hjälper dig att snabbt börja använda de nya funktionerna. Vi täcker även kort vad som kom i version 1.6 och 1.7 (för dig som hoppat över dessa), samt ger konkreta råd för migrering och uppgradering.

Array API-stöd och GPU-acceleration

Det här är ärligt talat den mest spännande nyheten i scikit-learn 1.8. Det utökade stödet för Array API möjliggör GPU-beräkningar direkt i scikit-learn-estimatorer. Tidigare var scikit-learn strikt knutet till NumPy-arrayer på CPU, men med Array API-standarden kan biblioteket nu acceptera data från GPU-bibliotek som PyTorch och CuPy.

Hur Array API fungerar

Array API är en standardiserad specifikation som definierar ett gemensamt gränssnitt för arrayoperationer. Genom att implementera stöd för detta gränssnitt kan scikit-learn-estimatorer arbeta med vilken arraytyp som helst som följer standarden — oavsett om arrayen lever på CPU (NumPy) eller GPU (PyTorch CUDA-tensorer, CuPy-arrayer).

Stödet är fortfarande experimentellt och måste aktiveras explicit via konfigurationsinställningen array_api_dispatch=True. När detta är aktiverat kommer estimatorer automatiskt att använda rätt beräkningsbibliotek baserat på indatat. Skickar du in en PyTorch-tensor som lever på GPU:n? Då utförs alla beräkningar där, utan att data behöver kopieras fram och tillbaka. Smidigt.

Estimatorer med Array API-stöd i version 1.8

Följande estimatorer och funktioner har fått Array API-stöd:

• preprocessing.StandardScaler — standardisering av features
• preprocessing.PolynomialFeatures — polynomtransformationer
• linear_model.RidgeCV och linear_model.RidgeClassifierCV — Ridge-regression med korsvalidering (kräver solver="svd")
• mixture.GaussianMixture — Gaussiska blandningsmodeller (med init_params="random")
• calibration.CalibratedClassifierCV — sannolikhetskalibrering (med method="temperature")
• naive_bayes.GaussianNB — Gaussisk Naive Bayes
• Diverse metriker: confusion_matrix, roc_curve, precision_recall_curve, brier_score_loss, log_loss med flera

Kodexempel: GPU-accelererad pipeline

Här är ett exempel på hur man bygger en pipeline som flyttar data till GPU:n och kör klassificering med Ridge-regression och temperaturkalibrering:

import torch
import numpy as np
import sklearn
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import FunctionTransformer, StandardScaler
from sklearn.calibration import CalibratedClassifierCV
from sklearn.linear_model import RidgeClassifierCV
from sklearn.model_selection import cross_validate
from sklearn.datasets import make_classification

# Skapa exempeldata
X, y = make_classification(
    n_samples=5000, n_features=50, n_classes=3,
    n_informative=20, random_state=42
)

# Definiera alfavärden för Ridge-regression
alphas = np.logspace(-3, 3, 50)

# Skapa en pipeline som flyttar data till GPU
gpu_pipeline = make_pipeline(
    StandardScaler(),
    # Flytta data till GPU som PyTorch-tensor
    FunctionTransformer(
        lambda x: torch.tensor(x, dtype=torch.float32, device="cuda")
    ),
    # Kalibrerad Ridge-klassificerare körs på GPU
    CalibratedClassifierCV(
        RidgeClassifierCV(alphas=alphas),
        method="temperature"
    ),
)

# Aktivera Array API-stöd och kör korsvalidering
with sklearn.config_context(array_api_dispatch=True):
    cv_resultat = cross_validate(gpu_pipeline, X, y, cv=5)
    print(f"Genomsnittlig noggrannhet: {cv_resultat['test_score'].mean():.3f}")

Prestandavinster

Hur mycket snabbare blir det egentligen? I tester har man sett ungefär 10 gånger snabbare beräkningar jämfört med en enda CPU-kärna, vilket inte är ovanligt för den här typen av arbetsbelastningar. Vinsten är särskilt stor för estimatorer som utför matrisoperationer på stora datamängder — till exempel RidgeCV med många alfavärden eller GaussianMixture med stora dataset.

En sak att tänka på: inlärda attribut hos en estimator som tränats med Array API-kompatibla indata lagras som arrayer från samma bibliotek och på samma enhet. Det innebär att predict- och transform-metoderna sedan förväntar sig indata från samma arraybibliotek och enhet.

Free-threaded CPython 3.14 — framtiden utan GIL

Python har historiskt begränsats av Global Interpreter Lock (GIL), som förhindrar äkta parallell exekvering av Python-trådar. Det är ett av de mest diskuterade ämnena i Python-communityn, och nu börjar saker hända på riktigt.

Med CPython 3.13 påbörjades arbetet med att ta bort GIL, och i CPython 3.14 finns en experimentell "free-threaded" version som möjliggör effektiv multitrådning. Scikit-learn 1.8 levererar free-threaded wheels för alla stödda plattformar på Python 3.14 — du kan alltså installera och köra direkt utan extra konfiguration.

Vad innebär free-threaded CPython?

I traditionell CPython förhindrar GIL att flera trådar exekverar Python-bytekod samtidigt. Det gör att trådbaserad parallellism i praktiken inte ger prestandavinster för CPU-bundna uppgifter. Med free-threaded CPython tas denna begränsning bort, och trådar kan faktiskt köra parallellt på flera CPU-kärnor.

För scikit-learn betyder det att joblibbaserad parallellism kan använda trådar istället för processer. Det undviker overhead från interprocesskommunikation och kopiering av data mellan processer, vilket kan ge rejäla prestandavinster.

Kodexempel: Trådbaserad parallellism

import joblib
from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification

# Skapa exempeldata
X, y = make_classification(n_samples=10000, n_features=20, random_state=42)

# Definiera parametersökning
param_grid = {
    "n_estimators": [50, 100, 200],
    "max_depth": [5, 10, 20, None],
    "min_samples_split": [2, 5, 10],
}

clf = RandomForestClassifier(random_state=42)
grid_search = GridSearchCV(clf, param_grid=param_grid, cv=5, n_jobs=4)

# Använd trådbaserad backend istället för processbaserad
# Särskilt effektivt med free-threaded CPython 3.14
with joblib.parallel_config(backend="threading"):
    grid_search.fit(X, y)

print(f"Bästa parametrar: {grid_search.best_params_}")
print(f"Bästa poäng: {grid_search.best_score_:.4f}")

Med free-threaded CPython elimineras overhead från processbaserad parallellism — ingen serialisering och deserialisering via pickle, ingen kopiering av minnesinnehåll, och ingen interprocesskommunikation. Resultatet? Snabbare exekvering, lägre minnesanvändning och bättre utnyttjande av flerkärniga processorer.

Temperaturkalibrering i CalibratedClassifierCV

Okej, det här är en funktion som jag personligen tycker är riktigt välkommen. Temperaturskaliering som kalibreringsmetod i CalibratedClassifierCV löser ett problem som många av oss brottats med: att få tillförlitliga sannolikhetsestimat från klassificerare, särskilt i flerklassproblem.

Varför temperaturskaliering?

De tidigare tillgängliga metoderna — "sigmoid" (Platt scaling) och "isotonic" — har begränsningar, framför allt för flerklassproblem. Sigmoid-metoden använder ett "One-vs-Rest"-schema som lägger till separata parametrar för varje klass, och det ökar risken för överanpassning. Temperaturskaliering löser detta elegant med en enda fri parameter T (temperaturen) som appliceras på alla klasser samtidigt.

Tekniskt fungerar det genom att beräkna softmax(logits / T), där T optimeras för att minimera log loss. Ett högre T-värde gör sannolikhetsfördelningen mer uniform (modellen blir mer "osäker"), medan ett lägre T-värde gör den mer spetsig (modellen blir mer "säker").

Kodexempel: Jämförelse av kalibreringsmetoder

import numpy as np
from sklearn.calibration import CalibratedClassifierCV, CalibrationDisplay
from sklearn.datasets import make_classification
from sklearn.naive_bayes import GaussianNB
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt

# Skapa ett flerklassklassificeringsproblem
X, y = make_classification(
    n_samples=5000, n_classes=3, n_features=20,
    n_informative=8, random_state=42
)

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42
)

# Träna basklassificerare
bas_clf = GaussianNB()
bas_clf.fit(X_train, y_train)

# Sigmoid-kalibrering (traditionell metod)
sigmoid_clf = CalibratedClassifierCV(
    bas_clf, method="sigmoid", ensemble=False
)
sigmoid_clf.fit(X_train, y_train)

# Temperaturskaliering (ny metod i 1.8)
temp_clf = CalibratedClassifierCV(
    bas_clf, method="temperature", ensemble=False
)
temp_clf.fit(X_train, y_train)

# Jämför log loss
from sklearn.metrics import log_loss

print(f"Log loss (okalibrerad): {log_loss(y_test, bas_clf.predict_proba(X_test)):.4f}")
print(f"Log loss (sigmoid):     {log_loss(y_test, sigmoid_clf.predict_proba(X_test)):.4f}")
print(f"Log loss (temperatur):  {log_loss(y_test, temp_clf.predict_proba(X_test)):.4f}")

Temperaturskaliering tenderar att ge bättre resultat än sigmoid-kalibrering för flerklassproblem, just eftersom den hanterar alla klasser gemensamt istället för att kalibrera varje klass separat. Det är särskilt fördelaktigt när antalet klasser är stort.

Integration med Array API

Värt att nämna: CalibratedClassifierCV med method="temperature" stöder även Array API-kompatibla indata, förutsatt att den underliggande estimatorn också gör det. Hela kalibreringsprocessen kan alltså köras på GPU:n, vilket ger ytterligare prestandavinster.

Prestandaförbättringar i linjära modeller

Scikit-learn 1.8 levererar dramatiska prestandaförbättringar för linjära modeller med L1-regularisering. Den viktigaste optimeringen? Implementeringen av "gap safe screening rules" i coordinate descent-lösaren.

Gap safe screening rules

Gap safe screening rules är en teknik som gör det möjligt att tidigt utesluta features från optimeringen. Under optimeringsprocessen kan man identifiera vilka features vars koefficienter garanterat är noll vid den optimala lösningen. Dessa features kan sedan ignoreras i efterföljande iterationer, vilket drastiskt minskar beräkningstiden.

Följande estimatorer drar nytta av optimeringen:

• linear_model.Lasso och linear_model.LassoCV
• linear_model.ElasticNet och linear_model.ElasticNetCV
• linear_model.MultiTaskLasso och linear_model.MultiTaskLassoCV
• linear_model.MultiTaskElasticNet och linear_model.MultiTaskElasticNetCV
• linear_model.lasso_path och linear_model.enet_path

Kodexempel: ElasticNetCV med gap safe screening

from time import time
from sklearn.datasets import make_regression
from sklearn.linear_model import ElasticNetCV, LassoCV

# Skapa en stor datamängd med många features
X, y = make_regression(
    n_samples=1000, n_features=10_000,
    n_informative=50, random_state=42
)

# ElasticNetCV med gap safe screening (automatiskt i 1.8)
model = ElasticNetCV(cv=5, l1_ratio=0.5, n_alphas=100)

start = time()
model.fit(X, y)
slut = time()

print(f"ElasticNetCV med {X.shape[1]} features: {slut - start:.1f} sekunder")
print(f"Antal icke-noll-koefficienter: {(model.coef_ != 0).sum()}")
print(f"Bästa alpha: {model.alpha_:.6f}")

# LassoCV drar också nytta av optimeringen
lasso_model = LassoCV(cv=5, n_alphas=100)

start = time()
lasso_model.fit(X, y)
slut = time()

print(f"\nLassoCV med {X.shape[1]} features: {slut - start:.1f} sekunder")
print(f"Antal icke-noll-koefficienter: {(lasso_model.coef_ != 0).sum()}")

Hastighetsförbättringen är markant — upp till 10 gånger snabbare vid beräkning av regulariseringsvägar. Screeningen sker varje gång dualitetsgapet beräknas, och det finns även en extra kontroll av stoppkriteriet innan huvudloopen av descent-steg påbörjas.

Övriga optimeringar i linjära modeller

Utöver gap safe screening finns ytterligare optimeringar i version 1.8:

• ElasticNet och Lasso med precompute=False använder nu mindre minne för dense X och är något snabbare. Tidigare använde de dubbelt så mycket minne som X, även för Fortran-contiguous arrayer.
• Dessa modeller är snabbare att träna genom att undvika ett BLAS level 1-anrop (axpy) i den innersta loopen.

DecisionTreeRegressor med absolute_error

Den här förbättringen är kanske inte lika flashig som GPU-stödet, men den är otroligt praktisk. DecisionTreeRegressor med kriteriet "absolute_error" har fått sin algoritmiska komplexitet förbättrad från O(n²) till O(n log n). Det innebär att det nu är fullt möjligt att skala till miljontals datapunkter.

Praktisk betydelse

Absolute error (median absolute deviation) är ett robust kriterium som är mindre känsligt för extremvärden jämfört med "squared_error". Problemet var att det tidigare var opraktiskt långsamt att använda på stora datamängder. Med den nya implementeringen i 1.8 är prestandaskillnaden mot "squared_error" nu mycket mindre — och det gör en verklig skillnad i praktiken.

Kodexempel: Jämförelse av prestanda

import time
import numpy as np
from sklearn.datasets import make_regression
from sklearn.tree import DecisionTreeRegressor

# Skapa en stor datamängd
n_samples = 100_000
X, y = make_regression(
    n_samples=n_samples, n_features=10, random_state=42
)

# Testa med absolute_error (förbättrat i 1.8)
tree_abs = DecisionTreeRegressor(
    criterion="absolute_error", max_depth=10, random_state=42
)

start = time.time()
tree_abs.fit(X, y)
tid_abs = time.time() - start

# Testa med squared_error (referens)
tree_sq = DecisionTreeRegressor(
    criterion="squared_error", max_depth=10, random_state=42
)

start = time.time()
tree_sq.fit(X, y)
tid_sq = time.time() - start

print(f"absolute_error: {tid_abs:.2f} sekunder ({n_samples:,} sampel)")
print(f"squared_error:  {tid_sq:.2f} sekunder ({n_samples:,} sampel)")
print(f"Förhållande:    {tid_abs / tid_sq:.1f}x")

# Tidigare kunde det ta ~20 sekunder för 100K sampel,
# nu tar det under 1 sekund

Förbättringen påverkar förstås även RandomForestRegressor och andra ensemble-metoder som bygger på beslutsträd — så effekten sprider sig genom hela ekosystemet.

ClassicalMDS — Principal Coordinates Analysis

Scikit-learn 1.8 introducerar ClassicalMDS i sklearn.manifold-modulen. Classical MDS (även känt som Principal Coordinates Analysis eller Torgersons skaliering) är en teknik för dimensionsreduktion som approximerar parvisa skalärprodukter med en exakt analytisk lösning baserad på egenvärdesdekomposition.

Skillnaden mot befintlig MDS

Till skillnad från den befintliga MDS-implementeringen, som använder iterativ optimering, har ClassicalMDS en sluten formlösning. Det gör den snabbare och deterministisk — samma resultat varje gång, utan slumpmässig initialisering. Den är nära besläktad med PCA och bevarar parvisa skalärprodukter snarare än avstånd.

Kodexempel: Dimensionsreduktion med ClassicalMDS

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets, manifold

# Generera S-kurve-data i 3D
n_samples = 1500
S_points, S_color = datasets.make_s_curve(n_samples, random_state=0)

# Tillämpa Classical MDS för dimensionsreduktion
classical_mds = manifold.ClassicalMDS(n_components=2)
S_reducerad = classical_mds.fit_transform(S_points)

# Visualisering
fig = plt.figure(figsize=(12, 5))

# Original 3D S-kurva
ax1 = fig.add_subplot(1, 2, 1, projection="3d")
x, y, z = S_points.T
ax1.scatter(x, y, z, c=S_color, s=30, alpha=0.8, cmap="Spectral")
ax1.set_title("Original S-kurva (3D)", fontsize=14)
ax1.view_init(azim=-60, elev=9)

# 2D-projektion med Classical MDS
ax2 = fig.add_subplot(1, 2, 2)
x2, y2 = S_reducerad.T
ax2.scatter(x2, y2, c=S_color, s=30, alpha=0.8, cmap="Spectral")
ax2.set_title("Classical MDS (2D)", fontsize=14)
ax2.set_xlabel("Komponent 1")
ax2.set_ylabel("Komponent 2")

plt.tight_layout()
plt.show()

# Jämför med PCA
from sklearn.decomposition import PCA

pca = PCA(n_components=2)
S_pca = pca.fit_transform(S_points)

print(f"ClassicalMDS — form: {S_reducerad.shape}")
print(f"PCA — förklarad varians: {pca.explained_variance_ratio_.sum():.3f}")

Classical MDS är särskilt användbar när man har en avståndsmatris eller likhetsmatris och vill skapa en lågdimensionell representation. Typiska användningsområden inkluderar ekologisk dataanalys, psykometri och visualisering av komplexa avståndsmått.

Förbättrad HTML-representation i Jupyter

Det kanske inte låter lika spännande som GPU-acceleration, men bättre HTML-representation i Jupyter gör faktiskt vardagen som utvecklare märkbart trevligare. Version 1.8 förbättrar den interaktiva HTML-representationen av estimatorer med två viktiga nyheter.

Nya funktioner

• Hyperlänkar: Hyperparameternamn i dropdown-tabellen inkluderar nu direktlänkar till den officiella dokumentationen. Perfekt för att snabbt slå upp detaljer utan att lämna sin notebook.
• Verktygstips: Docstring-beskrivningar visas som tooltips vid hovring över parametrar. Bara att föra muspekaren över ett parameternamn för att få en kort förklaring.
• Adaptiv färghantering: HTML-representationen anpassar sig nu bättre till ljusa och mörka teman.

Kodexempel: Interaktiv inspektion

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier

# Skapa en pipeline
pipeline = make_pipeline(
    StandardScaler(),
    PolynomialFeatures(degree=2, interaction_only=True),
    LogisticRegression(C=10, max_iter=500, random_state=42)
)

# I Jupyter: visa pipeline med förbättrad HTML-vy
# Klicka på estimatornamnen för att expandera/kollapsa
# Hovra över parametrar för beskrivningar
# Klicka på parameterlänkar för att öppna dokumentationen
pipeline

Dessa förbättringar bygger vidare på det som introducerades i 1.7 (parameterlista med icke-standardvärden markerade i orange, kopieringsknapp). Sammantaget gör det arbetet med komplexa pipelines i Jupyter betydligt smidigare.

Vad kom i version 1.6 och 1.7

Uppgraderar du direkt från en äldre version till 1.8? Då kan det vara värt att snabbt gå igenom de viktigaste nyheterna från 1.6 och 1.7.

Scikit-learn 1.6 — Nyckelfeatures

• FrozenEstimator: En meta-estimator som "fryser" en estimator så att fit()-anrop inte gör något, och clone() returnerar samma (anpassade) estimator. Superpraktiskt för att använda föranpassade modeller i pipelines.
• Saknade värden i ExtraTrees: ExtraTreesClassifier, ExtraTreesRegressor och deras ensamma varianter kan nu hantera NaN-värden i indatat. Saknade värden hanteras genom att slumpmässigt fördela sampel till vänster eller höger barnnod.
• Multinomial LogisticRegression med newton-cholesky: Newton-cholesky-lösaren stöder nu flerklassklassificering, inte bara binär.
• Komplett metadata routing: Stöd för metadata routing har lagts till för alla återstående estimatorer och funktioner (utom AdaBoost).

Scikit-learn 1.7 — Nyckelfeatures

• HistGradientBoosting valideringsdata: Du kan nu explicit ange valideringsdata (X_val, y_val, sample_weight_val) direkt i fit()-metoden för early stopping.
• MLPClassifier/MLPRegressor sample_weight: Neurala nätverksmodellerna stöder nu sample weights — äntligen konsistent med resten av scikit-learns API.
• HTML-representation av parametrar: Estimatorernas HTML-vy i Jupyter fick en parametersektion med icke-standardvärden markerade i orange och en kopieringsknapp.
• Sparse arrays: Alla estimatorer som accepterar sparse-matriser accepterar nu även sparse-arrayer som förberedelse för SciPys migrering.

from sklearn.frozen import FrozenEstimator
from sklearn.ensemble import RandomForestClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

# Exempel: Använd en föranpassad modell i en pipeline med FrozenEstimator
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

X, y = make_classification(n_samples=1000, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)

# Frys modellen — fit() gör ingenting, clone() returnerar samma modell
frusen_rf = FrozenEstimator(rf)

# Kan nu användas i meta-estimatorer utan att omtränas
pipeline = make_pipeline(StandardScaler(), frusen_rf)
pipeline.fit(X_train, y_train)  # StandardScaler tränas, RF förblir oförändrad

Migration och uppgradering till scikit-learn 1.8

Att uppgradera till scikit-learn 1.8 är generellt sett okomplicerat, men det finns några saker att ha koll på.

Installation

# Uppgradera via pip
pip install --upgrade scikit-learn

# Eller via conda
conda install -c conda-forge scikit-learn

# Verifiera installationen
python -c "import sklearn; print(sklearn.__version__)"
# Förväntat resultat: 1.8.0

Python-version

Scikit-learn 1.8 stöder Python 3.11 till 3.14. Sitter du fortfarande på Python 3.10 eller äldre? Då behöver du uppgradera din Python-installation först. Vill du dra nytta av free-threaded CPython så krävs Python 3.14 med free-threaded-builden.

Viktiga deprecations och API-ändringar

Version 1.8 introducerar flera deprecations som du bör vara medveten om:

• LogisticRegression penalty-parameter: penalty-parametern är deprecated i 1.8 och tas bort i 1.10. Använd istället l1_ratio (l1_ratio=0 motsvarar penalty="l2").
• PassiveAggressiveClassifier/Regressor: Deprecated i 1.8, tas bort i 1.10. Använd istället SGDClassifier(loss="hinge", learning_rate="pa1").
• utils.extmath.stable_cumsum: Deprecated, tas bort i 1.10.
• metrics.cluster.entropy: Deprecated, tas bort i 1.10.
• SGD-modeller eta0: Kräver nu ett strikt positivt värde. Standardvärdet har ändrats från 0 till 0.01 för SGDClassifier och SGDOneClassSVM.

Kodexempel: Hantera deprecations

from sklearn.linear_model import LogisticRegression, SGDClassifier

# GAMMALT SÄTT (deprecated i 1.8, tas bort i 1.10):
# clf = LogisticRegression(penalty="l2")

# NYTT SÄTT — använd l1_ratio istället:
clf_l2 = LogisticRegression(l1_ratio=0)  # Motsvarar penalty="l2"
clf_l1 = LogisticRegression(l1_ratio=1)  # Motsvarar penalty="l1"
clf_en = LogisticRegression(l1_ratio=0.5)  # Elastic Net

# GAMMALT SÄTT (deprecated):
# from sklearn.linear_model import PassiveAggressiveClassifier
# pa_clf = PassiveAggressiveClassifier()

# NYTT SÄTT — använd SGDClassifier:
sgd_clf = SGDClassifier(loss="hinge", learning_rate="pa1")

Rekommendationer för en smidig migrering

1. Kör dina befintliga tester efter uppgraderingen och granska eventuella DeprecationWarnings.
2. Uppdatera kod som använder deprecated parametrar och klasser.
3. Om du vill använda Array API, aktivera det med sklearn.config_context(array_api_dispatch=True).
4. Testa att din kod fungerar med eventuella nya standardvärden.
5. Om du jobbar med stora datamängder, kontrollera att du drar nytta av de nya prestandaoptimeringarna.

Nya metriker och övriga förbättringar

Utöver de stora nyheterna innehåller scikit-learn 1.8 flera mindre men användbara förbättringar som är värda att känna till:

• Nya metriker: d2_brier_score och confusion_matrix_at_thresholds har lagts till. Den sistnämnda returnerar TP, FP, FN och TN per tröskel — väldigt användbart för att analysera klassificerares beteende vid olika tröskelvärden.
• QuadraticDiscriminantAnalysis: Nya parametrar solver, covariance_estimator och shrinkage gör klassen mer flexibel och konsistent med LinearDiscriminantAnalysis.
• MinCovDet: Konsistenskorrigering har lagts till för normalfördelad data.
• SplineTransformer: Stöder nu saknade värden via parametern handle_missing.
• MaxAbsScaler: Ny parameter clip=True klipper värden utanför det inlärda intervallet.
• Förbättrade felmeddelanden: Bättre felmeddelanden för sparse-indata och förbättrad validering av sample_weight.

from sklearn.metrics import d2_brier_score
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

# Skapa data och träna modell
X, y = make_classification(n_samples=1000, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

clf = LogisticRegression(random_state=42)
clf.fit(X_train, y_train)

# Ny metrik: D2 Brier score
y_prob = clf.predict_proba(X_test)[:, 1]
d2_score = d2_brier_score(y_test, y_prob)
print(f"D2 Brier score: {d2_score:.4f}")

Sammanfattning

Scikit-learn 1.8 är en riktigt stark release som tar Pythons mest använda maskininlärningsbibliotek ett rejält steg framåt. Här är de viktigaste nyheterna i korthet:

• GPU-acceleration via Array API öppnar dörren för hårdvaruaccelererade beräkningar med PyTorch och CuPy — upp till 10 gånger snabbare för stödda estimatorer.
• Temperaturskaliering i CalibratedClassifierCV ger en elegant lösning för sannolikhetskalibrering i flerklassproblem.
• Free-threaded CPython 3.14 stöd banar väg för effektivare trådbaserad parallellism utan GIL.
• Gap safe screening rules ger upp till 10x snabbare Lasso och ElasticNet.
• DecisionTreeRegressor med absolute_error går från O(n²) till O(n log n), vilket gör robust regression praktiskt användbart på stora dataset.
• ClassicalMDS tillför en snabb och deterministisk metod för manifold learning.
• Förbättrad HTML-representation med dokumentationslänkar och verktygstips gör Jupyter-arbetet smidigare.

Oavsett om du jobbar med klassisk maskininlärning, experimenterar med GPU-acceleration eller behöver snabbare träning av regulariserade modeller — version 1.8 har något att erbjuda. Uppgradera och börja utforska redan idag.