ZenML: Bikin Pipeline ML dan LLM yang Portable dan Siap Produksi

Halo temen-temen, ketemu lagi sama aku, Ruby Abdullah. Kali ini aku mau ngajak kalian ngobrol soal salah satu tools yang menurutku wajib banget dikuasai kalau kalian serius pengen kerja di dunia machine learning atau LLM secara profesional, bukan cuma main-main di notebook doang. Tools itu namanya ZenML.

Jujur ya, dulu waktu aku pertama kali belajar ML, semua proses itu aku tumpuk di satu file notebook. Load data di cell atas, training di tengah, evaluasi di bawah, terus kalau mau deploy tinggal copy-paste sana-sini. Kelihatannya cepet, tapi begitu proyeknya makin gede dan mulai masuk ke produksi, semua jadi berantakan. Susah di-reproduce, susah dilacak, dan kalau ada yang error kita bingung ngulang dari mana. Nah, di sinilah ZenML masuk buat nyelametin hidup kita.

Di artikel ini aku bakal jelasin ZenML dari nol sampai kalian bisa bikin pipeline end-to-end sendiri. Kita bahas instalasi, konsep dasar kayak @step dan @pipeline, konsep stack yang jadi jantungnya ZenML, artifacts dan caching, integrasi ke tools lain kayak MLflow, sampai gimana caranya deploy. Siap? Yuk kita mulai.

Introduction

Sebelum masuk ke kodingan, aku pengen kalian paham dulu ZenML itu sebenernya apa dan kenapa dia penting.

ZenML itu framework MLOps open-source yang tugasnya bikin workflow machine learning kalian jadi terstruktur, bisa diulang (reproducible), dan gampang dipindahin dari laptop ke cloud tanpa harus nulis ulang kode. Jadi bayangin gini, temen-temen. Kalian punya kode training model. Di laptop kalian jalan lokal. Terus bos kalian bilang, "Eh, ini pindahin ke cloud dong, pakai orchestrator Kubernetes, terus tracking-nya pakai MLflow." Kalau tanpa ZenML, kalian harus ngoprek banyak banget kode. Tapi dengan ZenML, kalian cukup ganti konfigurasi stack, dan kode inti kalian tetap sama persis. Keren kan?

Konsep utama ZenML itu ada dua: pipeline dan step. Step itu satu unit kerja, misalnya "load data" atau "train model". Pipeline itu rangkaian step-step yang saling terhubung. Nah, ZenML memisahkan antara logika ML (yang kalian tulis) dengan infrastruktur (tempat kode itu jalan). Pemisahan ini yang bikin kode kalian jadi portable banget.

Kenapa ini penting buat karier kalian? Karena di industri, yang dicari itu bukan cuma orang yang bisa bikin model akurat di notebook. Yang dicari itu orang yang bisa bawa model itu ke produksi, bisa maintain, bisa lacak eksperimen, dan bisa kolaborasi sama tim. ZenML ngajarin kalian mindset MLOps yang bener sejak awal. Jadi menurutku, belajar ZenML itu investasi yang bagus banget buat masa depan kalian.

Satu hal lagi yang aku suka dari ZenML: dia nggak maksa kalian pakai tools tertentu. Kalian mau pakai scikit-learn, PyTorch, TensorFlow, atau bahkan framework LLM kayak LangChain, semua bisa. ZenML itu sifatnya kayak lem yang nyatuin semua komponen kalian jadi satu alur yang rapi.

Instalasi

Oke, sekarang kita masuk ke bagian praktik. Instalasi ZenML itu gampang banget, cukup satu baris perintah aja.

pip install zenml

Kalau kalian mau versi yang lengkap dengan dashboard visual (dan aku saranin banget pakai ini), install versi server-nya:

pip install "zenml[server]"

Aku selalu saranin temen-temen buat pakai virtual environment biar nggak berantakan sama dependency proyek lain. Ini cara aku biasanya setup:

python -m venv zenml-env
source zenml-env/bin/activate  # kalau di Windows: zenml-env\Scripts\activate
pip install "zenml[server]" scikit-learn

Setelah kelar install, kita perlu inisialisasi ZenML di dalam folder proyek kita. Ini penting karena ZenML bakal bikin folder tersembunyi .zen yang nyimpen semua konfigurasi dan metadata.

zenml init

Kalian bakal lihat pesan sukses yang bilang repository ZenML udah dibuat. Nah, buat ngecek apakah semuanya udah bener, coba jalanin perintah ini:

zenml status

Kalau kalian pengen lihat dashboard visualnya yang cakep itu, jalanin:

zenml login --local

Perintah ini bakal nge-launch server lokal dan buka browser ke dashboard ZenML. Di sini kalian bisa lihat semua pipeline yang udah kalian jalanin, step-step-nya, artifact yang dihasilkan, dan banyak lagi. Aku pribadi suka banget sama dashboard ini karena bikin debugging jadi jauh lebih gampang. Kita bisa lihat secara visual step mana yang gagal, berapa lama tiap step jalan, dan data apa yang mengalir di antara step.

Oh iya, satu tips dari aku: kalau kalian pakai versi ZenML yang agak lama, perintahnya mungkin zenml up bukan zenml login --local. Jadi kalau ada error, cek dulu versi ZenML kalian dengan zenml version. Aku nulis artikel ini berdasarkan versi ZenML yang cukup baru ya temen-temen.

Basic Usage

Sekarang bagian paling seru, kita mulai nulis kode. Aku bakal jelasin dua decorator paling penting di ZenML: @step dan @pipeline.

Bikin Step Pertama

Step itu ibarat fungsi biasa di Python, tapi kita kasih decorator @step. Decorator ini yang bikin ZenML tahu bahwa fungsi ini adalah satu unit kerja yang bisa dilacak, di-cache, dan dijalanin di infrastruktur tertentu. Coba lihat contoh sederhana ini:

from zenml import step

@step
def loaddata() -> dict:

    """Load data sederhana buat contoh."""
    data = {
        "features": [[1, 2], [3, 4], [5, 6], [7, 8]],
        "labels": [0, 0, 1, 1],
    }
    return data

from zenml import pipeline

@pipeline
def simplepipeline():
    data = loaddata()

    return data

if name == "main":
    simplepipeline()

Simpan semua kode di atas ke satu file, misalnya run.py, terus jalanin dengan python run.py. ZenML bakal eksekusi pipeline kalian, nyimpen semua artifact, dan nyatet metadata-nya. Kalau kalian buka dashboard, kalian bakal lihat pipeline ini muncul di sana lengkap dengan visualisasi alurnya.

Ngerti Alur Data Antar Step

Yang bikin ZenML powerful itu cara dia ngatur aliran data antar step. Ketika kalian nulis data = loaddata() terus data itu dipakai di step lain, ZenML otomatis paham bahwa ada dependency antara dua step itu. Dia bakal jalanin dalam urutan yang bener dan otomatis passing artifact dari satu step ke step berikutnya. Kalian nggak perlu ngurus manual gimana caranya data pindah, ZenML yang urus semua di belakang layar.

zenml stack describe

zenml stack list

from zenml import step

@step(enablecache=False)
def fetchrealtimedata() -> dict:
    """Step ini selalu jalan ulang, nggak pakai cache."""
    # ambil data terbaru dari API
    return {"data": "selalu fresh"}

Kalian juga bisa matiin caching di level pipeline dengan @pipeline(enablecache=False). Fleksibel banget kan.

zenml integration install mlflow -y

zenml experiment-tracker register mlflowtracker --flavor=mlflow
zenml stack register mlflowstack -o default -a default -e mlflowtracker --set

Perintah di atas bikin stack baru bernama mlflowstack yang pakai orchestrator default, artifact store default, dan experiment tracker MLflow. Flag --set langsung ngeaktifin stack ini. Nah setelah itu, di dalam step training kalian tinggal aktifin experiment tracker-nya:

from zenml import step
from zenml.client import Client

experimenttracker = Client().activestack.experimenttracker

@step(experimenttracker=experimenttracker.name)
def trainwithtracking(data: dict) -> float:
    import mlflow
    mlflow.sklearn.autolog()
    # kode training kalian di sini
    accuracy = 0.95
    mlflow.logmetric("accuracy", accuracy)

    return accuracy

from zenml import step, pipeline
from typing import Tuple
from typingextensions import Annotated
import pandas as pd
from sklearn.datasets import loadiris

from sklearn.modelselection import traintestsplit
from sklearn.ensemble import RandomForestClassifier
from sklearn.base import ClassifierMixin

@step
def loaddata() -> Tuple[

    Annotated[pd.DataFrame, "Xtrain"],
    Annotated[pd.DataFrame, "Xtest"],

    Annotated[pd.Series, "ytrain"],
    Annotated[pd.Series, "ytest"],

]:
    """Load dataset Iris dan split jadi train dan test."""
    iris = loadiris(asframe=True)

    X = iris.data
    y = iris.target
    Xtrain, Xtest, ytrain, ytest = traintestsplit(

        X, y, testsize=0.2, randomstate=42

    )
    return Xtrain, Xtest, ytrain, ytest


@step
def trainmodel(
    Xtrain: pd.DataFrame, ytrain: pd.Series
) -> ClassifierMixin:
    """Latih model Random Forest."""
    model = RandomForestClassifier(nestimators=100, randomstate=42)
    model.fit(Xtrain, ytrain)
    return model

@step
def evaluatemodel(

    model: ClassifierMixin, Xtest: pd.DataFrame, ytest: pd.Series

) -> float:
    """Evaluasi akurasi model di data test."""
    accuracy = model.score(Xtest, ytest)

    print(f"Akurasi model: {accuracy:.4f}")
    return accuracy

@pipeline
def trainingpipeline():
    Xtrain, Xtest, ytrain, ytest = loaddata()

    model = trainmodel(Xtrain, ytrain)
    accuracy = evaluatemodel(model, Xtest, ytest)

    return accuracy

if name == "main":
    trainingpipeline()

Coba perhatiin baik-baik kode di atas. Ada tiga step: loaddata, trainmodel, dan evaluatemodel. Di loaddata aku pakai Annotated buat kasih nama ke tiap output artifact, jadi di dashboard nanti kelihatan jelas mana Xtrain, mana ytest, dan seterusnya. Ini best practice yang bikin pipeline kalian jauh lebih mudah dibaca.

Di pipeline, aku cuma rangkai ketiga step itu. ZenML otomatis paham bahwa trainmodel butuh output dari loaddata, dan evaluatemodel butuh output dari trainmodel dan loaddata. Dia atur urutannya sendiri. Jalanin python run.py, terus buka dashboard, dan kalian bakal lihat DAG (Directed Acyclic Graph) yang cakep nunjukin alur pipeline kalian.

Coba jalanin dua kali. Di run kedua, kalau kalian nggak ngubah apa-apa, perhatiin ZenML bakal bilang step-nya "cached". Itu tadi yang kita bahas soal caching. Sekarang coba ubah nestimators di trainmodel jadi 50, terus jalanin lagi. Kali ini step loaddata tetap cached (karena nggak berubah), tapi trainmodel dan evaluatemodel bakal jalan ulang. Efisien banget kan.

Deploy dan Serving

Setelah model kalian jadi, langkah berikutnya adalah deploy biar bisa dipakai buat prediksi. ZenML punya beberapa cara buat ini. Yang paling umum adalah pakai integrasi model deployer kayak MLflow, Seldon, atau BentoML.

Konsepnya, kalian tambahin step deployment ke pipeline kalian. Step ini bakal ambil model yang udah dilatih terus deploy jadi sebuah endpoint API yang bisa nerima request prediksi. Contoh sederhana pakai MLflow deployer, kalian install dulu integrasinya:

zenml integration install mlflow -y
zenml model-deployer register mlflowdeployer --flavor=mlflow

Conclusion

Oke temen-temen, kita udah sampai di penghujung artikel. Kita udah bahas banyak banget hal soal ZenML. Kita mulai dari instalasi dan inisialisasi, terus masuk ke konsep dasar @step dan @pipeline. Lanjut ke konsep yang lebih dalam kayak stack dengan tiga komponen utamanya (orchestrator, artifact store, experiment tracker), sistem artifact dan caching yang super efisien, integrasi ke MLflow dan cloud, sampai contoh pipeline end-to-end lengkap dari load data, train, sampai evaluate. Kita juga udah ngebahas gimana caranya deploy model dan sekumpulan best practices dari pengalamanku.

Kalau aku boleh rangkum satu pelajaran paling penting dari ZenML, itu adalah pisahin logika ML dari infrastruktur. Ini prinsip yang bikin kode kalian portable, reproducible, dan siap produksi. Dengan ZenML, kalian bisa fokus ke bagian yang bener-bener penting, yaitu bikin model yang bagus, tanpa harus pusing mikirin gimana caranya kode itu jalan di infrastruktur yang berbeda-beda.

Buat kalian yang serius pengen berkarier di dunia machine learning dan LLM, aku sangat menyarankan buat mendalami ZenML. Skill MLOps kayak gini yang bakal ngebedain kalian dari kebanyakan orang yang cuma bisa main di notebook. Mulai dari proyek kecil, coba bikin pipeline sederhana kayak yang aku contohin tadi, terus pelan-pelan naikin kompleksitasnya. Nanti kalian bakal ngerasain sendiri betapa nyamannya kerja dengan workflow yang terstruktur.

Sekian dari aku. Semoga artikel ini bermanfaat dan bikin kalian makin semangat belajar. Kalau ada pertanyaan, jangan ragu buat cari aku ya. Selamat ngoding, dan sampai ketemu di artikel berikutnya. Semangat terus temen-temen.