Lewati ke isi

Menyimpan Model, Deployment, dan Monitoring

Gambaran singkat

Apa ini? Cara menyimpan model terlatih, memakainya pada data baru, dan memantau apakah ia masih bekerja baik setelah dipakai.

Analogi

Resep yang sudah sempurna perlu ditulis, bukan diingat. Setelah dipakai di dapur, Anda juga memeriksa apakah rasanya tetap konsisten ketika bahan berubah.

Mengapa penting? Model yang hanya ada di notebook tidak berguna bagi pengguna. Setelah dipakai, data dunia nyata berubah sehingga kinerja bisa menurun tanpa disadari.

Yang akan dipelajari, berurutan:

  1. Menyimpan pipeline utuh dan metadatanya dengan joblib.
  2. Memprediksi data baru dengan format kolom yang benar.
  3. Opsi deployment dan risiko keamanan berkas model.
  4. Memantau pergeseran data (data drift).

Istilah awal:

Istilah Arti sederhana
Pipeline Rangkaian praproses dan model sebagai satu kesatuan
joblib Pustaka penyimpan objek Python ke berkas
Data drift Pola data baru berbeda dari data latih
Deployment Menyediakan model agar bisa dipakai

Tujuan pembelajaran

  • Menyimpan dan memuat Pipeline utuh dengan joblib, beserta metadata.
  • Memprediksi data baru dengan format kolom yang benar.
  • Memahami opsi deployment dan risiko keamanan berkas model.
  • Memantau pergeseran data (data drift) setelah model dipakai.

Menyimpan model

Simpan pipeline utuh (praproses + model), bukan model saja, agar data baru mengalami praproses yang sama persis. Catat juga metadata: versi pustaka, daftar fitur, arti kelas, dan cara model dilatih.

Keamanan berkas model

joblib (dan pickle) dapat mengeksekusi kode saat dimuat. Jangan memuat berkas model dari sumber yang tidak tepercaya. Model yang disimpan dengan versi scikit-learn tertentu juga sebaiknya dimuat dengan versi yang sama; versi berbeda dapat menimbulkan galat atau hasil berbeda.

Implementasi langkah demi langkah

Program examples/classification/saving.py melatih regresi logistik pada Breast Cancer lalu menyimpan, memuat, memprediksi, dan memantaunya. Bagian pemantauan memakai batch "data baru" sintetis: salinan data uji dengan fitur mean radius sengaja digeser 30% untuk mensimulasikan perubahan data. Program lengkap ada di akhir bagian ini.

Langkah 1: menyimpan pipeline dan metadata

Tujuan. Menyimpan model terlatih agar dapat dipakai lagi tanpa melatih ulang, bersama catatan yang dibutuhkan untuk memakainya dengan benar.

saving.py
SEED = 42
X, y = load_breast_cancer(return_X_y=True, as_frame=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=SEED
)
model = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000)).fit(X_train, y_train)

# 1. Simpan pipeline utuh (praproses + model) dan metadata
out_dir = Path(tempfile.mkdtemp())
joblib.dump(model, out_dir / "breast_cancer_model.joblib")
meta = {
    "sklearn_version": sklearn.__version__,
    "features": list(X.columns),
    "classes": {"0": "ganas", "1": "jinak"},
    "metric_note": "dilatih pada data latih (stratified split, seed 42)",
}
(out_dir / "metadata.json").write_text(json.dumps(meta, indent=2), encoding="utf-8")
print("berkas tersimpan:", sorted(p.name for p in out_dir.iterdir()))
Kode Penjelasan
Path(tempfile.mkdtemp()) Membuat folder sementara baru dan membungkusnya sebagai Path agar mudah dipakai. Pada proyek nyata, gunakan folder pilihan Anda.
joblib.dump(model, out_dir / "...joblib") Serialisasi: menyimpan objek model (seluruh pipeline: scaler + model yang sudah dilatih) ke berkas. Operator / pada Path menyambung folder dan nama berkas.
meta = {...} Kamus metadata: versi scikit-learn saat pelatihan, daftar fitur dan urutannya, arti kelas, dan catatan pelatihan.
json.dumps(meta, indent=2) Mengubah kamus menjadi teks JSON yang rapi; write_text menuliskannya ke berkas.
sorted(p.name for p in out_dir.iterdir()) Daftar nama berkas di folder, urut abjad.
berkas tersimpan: ['breast_cancer_model.joblib', 'metadata.json']

Mengapa pipeline utuh. Bila hanya model yang disimpan tanpa scaler, data baru tidak mengalami standardisasi yang sama dan prediksinya salah.

Langkah 2: memuat ulang dan memverifikasi

saving.py
# 2. Muat kembali dan pastikan prediksinya identik
loaded = joblib.load(out_dir / "breast_cancer_model.joblib")
same = np.array_equal(model.predict(X_test), loaded.predict(X_test))
print("prediksi model asli == model termuat:", same)

joblib.load membaca berkas dan mengembalikan objek pipeline yang siap dipakai. np.array_equal(a, b) memeriksa apakah dua array sama persis; di sini membandingkan prediksi model asli dan model termuat.

prediksi model asli == model termuat: True

Hasil. True: prediksi identik. Uji sederhana ini layak dilakukan setiap kali menyimpan model.

Langkah 3: prediksi untuk satu sampel baru

Konsep. Pipeline yang disimpan mengharapkan kolom yang sama dengan data latih (nama dan urutan). Karena itu masukan harus berupa DataFrame, bukan list angka.

saving.py
# 3. Prediksi untuk satu sampel baru (harus berupa DataFrame dengan nama kolom yang sama)
new_sample = X_test.iloc[[0]]
print("P(ganas, jinak):", loaded.predict_proba(new_sample)[0].round(3), "| label asli:", int(y_test.iloc[0]))

X_test.iloc[[0]] dengan dua kurung siku menghasilkan DataFrame berisi satu baris (satu kurung menghasilkan Series yang tidak cocok). predict_proba(new_sample)[0] mengambil baris pertama probabilitas: urutan kolom [P(kelas 0 = ganas), P(kelas 1 = jinak)].

P(ganas, jinak): [1. 0.] | label asli: 0

Hasil. Probabilitas ganas ≈ 1,0 dan jinak ≈ 0,0, sesuai label asli 0 (ganas).

Langkah 4: memantau pergeseran fitur (data drift)

Konsep. Setelah model dipakai, data baru dapat berbeda dari data latih. Uji Kolmogorov–Smirnov (ks_2samp) membandingkan dua distribusi: p-value kecil berarti distribusinya berbeda secara statistik.

saving.py
# 4. Pemantauan sederhana: apakah distribusi data baru bergeser dari data latih?
#    Batch "baru" di bawah ini SINTETIS: salinan data uji dengan 'mean radius' digeser 30%.
new_batch = X_test.copy()
new_batch["mean radius"] = new_batch["mean radius"] * 1.3
print("\nfitur              p-value KS (data latih vs batch baru)")
for col in ["mean radius", "mean texture", "mean smoothness"]:
    p = ks_2samp(X_train[col], new_batch[col]).pvalue
    print(f"{col:<18} {p:.4f}", "<- bergeser" if p < 0.01 else "")

new_batch["mean radius"] * 1.3 menggeser satu fitur 30% (simulasi). Perulangan menghitung p-value KS untuk tiga fitur: ks_2samp(X_train[col], new_batch[col]).pvalue. Ambang 0,01 hanyalah pilihan di sini; teks "<- bergeser" dicetak bila p-value di bawahnya.

fitur              p-value KS (data latih vs batch baru)
mean radius        0.0000 <- bergeser
mean texture       0.6342 
mean smoothness    0.6264 

Interpretasi. mean radius mendapat p-value ≈ 0,0000 (jelas bergeser), sedangkan mean texture (0,634) dan mean smoothness (0,626) tidak. Uji statistik hanyalah sinyal untuk diperiksa; sampel besar dapat menandai pergeseran yang kecil secara praktis.

Langkah 5: memantau keluaran model

saving.py
# 5. Pemantauan keluaran: porsi prediksi 'ganas' sebelum dan sesudah pergeseran
share_before = (loaded.predict(X_test) == 0).mean()
share_after = (loaded.predict(new_batch) == 0).mean()
print("\nporsi diprediksi ganas -> data uji: %.3f | batch bergeser: %.3f" % (share_before, share_after))

(loaded.predict(X_test) == 0).mean() menghitung proporsi sampel yang diprediksi ganas (membandingkan dengan 0 menghasilkan True/False, dan rata-ratanya adalah proporsinya).

porsi diprediksi ganas -> data uji: 0.368 | batch bergeser: 0.404

Interpretasi. Porsi prediksi "ganas" naik dari 0,368 (data uji) menjadi 0,404 pada batch yang bergeser. Perubahan distribusi prediksi, bahkan tanpa label, sering menjadi tanda awal masalah.

Program lengkap (saving.py)
saving.py
import json
import tempfile
from pathlib import Path

import joblib
import numpy as np
import sklearn
from scipy.stats import ks_2samp
from sklearn.datasets import load_breast_cancer
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

SEED = 42
X, y = load_breast_cancer(return_X_y=True, as_frame=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=SEED
)
model = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000)).fit(X_train, y_train)

# 1. Simpan pipeline utuh (praproses + model) dan metadata
out_dir = Path(tempfile.mkdtemp())
joblib.dump(model, out_dir / "breast_cancer_model.joblib")
meta = {
    "sklearn_version": sklearn.__version__,
    "features": list(X.columns),
    "classes": {"0": "ganas", "1": "jinak"},
    "metric_note": "dilatih pada data latih (stratified split, seed 42)",
}
(out_dir / "metadata.json").write_text(json.dumps(meta, indent=2), encoding="utf-8")
print("berkas tersimpan:", sorted(p.name for p in out_dir.iterdir()))

# 2. Muat kembali dan pastikan prediksinya identik
loaded = joblib.load(out_dir / "breast_cancer_model.joblib")
same = np.array_equal(model.predict(X_test), loaded.predict(X_test))
print("prediksi model asli == model termuat:", same)

# 3. Prediksi untuk satu sampel baru (harus berupa DataFrame dengan nama kolom yang sama)
new_sample = X_test.iloc[[0]]
print("P(ganas, jinak):", loaded.predict_proba(new_sample)[0].round(3), "| label asli:", int(y_test.iloc[0]))

# 4. Pemantauan sederhana: apakah distribusi data baru bergeser dari data latih?
#    Batch "baru" di bawah ini SINTETIS: salinan data uji dengan 'mean radius' digeser 30%.
new_batch = X_test.copy()
new_batch["mean radius"] = new_batch["mean radius"] * 1.3
print("\nfitur              p-value KS (data latih vs batch baru)")
for col in ["mean radius", "mean texture", "mean smoothness"]:
    p = ks_2samp(X_train[col], new_batch[col]).pvalue
    print(f"{col:<18} {p:.4f}", "<- bergeser" if p < 0.01 else "")

# 5. Pemantauan keluaran: porsi prediksi 'ganas' sebelum dan sesudah pergeseran
share_before = (loaded.predict(X_test) == 0).mean()
share_after = (loaded.predict(new_batch) == 0).mean()
print("\nporsi diprediksi ganas -> data uji: %.3f | batch bergeser: %.3f" % (share_before, share_after))

Deployment

Model dapat dipakai dalam beberapa bentuk:

Bentuk Cocok untuk
Skrip/notebook terjadwal (batch) Prediksi berkala untuk banyak data
Layanan web (API) Prediksi sesuai permintaan
Aplikasi interaktif sederhana Demo dan prototipe
flowchart LR
    A[Latih pipeline] --> B[Simpan model + metadata]
    B --> C[Layanan prediksi]
    C --> D[Monitoring data dan keluaran]
    D -->|pergeseran| A

Contoh berikut hanya ilustrasi kerangka API dengan FastAPI; tidak dijalankan atau diuji di materi ini dan membutuhkan pustaka tambahan (fastapi, uvicorn):

# Ilustrasi saja (tidak diuji di materi ini)
import joblib
import pandas as pd
from fastapi import FastAPI

app = FastAPI()
model = joblib.load("breast_cancer_model.joblib")

@app.post("/predict")
def predict(features: dict):
    row = pd.DataFrame([features])                 # kolom harus sama dengan data latih
    proba_benign = float(model.predict_proba(row)[0, 1])
    return {"proba_benign": proba_benign}

Pada penggunaan nyata tambahkan validasi masukan, pencatatan (logging), versi model, dan keamanan akses.

Monitoring dan pemeliharaan

  • Pergeseran data: distribusi fitur berubah dari data latih.
  • Concept drift: hubungan fitur dengan label berubah; hanya terdeteksi bila label baru tersedia.
  • Pantau metrik performa begitu label sebenarnya diketahui, simpan versi model dan data latihnya, dan tentukan kapan melatih ulang.

Kesalahan umum

Hindari

  • Menyimpan model tanpa praproses sehingga data baru tidak diproses sama.
  • Memuat berkas model dari sumber tidak tepercaya.
  • Tidak mencatat versi pustaka dan fitur.
  • Menganggap model "selesai" setelah deployment tanpa pemantauan.

Latihan

  1. Simpan model ke folder pilihan Anda, tutup Python, lalu muat dan prediksi dari proses baru.
  2. Geser mean texture sebesar 5% dan periksa p-value KS. Kapan pergeseran mulai terdeteksi?
  3. Tambahkan pemeriksaan bahwa kolom data baru sama dengan meta["features"] sebelum memprediksi.

Ringkasan

Simpan pipeline utuh dengan metadata, uji muat ulang, jaga keamanan berkas model, dan pantau masukan serta keluaran setelah deployment untuk mendeteksi pergeseran.

Berikutnya: Proyek Klasifikasi End-to-End.