Machine Learning Academy · leksjon

Lagre og laste inn en pipeline med joblib

Deltakere vil serialisere en tilpasset Pipeline til disk med joblib.dump og laste den inn igjen i en ny Python-økt for å lage prediksjoner uten å trene på nytt.

Leksjon 4 av 413 trinn

Lagre og laste inn en pipeline med joblib er en gratis leksjon i Machine Learning Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Machine Learning Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.

Hvorfor lagre en trent pipeline?

Det kan ta minutter eller timer å trene en maskinlæringspipeline. Når den er tilpasset, vil De lagre den på disk slik at De kan laste den inn igjen senere for prediksjoner uten å trene på nytt. Persistens er også avgjørende for distribusjon: De trener på en utviklingsmaskin og leverer prediksjoner fra en produksjonsserver. Den lagrede filen må inneholde både forhåndsbehandlingstrinnene og modellvektene.

To serialiseringsalternativer: pickle og joblib

Pythons innebygde pickle-modul kan serialisere alle Python-objekter, inkludert sklearn-pipelines. joblib er et tredjepartsbibliotek (inkludert med scikit-learn) som vanligvis foretrekkes for ML-objekter fordi det er mer effektivt for store NumPy-matriser – det bruker minnekartlegging i stedet for kopiering – og kan komprimere utdatafilen automatisk.

import pickle
import joblib

# Both approaches work; joblib is recommended for sklearn objects
print('pickle version:', pickle.HIGHEST_PROTOCOL)
import sklearn
print('sklearn version:', sklearn.__version__)

Lagre med joblib.dump

joblib.dump(obj, filename) serialiserer pipelinen til en fil. De kan valgfritt angi compress=3 for å bruke zlib-komprimering (nivå 1–9; 3 gir en god balanse mellom hastighet og størrelse). Funksjonen returnerer en liste over opprettede filer. For de fleste pipelines opprettes én enkelt .pkl- eller .joblib-fil.

import joblib
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris

X, y = load_iris(return_X_y=True)

pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('clf', LogisticRegression(C=1.0, max_iter=200))
])
pipe.fit(X, y)

# Save
joblib.dump(pipe, '/tmp/iris_pipeline.joblib')
print('Pipeline saved!')

Laste inn med joblib.load

joblib.load(filename) deserialiserer pipelinen tilbake til et Python-objekt. Den innlastede pipelinen er identisk med originalen: Den har de samme tilpassede skaleringsparametrene (gjennomsnitt og varians) og de samme modellvektene. De kan umiddelbart kalle predict, predict_proba eller score uten å tilpasse modellen på nytt.

import joblib
from sklearn.datasets import load_iris
import numpy as np

X, y = load_iris(return_X_y=True)

# Load the saved pipeline
loaded_pipe = joblib.load('/tmp/iris_pipeline.joblib')

# Predict and verify
predictions = loaded_pipe.predict(X[:5])
print('Predictions:', predictions)
print('Test accuracy:', loaded_pipe.score(X, y).round(4))

Kontrollere troskap ved tur-retur

Etter innlasting bør De bekrefte at den innlastede pipelinen gir identiske prediksjoner som originalen. Ethvert avvik tyder på en serialiseringsfeil eller en inkompatibilitet mellom versjoner. En enkel kontroll er å sammenligne prediksjonene element for element ved hjelp av np.array_equal.

import joblib
import numpy as np
from sklearn.datasets import load_iris

X, _ = load_iris(return_X_y=True)

# Reload and compare
loaded = joblib.load('/tmp/iris_pipeline.joblib')

# Reload the original reference predictions
# (in practice, save original predictions before reload)
original_preds = loaded.predict(X)  # use loaded as reference
loaded2 = joblib.load('/tmp/iris_pipeline.joblib')
reloaded_preds = loaded2.predict(X)

print('Predictions match:', np.array_equal(original_preds, reloaded_preds))

Komprimeringsalternativer i joblib

Store pipelines (for eksempel med en RandomForest med 1000 trær) kan være på flere hundre MB. Bruk joblib.dump(pipe, path, compress=3) for å komprimere underveis. Alternativt kan De angi komprimeringsverktøyet eksplisitt: compress=('zlib', 3) eller compress=('lz4', 1) for maksimal hastighet. LZ4 er raskest, mens zlib gir mindre filer, men er langsommere.

import joblib
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
import os

X, y = load_iris(return_X_y=True)
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression())]).fit(X, y)

# Uncompressed
joblib.dump(pipe, '/tmp/pipe_raw.joblib')
# Compressed
joblib.dump(pipe, '/tmp/pipe_compressed.joblib', compress=3)

print('Raw size:', os.path.getsize('/tmp/pipe_raw.joblib'), 'bytes')
print('Compressed size:', os.path.getsize('/tmp/pipe_compressed.joblib'), 'bytes')

Bruke pickle som et alternativ

Hvis joblib ikke er tilgjengelig, fungerer pickle for sklearn-pipelines. Bruk binærmodus ('rb'/'wb') når De åpner filen. For små modeller eller engangsverktøy i skriptform er pickle helt greit; for produksjonssystemer som håndterer store NumPy-matriser, anbefales joblib på det sterkeste.

import pickle
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris

X, y = load_iris(return_X_y=True)
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression())]).fit(X, y)

# Save with pickle
with open('/tmp/model.pkl', 'wb') as f:
    pickle.dump(pipe, f)

# Load with pickle
with open('/tmp/model.pkl', 'rb') as f:
    loaded = pickle.load(f)

print('Loaded score:', loaded.score(X, y).round(4))

Advarsler om versjonskompatibilitet

En kritisk bekymring i produksjon er at en pipeline som er serialisert med scikit-learn 1.2, kanskje ikke lastes inn korrekt i scikit-learn 1.5. Registrer alltid bibliotekversjonene som ble brukt under treningen, i en metadatafil sammen med den lagrede modellen. Bruk pip freeze > requirements.txt, eller registrer versjonene programmatisk og lagre dem ved siden av modellfilen.

import sklearn
import numpy as np
import json
import os

metadata = {
    'sklearn_version': sklearn.__version__,
    'numpy_version': np.__version__,
    'model_file': 'iris_pipeline.joblib'
}

with open('/tmp/model_metadata.json', 'w') as f:
    json.dump(metadata, f, indent=2)

print(json.dumps(metadata, indent=2))

Laste inn en pipeline i et produksjonsskript

I en produksjonstjeneste er arbeidsflyten slik: Last inn pipelinen én gang ved oppstart (ikke for hver forespørsel), motta inndatafunksjoner, forhåndsbehandle dem med pipelinens innebygde transformasjoner og returner prediksjoner. Siden pipelinen inneholder all forhåndsbehandling, trenger ikke serveringskoden å kjenne til skalering, koding eller PCA – alt dette er kapslet inn i det lagrede objektet.

import joblib
import numpy as np

# At startup (once)
model = joblib.load('/tmp/iris_pipeline.joblib')

def predict(sepal_length, sepal_width, petal_length, petal_width):
    features = np.array([[sepal_length, sepal_width, petal_length, petal_width]])
    label = model.predict(features)[0]
    proba = model.predict_proba(features)[0]
    return {'label': int(label), 'confidence': round(float(proba.max()), 4)}

result = predict(5.1, 3.5, 1.4, 0.2)
print('Prediction result:', result)

Sikkerhetshensyn ved bruk av pickle-modeller

Last aldri inn en pickle-fil fra en kilde De ikke stoler på. Pickle-filer kan kjøre vilkårlig kode ved innlasting – dette er en grunnleggende sikkerhetsbegrensning i Python. For deling av modeller eksternt bør De vurdere tryggere, formatske alternativer: ONNX for serialisering på tvers av rammeverk, eller joblib-filer som bare deles innenfor en pålitelig infrastruktur. Kontroller alltid filens kontrollsum før innlasting.

import hashlib

def file_sha256(path):
    h = hashlib.sha256()
    with open(path, 'rb') as f:
        for chunk in iter(lambda: f.read(65536), b''):
            h.update(chunk)
    return h.hexdigest()

checksum = file_sha256('/tmp/iris_pipeline.joblib')
print('Model SHA-256:', checksum)

# In production: compare this checksum with the one stored in your model registry

Rask fornuftssjekk av innlasting og prediksjon

En siste anbefaling er å inkludere et kort testskript i modellpakken som laster inn pipelinen, kjører en kjent inndata og kontrollerer at utdataene som forventet. Kjør denne testen i CI/CD-pipelinen hver gang modellen settes i produksjon, slik at De bekrefter at filen ikke er skadet og at miljøet er kompatibelt.

import joblib
import numpy as np

# Sanity test
model = joblib.load('/tmp/iris_pipeline.joblib')

# Known input (setosa): sepal_length=5.1, sepal_width=3.5, petal_length=1.4, petal_width=0.2
X_test = np.array([[5.1, 3.5, 1.4, 0.2]])
pred = model.predict(X_test)[0]

# Iris class 0 = setosa
assert pred == 0, f'Expected setosa (0) but got {pred}'
print('Sanity test PASSED — model predicts setosa correctly.')

Rask sjekk

Test forståelsen Deres av lagring og innlasting av pipelines fra denne leksjonen.

Besvar den i den interaktive leksjonen

Oppsummering av leksjonen

I denne leksjonen har De lært: joblib.dump og joblib.load lagrer og gjenoppretter en komplett tilpasset pipeline, inkludert alle forhåndsbehandlingsparametere, registrer alltid bibliotekversjonene sammen med den lagrede modellen for å sikre at den kan lastes inn på en reproduserbar måte, og last aldri inn pickle-filer fra kilder De ikke stoler på, siden de kan kjøre vilkårlig kode. Deretter tar vi for oss ubalanserte datasett – hvordan klasseubalanse oppdages, og hvorfor nøyaktighet er et misvisende mål i slike situasjoner.

Gratis å komme i gang

Lær deg Python med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 30
Leksjoner: 120

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Lagre og laste inn en pipeline med joblib» gratis?

Ja – hele teksten i «Lagre og laste inn en pipeline med joblib» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Machine Learning Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Machine Learning Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Lagre og laste inn en pipeline med joblib»?

Deltakere vil serialisere en tilpasset Pipeline til disk med joblib.dump og laste den inn igjen i en ny Python-økt for å lage prediksjoner uten å trene på nytt. Du øver på Machine Learning Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Machine Learning Academy?

Ingen tidligere erfaring er nødvendig. Machine Learning Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Lagre og laste inn en pipeline med joblib»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Machine Learning Academy-leksjonen?

Ja. Alle Machine Learning Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Bygge den første pipelinen: Skalerer pluss klassifikator
ColumnTransformer i en pipeline
Kryssvalidere og grid-søke i en full pipeline
Lagre og laste inn en pipeline med joblib

← Tilbake til Machine Learning Academy