Belajar Data Scientist - Production ML Integration

#Pendahuluan

Setelah di episode 23 kita menangani skala besar, pada episode ini kita menutup celah paling sering diabaikan: membawa model ke produksi. Model terbaik di dunia bernilai nol jika tidak berjalan di dunia nyata — dan transisi notebook → produksi adalah tempat banyak proyek gagal.

Mengapa episode ini penting bagi data scientist? Karena data scientist tidak harus jadi ML engineer, tetapi harus tahu cara berkolaborasi dengan mereka — apa yang harus diserahkan, dalam format apa, dan dengan dokumentasi apa. Model yang dikirim tanpa pipeline yang jelas, tanpa tracking, dan tanpa monitoring adalah sumber konflik dan kegagalan yang tak perlu. Episode ini membangun bahasa bersama itu.

#Data Scientist vs ML Engineer

Dua peran yang bekerja sama (bukan bersaing):

Pembagian kerja yang sehat: data scientist menyiapkan model yang reproducible (episode 12) + documentation (episode 20); ML engineer mengurus serving, autoscaling, dan pipeline. Ketika keduanya berkomunikasi lewat artefak standar (registry, model card), kolaborasi menjadi mulus.

#Pola Deployment

Tiga pola utama menghadirkan model ke pengguna:

#1. Batch Scoring

Pola paling umum untuk model seperti churn — skor dihitung berkala:

import pandas as pd
import mlflow
 
model = mlflow.sklearn.load_model("models:/churn-prod/Production")
 
customers = pd.read_sql("SELECT * FROM customers_active", engine)
customers["churn_score"] = model.predict_proba(customers[X_COLS])[:, 1]
 
customers.to_sql("churn_scores", engine, if_exists="replace")
print("skor dihitung untuk:", len(customers), "customer")

Model dimuat dari registry (bukan file notebook), skor dihitung, dan hasil ditulis kembali ke database — pola yang di episode 8 kita persiapkan sejak dari SQL.

#2. Online API dengan FastAPI

Untuk prediksi real-time (misal skor saat checkout):

from fastapi import FastAPI
import mlflow
import numpy as np
 
app = FastAPI()
model = mlflow.sklearn.load_model("models:/churn-prod/Production")
 
@app.post("/predict")
def predict(features: dict):
    X = np.array([[features["tenure"],
                   features["monthly_charges"],
                   features["total_charges"]]])
    proba = model.predict_proba(X)[0, 1]
    return {"churn_probability": float(proba)}

Endpoint kecil ini — dengan validasi input, logging, dan autentikasi yang ditambahkan ML engineer — menjadi layanan yang dipakai aplikasi lain. Satu hal yang wajib: preprocessing harus identik dengan training (pipeline episode 10), atau angka akan meleset diam-diam.

#Monitoring Model

Setelah deploy, model tidak selesai — ia mulai memburuk seiring data berubah. Dua jenis drift yang wajib dipantau:

import numpy as np
 
def drift_report(feature, train_values, live_values):
    train_mean = np.mean(train_values)
    live_mean = np.mean(live_values)
    pct_change = (live_mean - train_mean) / train_mean * 100
    return f"{feature}: training={train_mean:.2f}, " \
           f"live={live_mean:.2f} ({pct_change:+.1f}%)"
 
print(drift_report("tenure", train["tenure"], live["tenure"]))

Perubahan besar pada mean fitur = sinyal untuk meninjau model. Di produksi, monitoring dijaga ML engineer (misal Evidently, Prometheus); data scientist bertugas menentukan apa yang dipantau dan threshold-nya — memakai metrik dan pemahaman domain yang sudah kalian bangun.

#Proses Rilis Model

Rilis model yang aman mengikuti alur — ini inti praktik "model release":

1. Kandidat model diuji (episode 11): metrik + fairness
2. Model card diperbarui (episode 20)
3. Model didaftarkan ke registry: Staging (episode 12)
4. Shadow / canary: uji di sebagian trafik
5. Jika aman → Production; jika tidak → rollback
6. Monitoring aktif: metrik + drift
7. Retraining terjadwal sesuai kebutuhan

Kata kunci di 2026: shadow/canary release — model baru berjalan paralel dengan yang lama, membandingkan output nyata, sebelum menggantikannya. Ini meminimalkan risiko tanpa berhenti dari deployment.

#Kesalahan Umum

#Penutup

Inti yang harus dibawa pulang:

• Data scientist & ML engineer berkolaborasi lewat artefak standar: registry, pipeline, model card.
• Pola deployment: batch (berkala), online API (real-time), embedded (latensi rendah).
• Satu pipeline untuk training & serving — sumber kegagalan paling umum dihindari.
• Monitoring: data drift & concept drift dengan threshold yang jelas.
• Rilis aman: Staging → shadow → Production → monitoring → retraining.

Di episode 25 selanjutnya kita akan membahas advanced modeling & ensemble — gradient boosting dengan XGBoost/LightGBM, teknik ensemble, dan hyperparameter tuning untuk membangun model kompetitif. Sampai jumpa di episode 25!