Belajar Machine Learning - Deployment & Serving Model

#Pendahuluan

Setelah di episode 17 kita membangun pipeline MLOps, saatnya tiba bagi model untuk keluar dari notebook dan melayani pengguna: di balik API, di dalam aplikasi mobile, atau dalam batch job malam hari. Episode ini menjawab pertanyaan paling praktis: bagaimana men-deploy model agar cepat, aman, dan bisa dipantau?

Mengapa deployment dipisahkan dari training? Karena keduanya punya kebutuhan berbeda. Training butuh fleksibilitas dan eksplorasi; serving butuh stabilitas, kecepatan, dan keamanan. Model di produksi harus merespons dalam milidetik, tidak boleh bocor ke penyerang (episode 16), dan harus terpantau terus-menerus.

#Export Model

Langkah pertama: simpan model terlatih ke file yang bisa dimuat kembali kapan saja.

#joblib (cara paling sederhana)

import joblib
 
joblib.dump(pipeline, "model/churn_pipeline.joblib")
loaded = joblib.load("model/churn_pipeline.joblib")
 
print(loaded.predict(X_new))

Kelebihan joblib: simpel, memuat seluruh Pipeline (preprocessing + model) sekaligus. Kelemahan: hanya bisa dimuat oleh Python versi dan library yang serupa — versi scikit-learn tidak sama bisa gagal.

#ONNX (portable dan cepat)

ONNX (Open Neural Network Exchange) adalah format model standar yang bisa dijalankan di banyak platform dan bahasa (Python, C++, Java, mobile). Untuk serving produksi, ONNX biasanya lebih cepat dan ringan:

from skl2onnx import convert_sklearn
from skl2onnx.common.data_types import FloatTensorType
 
initial_types = [("float_input", FloatTensorType([None, X.shape[1]]))]
onnx_model = convert_sklearn(pipeline, initial_types=initial_types)
 
with open("model/churn.onnx", "wb") as f:
    f.write(onnx_model.SerializeToString())

Untuk tree-based (XGBoost, LightGBM), ekspor ONNX sering menaikkan kecepatan inference signifikan — investasi yang layak saat trafik naik.

#REST API dengan FastAPI

FastAPI adalah pilihan standar untuk serving model di 2026: cepat, type-safe, dan dokumentasi otomatis.

from fastapi import FastAPI
from pydantic import BaseModel
import joblib
 
app = FastAPI(title="Churn Predictor")
model = joblib.load("model/churn_pipeline.joblib")
 
class Input(BaseModel):
    umur: float
    pendapatan: float
    kota: str
 
class Output(BaseModel):
    churn_probability: float
    churn: bool
 
@app.post("/predict", response_model=Output)
def predict(data: Input):
    import pandas as pd
    df = pd.DataFrame([data.model_dump()])
    proba = model.predict_proba(df)[0, 1]
    return Output(churn_probability=round(proba, 4), churn=proba > 0.5)

Jalankan dan uji:

uvicorn app:app --host 0.0.0.0 --port 8000
curl -s -X POST http://localhost:8000/predict \
  -H "Content-Type: application/json" \
  -d '{"umur": 34, "pendapatan": 5.2, "kota": "jakarta"}'

FastAPI memberi dokumentasi interaktif otomatis di http://localhost:8000/docs — tempat menguji endpoint tanpa menulis curl manual.

#Containerization dengan Docker

Supaya server model jalan konsisten di mesin mana pun — laptop, CI, server produksi — bungkus dengan Docker:

FROM python:3.12-slim
 
WORKDIR /app
 
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
 
COPY app.py model/ /app/
 
EXPOSE 8000
CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

docker build -t churn-api .
docker run -p 8000:8000 churn-api

Image Docker adalah artefak deploy yang lengkap — versi library, kode, dan model terkurung di dalamnya. Ini memecahkan masalah "berjalan di mesin saya, tapi tidak di server" dan menjadi dasar CD di episode 17.

#Batch Inference

Tidak semua prediksi harus real-time. Untuk skor jutaan customer setiap malam, batch inference jauh lebih efisien:

model = joblib.load("model/churn_pipeline.joblib")
 
df = pd.read_csv("customers_today.csv")
proba = model.predict_proba(df)[:, 1]
 
df["churn_proba"] = proba
df.to_parquet("scores/churn_today.parquet")

Perbedaan mendasar:

#Monitoring Produksi

Model di produksi itu seperti mesin pabrik — harus dipantau, atau rusaknya baru terasa saat sudah terlambat.

#Data Drift dan Model Degradation

Ingat PSI dari episode 17. Di produksi, kita memantau secara berkala:

def monitor_production(sample):
    drift_score = psi(
        np.histogram(X_train[:, 0])[0],
        np.histogram(sample[:, 0])[0],
    )
 
    if drift_score > 0.25:
        alert("Drift signifikan terdeteksi di fitur 0!")
    return drift_score

Gejala degradasi yang harus dipantau:

#Retraining Policy

Kebijakan retraining yang jelas menjawab pertanyaan "kapan model diganti?":

Aturan yang perlu ditetapkan sejak awal:

• Ambang drift yang memicu retraining (misal PSI > 0.25).
• Metrik & threshold untuk model baru harus menang (misal ROC-AUC > model lama).
• Rollback plan: model baru buruk di produksi → kembali ke versi lama dari registry.

#Common Pitfalls

• Serving pipeline tidak sama dengan training — deploy seluruh Pipeline, bukan model mentah, agar preprocessing identik.
• Lupa versioning model di API — deploy harus bisa di-rollback ke versi tertentu.
• Tanpa load test — model jalan di laptop, tumbang di produksi.
• Monitoring hanya infra (CPU/RAM), bukan data — drift terlewat.
• Retraining manual tanpa trigger — cepat usang, kualitas tidak terukur.

#Penutup

Pada episode 18 ini, kalian telah membawa model ke produksi.

Inti yang harus dibawa pulang:

• Export model dengan joblib (simplen) atau ONNX (portable & cepat).
• Serving realtime dengan FastAPI + validasi input Pydantic.
• Docker membuat deploy konsisten; batch inference untuk prediksi massal.
• Monitoring data drift, degradasi model, dan latency secara berkala.
• Tetapkan retraining policy dengan ambang dan rollback plan.

Di episode 19 selanjutnya kita memperdalam model yang sudah kita pakai: gradient boosting lanjutan & XGBoost deep dive — hyperparameter penting, kontrol overfitting, GPU acceleration, benchmark tabular, dan interpretasi dengan SHAP. Sampai jumpa di episode 19!