Lagre modeller med joblib og pickle
Deltakere vil serialisere en trent pipeline med både joblib og pickle, laste den inn igjen og kontrollere at prediksjonene er identiske for å bekrefte at tur-retur-operasjonen var vellykket.
Lagre modeller med joblib og pickle er en gratis leksjon i Machine Learning Academy på CoddyKit. Dette er leksjon 1 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 det er viktig å lagre modeller
Det er kostbart å trene en maskinlæringsmodell: Det kan ta fra minutter til timer og krever betydelige beregningsressurser. Lagring av modellen lagrer den tilpassede modellen på disken, slik at De kan laste den inn umiddelbart for inferens uten å trene den på nytt. Dette er forbindelsen mellom data science-notatboken og et produksjonssystem – den serialiserte modellfilen er artefakten som kan distribueres, og som dataingeniører pakker og gjør tilgjengelig.
Hva lagres i en modellfil?
Når De serialiserer en tilpasset sklearn-modell eller pipeline, inneholder filen: alle tilpassede parametere (for eksempel gjennomsnitt og varians for skalering, trestruktur og koeffisienter for logistisk regresjon), innstillinger for hyperparametere og referansen til Python-klassedefinisjonen. Treningsdataene er IKKE inkludert. Når filen lastes inn, gjenopprettes et Python-objekt som er klart til å kalle predict umiddelbart.
Lagre med joblib.dump
joblib er det anbefalte serialiseringsverktøyet for sklearn-objekter. Det håndterer store NumPy-arrayer effektivt ved hjelp av minnekartlegging og støtter transparent komprimering. Den vanlige arbeidsflyten er å trene modellen, lagre den i en .joblib-fil og deretter laste den inn i et separat skript eller en tjeneste for inferens.
import joblib
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_breast_cancer
X, y = load_breast_cancer(return_X_y=True)
pipe = Pipeline([
('scaler', StandardScaler()),
('clf', LogisticRegression(C=1.0, max_iter=300))
])
pipe.fit(X, y)
# Save
joblib.dump(pipe, '/tmp/cancer_model.joblib')
print('Model saved to /tmp/cancer_model.joblib')Laste inn med joblib.load
joblib.load deserialiserer filen og returnerer nøyaktig det samme tilpassede pipeline-objektet. Den innlastede modellen har alle de samme attributtene – named_steps, tilpassede skaleringsparametere og klassifiseringskoeffisienter – som originalen. De kan umiddelbart kalle predict, predict_proba eller score uten ytterligere oppsett.
import joblib
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
# Load in a fresh context
model = joblib.load('/tmp/cancer_model.joblib')
predictions = model.predict(X_test[:5])
print('Predictions:', predictions)
print('Test accuracy:', model.score(X_test, y_test).round(4))Bruke pickle til serialisering
Pythons standardbiblioteksmodul pickle kan også serialisere sklearn-objekter. Åpne filer i binærmodus ('wb' for skriving, 'rb' for lesing). Konstanten pickle.HIGHEST_PROTOCOL bruker den mest effektive tilgjengelige protokollen. For små modeller eller i skriptsammenheng er pickle fullt ut tilstrekkelig.
import pickle
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
X, y = load_iris(return_X_y=True)
model = LogisticRegression().fit(X, y)
# Save
with open('/tmp/iris_model.pkl', 'wb') as f:
pickle.dump(model, f, protocol=pickle.HIGHEST_PROTOCOL)
# Load
with open('/tmp/iris_model.pkl', 'rb') as f:
loaded = pickle.load(f)
print('Score:', loaded.score(X, y).round(4))
print('Coefficients shape:', loaded.coef_.shape)Sammenligne filstørrelser for joblib og pickle
For en stor modell, for eksempel en RandomForest med 1000 trær, er joblibs lagring av NumPy-arrayer med minnekartlegging mer effektiv. Forskjellen blir særlig tydelig når modellen inneholder store parametermatriser. For små modeller (LogReg, SVM) er forskjellen i størrelse ubetydelig.
import joblib
import pickle
import os
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
X, y = make_classification(n_samples=1000, n_features=20, random_state=0)
rf = RandomForestClassifier(n_estimators=100, random_state=0).fit(X, y)
# joblib
joblib.dump(rf, '/tmp/rf_model.joblib')
# pickle
with open('/tmp/rf_model.pkl', 'wb') as f:
pickle.dump(rf, f)
print(f'joblib size: {os.path.getsize("/tmp/rf_model.joblib"):,} bytes')
print(f'pickle size: {os.path.getsize("/tmp/rf_model.pkl"):,} bytes')Komprimering med joblib
Bruk joblib.dump(model, path, compress=3) for å komprimere filen med zlib. Komprimeringsnivåene går fra 1 (raskt, større) til 9 (sakte, minst). Nivå 3 er et praktisk standardvalg. For LZ4-komprimering (raskere enn zlib): compress=('lz4', 1). Lastetiden øker litt for komprimerte filer, men besparelsene på nettverksoverføring og lagring er ofte verdt det.
import joblib
import os
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
X, y = make_classification(n_samples=1000, random_state=0)
rf = RandomForestClassifier(n_estimators=100, random_state=0).fit(X, y)
for level in [0, 3, 6, 9]:
path = f'/tmp/rf_compress_{level}.joblib'
joblib.dump(rf, path, compress=level)
size = os.path.getsize(path)
print(f'compress={level}: {size:,} bytes')Kontroll av konsistens etter tur-retur
Etter innlasting må De alltid kontrollere at den innlastede modellen gir identiske prediksjoner som originalen. Dette beskytter mot skjult korrupsjon, versjonskonflikter eller ufullstendige filskrivinger. Sammenlign prediksjonene med np.array_equal på samme inndata.
import joblib
import numpy as np
from sklearn.datasets import load_iris
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
X, y = load_iris(return_X_y=True)
pipe = Pipeline([('sc', StandardScaler()), ('lr', LogisticRegression())]).fit(X, y)
original_preds = pipe.predict(X)
joblib.dump(pipe, '/tmp/verify_pipe.joblib')
loaded = joblib.load('/tmp/verify_pipe.joblib')
loaded_preds = loaded.predict(X)
if np.array_equal(original_preds, loaded_preds):
print('Round-trip PASSED: predictions are identical.')
else:
diff = (original_preds != loaded_preds).sum()
print(f'Round-trip FAILED: {diff} different predictions!')Låsing av versjoner og metadata
En modell som er serialisert med scikit-learn 1.2, lastes kanskje ikke inn uten problemer i scikit-learn 1.5 på grunn av interne endringer. Lagre alltid en metadatafil sammen med modellen som registrerer: sklearn-versjon, Python-versjon, treningsdato, datasettversjon og nøkkelmetrikker. Dette er modellkortet Deres — styringsdokumentet som forklarer hva modellen er, og hvordan den ble produsert.
import json
import sklearn
import sys
from datetime import datetime
metadata = {
'model_file': 'cancer_model.joblib',
'sklearn_version': sklearn.__version__,
'python_version': sys.version.split()[0],
'training_date': datetime.utcnow().isoformat(),
'dataset': 'breast_cancer',
'test_accuracy': 0.9789,
'features': 30,
'algorithm': 'LogisticRegression'
}
with open('/tmp/cancer_model_metadata.json', 'w') as f:
json.dump(metadata, f, indent=2)
print(json.dumps(metadata, indent=2))Sikkerhet: Last aldri inn pickle-filer fra ukjente kilder
Kritisk sikkerhetsadvarsel: både pickle og joblib kan kjøre vilkårlig Python-kode ved innlasting. Last aldri inn en modellfil fra en kilde De ikke stoler på — den kan være en skadelig nyttelast forkledd som en modell. For modeller som deles mellom organisasjoner bør De vurdere sikrere formater: ONNX (Open Neural Network Exchange) er et standardisert format som kan inspiseres, og som støttes av de fleste rammeverk.
Konvensjoner for filnavn
Gode navnekonvensjoner legger viktig informasjon inn i filnavnet: algoritme, datasett, dato og metrikk. Dette gjør modellregisteret selvforklarende og hindrer at De ved et uhell laster inn feil modellversjon i produksjon.
from datetime import date
from sklearn.metrics import accuracy_score
import joblib
# Example naming convention
dataset = 'breast_cancer'
algorithm = 'logreg'
test_acc = 0.9789
today = date.today().strftime('%Y%m%d')
filename = f'{dataset}_{algorithm}_{today}_acc{int(test_acc*100)}.joblib'
print('Model filename:', filename)
# e.g.: breast_cancer_logreg_20260620_acc97.joblib
# Load the model we saved earlier (demo)
model = joblib.load('/tmp/cancer_model.joblib')
print('Loaded OK')Rask kontroll
Test forståelsen Deres av modellserialisering med joblib og pickle fra denne leksjonen.
Oppsummering av leksjonen
I denne leksjonen har De lært at joblib.dump og joblib.load serialiserer og gjenoppretter tilpassede sklearn-modeller effektivt, at pickle fungerer også, men joblib foretrekkes for modeller med store NumPy-matriser på grunn av minnetilordning, og at De alltid bør lagre en metadatafil sammen med modellen med bibliotekversjoner, treningsdato og nøkkelmetrikker av hensyn til styring. Neste steg er å utforme en navnekonvensjon for versjonering og en metadatafil ved siden av modellen for å følge flere modellversjoner i et modellregister.
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
Ofte stilte spørsmål
Er leksjonen «Lagre modeller med joblib og pickle» gratis?
Ja – hele teksten i «Lagre modeller med joblib og pickle» 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 modeller med joblib og pickle»?
Deltakere vil serialisere en trent pipeline med både joblib og pickle, laste den inn igjen og kontrollere at prediksjonene er identiske for å bekrefte at tur-retur-operasjonen var vellykket. 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 1 av 4.
Hvor lang tid tar leksjonen «Lagre modeller med joblib og pickle»?
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
- Lagre modeller med joblib og pickle
- Versjonere modeller: Hvorfor filnavn og metadata er viktige
- Betjene prediksjoner med et FastAPI-endepunkt
- Overvåke prediksjoner: Loggføre inndata og utdata