Tutorial MLflow: Platform Open-Source untuk MLOps End-to-End

# Tutorial MLflow: Platform Open-Source untuk MLOps End-to-End MLflow adalah platform open-source yang dikembangkan oleh Databricks untuk mengelola seluruh siklus hidup machine learning. Dari experim...

By Ruby Abdullah · · tutorial
MLflowMLOpsExperiment TrackingModel RegistryMachine Learning

Tutorial MLflow: Platform Open-Source untuk MLOps End-to-End

MLflow adalah platform open-source yang dikembangkan oleh Databricks untuk mengelola seluruh siklus hidup machine learning. Dari experiment tracking, packaging model, hingga deployment ke production, MLflow menyediakan alat yang terintegrasi dan mudah digunakan. Dengan lebih dari 18.000 bintang di GitHub dan adopsi luas di industri, MLflow telah menjadi standar de facto dalam ekosistem MLOps.

Dalam tutorial ini, kita akan mempelajari cara menggunakan MLflow secara menyeluruh, mulai dari instalasi, experiment tracking, model registry, hingga serving model ke production.

Mengapa MLflow?

Sebelum masuk ke implementasi, penting untuk memahami masalah yang diselesaikan MLflow:

  • Reproducibility: Tanpa tracking yang baik, sulit mereproduksi hasil eksperimen sebelumnya. MLflow mencatat semua parameter, metrik, dan artefak secara otomatis.
  • Collaboration: Tim data science sering bekerja paralel. MLflow menyediakan server terpusat untuk berbagi eksperimen dan model.
  • Deployment: Transisi dari notebook ke production sering menjadi bottleneck. MLflow menyederhanakan proses ini dengan format model standar dan built-in serving.
  • Governance: Model Registry MLflow memungkinkan versioning, staging, dan approval workflow untuk model production.

Instalasi dan Setup

Instalasi Dasar

pip install mlflow

Untuk fitur tambahan, instal dengan extras:

pip install mlflow[extras]

Jika Anda menggunakan framework tertentu, instal juga dependensi yang sesuai:

pip install mlflow scikit-learn xgboost lightgbm tensorflow torch

Menjalankan MLflow UI

MLflow menyediakan UI web untuk melihat eksperimen dan model. Jalankan dengan:

mlflow ui --port 5000

Buka browser dan akses http://localhost:5000. Anda akan melihat dashboard kosong yang siap menerima data eksperimen.

Setup Tracking Server (Opsional)

Untuk tim, sebaiknya gunakan tracking server terpusat:

mlflow server \

--backend-store-uri sqlite:///mlflow.db \

--default-artifact-root ./mlflow-artifacts \

--host 0.0.0.0 \

--port 5000

Dengan PostgreSQL untuk production:

mlflow server \

--backend-store-uri postgresql://user:password@localhost:5432/mlflow \

--default-artifact-root s3://my-mlflow-bucket/artifacts \

--host 0.0.0.0 \

--port 5000

Experiment Tracking

Experiment tracking adalah fitur inti MLflow. Setiap kali Anda melatih model, MLflow mencatat parameter, metrik, dan artefak dalam sebuah "run".

Tracking Dasar

import mlflow

import mlflow.sklearn

from sklearn.ensemble import RandomForestClassifier

from sklearn.datasets import loadiris

from sklearn.modelselection import traintestsplit

from sklearn.metrics import accuracyscore, f1score, precisionscore

X, y = loadiris(returnXy=True)

Xtrain, Xtest, ytrain, ytest = traintestsplit(X, y, testsize=0.2, randomstate=42)

mlflow.setexperiment("iris-classification")

with mlflow.startrun(runname="random-forest-baseline"):

nestimators = 100

maxdepth = 5

minsamplessplit = 2

mlflow.logparam("nestimators", nestimators)

mlflow.logparam("maxdepth", maxdepth)

mlflow.logparam("minsamplessplit", minsamplessplit)

model = RandomForestClassifier(

nestimators=nestimators,

maxdepth=maxdepth,

minsamplessplit=minsamplessplit,

randomstate=42

)

model.fit(Xtrain, ytrain)

ypred = model.predict(Xtest)

accuracy = accuracyscore(ytest, ypred)

f1 = f1score(ytest, ypred, average="weighted")

precision = precisionscore(ytest, ypred, average="weighted")

mlflow.logmetric("accuracy", accuracy)

mlflow.logmetric("f1score", f1)

mlflow.logmetric("precision", precision)

mlflow.sklearn.logmodel(model, "model")

print(f"Accuracy: {accuracy:.4f}")

print(f"F1 Score: {f1:.4f}")

Autologging

MLflow mendukung autologging untuk framework populer, sehingga Anda tidak perlu mencatat parameter dan metrik secara manual:

import mlflow

from sklearn.ensemble import GradientBoostingClassifier

from sklearn.datasets import loadiris

from sklearn.modelselection import traintestsplit

mlflow.sklearn.autolog()

X, y = loadiris(returnXy=True)

Xtrain, Xtest, ytrain, ytest = traintestsplit(X, y, testsize=0.2, randomstate=42)

mlflow.setexperiment("iris-autolog")

with mlflow.startrun():

model = GradientBoostingClassifier(nestimators=200, maxdepth=3)

model.fit(Xtrain, ytrain)

Autologging tersedia untuk banyak framework:

mlflow.sklearn.autolog()

mlflow.tensorflow.autolog()

mlflow.pytorch.autolog()

mlflow.xgboost.autolog()

mlflow.lightgbm.autolog()

mlflow.spark.autolog()

Logging Artefak

Selain parameter dan metrik, Anda bisa menyimpan file artefak seperti plot, data, atau konfigurasi:

import mlflow

import matplotlib.pyplot as plt

import numpy as np

from sklearn.metrics import confusionmatrix, ConfusionMatrixDisplay

import json

with mlflow.startrun(runname="with-artifacts"):

model = RandomForestClassifier(nestimators=100)

model.fit(Xtrain, ytrain)

ypred = model.predict(Xtest)

cm = confusionmatrix(ytest, ypred)

disp = ConfusionMatrixDisplay(confusionmatrix=cm)

disp.plot()

plt.savefig("confusionmatrix.png")

plt.close()

mlflow.logartifact("confusionmatrix.png")

featureimportance = dict(zip(

[f"feature{i}" for i in range(Xtrain.shape[1])],

model.featureimportances.tolist()

))

with open("featureimportance.json", "w") as f:

json.dump(featureimportance, f, indent=2)

mlflow.logartifact("featureimportance.json")

mlflow.logdict(

{"modeltype": "RandomForest", "framework": "scikit-learn"},

"modelconfig.json"

)

Nested Runs untuk Hyperparameter Tuning

import mlflow

from sklearn.ensemble import RandomForestClassifier

from sklearn.modelselection import ParameterGrid

paramgrid = {

"nestimators": [50, 100, 200],

"maxdepth": [3, 5, 10],

"minsamplessplit": [2, 5]

}

mlflow.setexperiment("iris-hyperparameter-tuning")

with mlflow.startrun(runname="grid-search"):

bestaccuracy = 0

bestparams = None

for params in ParameterGrid(paramgrid):

with mlflow.startrun(runname=f"rf-{params}", nested=True):

mlflow.logparams(params)

model = RandomForestClassifier(params, randomstate=42)

model.fit(Xtrain, ytrain)

accuracy = model.score(Xtest, ytest)

mlflow.logmetric("accuracy", accuracy)

if accuracy > bestaccuracy:

bestaccuracy = accuracy

bestparams = params

mlflow.logparams({f"best{k}": v for k, v in bestparams.items()})

mlflow.logmetric("bestaccuracy", bestaccuracy)

print(f"Best params: {bestparams}, Accuracy: {bestaccuracy:.4f}")

Model Registry

Model Registry adalah fitur MLflow untuk mengelola model di sepanjang lifecycle-nya. Anda bisa mendaftarkan model, memberi versi, dan mengelola transisi antar stage.

Mendaftarkan Model

import mlflow

import mlflow.sklearn

from sklearn.ensemble import RandomForestClassifier

mlflow.setexperiment("iris-registry")

with mlflow.startrun():

model = RandomForestClassifier(nestimators=100, maxdepth=5, randomstate=42)

model.fit(Xtrain, ytrain)

accuracy = model.score(Xtest, ytest)

mlflow.logmetric("accuracy", accuracy)

mlflow.sklearn.logmodel(

model,

"model",

registeredmodelname="iris-classifier"

)

Mengelola Model Versions

from mlflow.client import MlflowClient

client = MlflowClient()

client.setregisteredmodeltag(

"iris-classifier",

"task",

"classification"

)

client.setmodelversiontag(

"iris-classifier",

version="1",

key="validationstatus",

value="approved"

)

modelinfo = client.getregisteredmodel("iris-classifier")

print(f"Model: {modelinfo.name}")

print(f"Latest versions: {[v.version for v in modelinfo.latestversions]}")

Model Aliases

MLflow menggunakan aliases untuk menandai versi model tertentu (menggantikan sistem stages lama):

from mlflow.client import MlflowClient

client = MlflowClient()

client.setregisteredmodelalias("iris-classifier", "champion", 1)

championmodel = mlflow.pyfunc.loadmodel("models:/iris-classifier@champion")

client.setregisteredmodelalias("iris-classifier", "challenger", 2)

championuri = "models:/iris-classifier@champion"

challengeruri = "models:/iris-classifier@challenger"

Membandingkan Model Versions

from mlflow.client import MlflowClient

client = MlflowClient()

versions = client.searchmodelversions("name='iris-classifier'")

for v in versions:

run = client.getrun(v.runid)

accuracy = run.data.metrics.get("accuracy", "N/A")

print(f"Version {v.version}: accuracy={accuracy}, aliases={v.aliases}")

MLflow Models dan Flavors

MLflow Models menyediakan format standar untuk menyimpan model dari berbagai framework. Setiap framework memiliki "flavor" tersendiri.

Custom Model dengan PythonModel

import mlflow

import mlflow.pyfunc

import numpy as np

class PreprocessingModel(mlflow.pyfunc.PythonModel):

def init(self, scalerparams, model):

self.scalermean = scalerparams["mean"]

self.scalerstd = scalerparams["std"]

self.model = model

def predict(self, context, modelinput, params=None):

scaledinput = (modelinput - self.scalermean) / self.scalerstd

predictions = self.model.predict(scaledinput)

return predictions

from sklearn.preprocessing import StandardScaler

from sklearn.ensemble import RandomForestClassifier

scaler = StandardScaler()

Xtrainscaled = scaler.fittransform(Xtrain)

rfmodel = RandomForestClassifier(nestimators=100, randomstate=42)

rfmodel.fit(Xtrainscaled, ytrain)

custommodel = PreprocessingModel(

scalerparams={"mean": scaler.mean, "std": scaler.scale},

model=rfmodel

)

with mlflow.startrun():

mlflow.pyfunc.logmodel(

artifactpath="model",

pythonmodel=custommodel,

registeredmodelname="iris-preprocessed-classifier"

)

Model Signature

Model signature mendokumentasikan input dan output yang diharapkan:

import mlflow

from mlflow.models import infersignature

import pandas as pd

Xsample = pd.DataFrame(Xtrain[:5], columns=["sepallength", "sepalwidth", "petallength", "petalwidth"])

ysample = model.predict(Xsample)

signature = infersignature(Xsample, ysample)

with mlflow.startrun():

mlflow.sklearn.logmodel(

model,

"model",

signature=signature,

inputexample=Xsample.iloc[:2]

)

Model Serving

MLflow menyediakan beberapa cara untuk men-deploy model ke production.

Local Serving

mlflow models serve -m "models:/iris-classifier@champion" --port 8000 --no-conda

Test dengan curl:

curl -X POST http://localhost:8000/invocations \

-H "Content-Type: application/json" \

-d '{"dataframesplit": {"columns": ["sepallength", "sepalwidth", "petallength", "petalwidth"], "data": [[5.1, 3.5, 1.4, 0.2]]}}'

Batch Prediction

import mlflow

import pandas as pd

model = mlflow.pyfunc.loadmodel("models:/iris-classifier@champion")

batchdata = pd.DataFrame({

"sepallength": [5.1, 6.2, 4.8],

"sepalwidth": [3.5, 2.8, 3.0],

"petallength": [1.4, 4.8, 1.4],

"petalwidth": [0.2, 1.8, 0.3]

})

predictions = model.predict(batchdata)

print(f"Predictions: {predictions}")

Docker Deployment

MLflow bisa menghasilkan Docker image untuk model Anda:

mlflow models build-docker -m "models:/iris-classifier/1" -n "iris-classifier-docker"

docker run -p 8000:8080 iris-classifier-docker

Proyek MLflow (MLflow Projects)

MLflow Projects menyediakan format standar untuk packaging kode ML agar reproducible.

Struktur Project

Buat file MLproject di root directory:

name: iris-training

condaenv: conda.yaml

entrypoints:

main:

parameters:

nestimators: {type: int, default: 100}

maxdepth: {type: int, default: 5}

testsize: {type: float, default: 0.2}

command: "python train.py --n-estimators {nestimators} --max-depth {maxdepth} --test-size {testsize}"

evaluate:

parameters:

modeluri: {type: str}

command: "python evaluate.py --model-uri {modeluri}"

File train.py:

import argparse

import mlflow

import mlflow.sklearn

from sklearn.ensemble import RandomForestClassifier

from sklearn.datasets import loadiris

from sklearn.modelselection import traintestsplit

from sklearn.metrics import accuracyscore

def main():

parser = argparse.ArgumentParser()

parser.addargument("--n-estimators", type=int, default=100)

parser.addargument("--max-depth", type=int, default=5)

parser.addargument("--test-size", type=float, default=0.2)

args = parser.parseargs()

X, y = loadiris(returnXy=True)

Xtrain, Xtest, ytrain, ytest = traintestsplit(

X, y, testsize=args.testsize, randomstate=42

)

with mlflow.startrun():

model = RandomForestClassifier(

nestimators=args.nestimators,

maxdepth=args.maxdepth,

randomstate=42

)

model.fit(Xtrain, ytrain)

accuracy = accuracyscore(ytest, model.predict(Xtest))

mlflow.logmetric("accuracy", accuracy)

mlflow.sklearn.logmodel(model, "model")

print(f"Accuracy: {accuracy:.4f}")

if name == "main":

main()

Menjalankan Project

mlflow run . -P nestimators=200 -P maxdepth=10

mlflow run https://github.com/user/ml-project -P nestimators=200

MLflow dengan Deep Learning

PyTorch Integration

import mlflow

import mlflow.pytorch

import torch

import torch.nn as nn

from torch.utils.data import DataLoader, TensorDataset

class IrisNet(nn.Module):

def init(self, hiddensize=64):

super().init()

self.net = nn.Sequential(

nn.Linear(4, hiddensize),

nn.ReLU(),

nn.Dropout(0.2),

nn.Linear(hiddensize, 32),

nn.ReLU(),

nn.Linear(32, 3)

)

def forward(self, x):

return self.net(x)

mlflow.pytorch.autolog()

mlflow.setexperiment("iris-pytorch")

with mlflow.startrun():

Xtensor = torch.FloatTensor(Xtrain)

ytensor = torch.LongTensor(ytrain)

dataset = TensorDataset(Xtensor, ytensor)

dataloader = DataLoader(dataset, batchsize=16, shuffle=True)

model = IrisNet(hiddensize=64)

criterion = nn.CrossEntropyLoss()

optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

for epoch in range(50):

model.train()

totalloss = 0

for batchX, batchy in dataloader:

optimizer.zerograd()

outputs = model(batchX)

loss = criterion(outputs, batchy)

loss.backward()

optimizer.step()

totalloss += loss.item()

avgloss = totalloss / len(dataloader)

mlflow.logmetric("trainloss", avgloss, step=epoch)

model.eval()

with torch.nograd():

Xtesttensor = torch.FloatTensor(Xtest)

outputs = model(Xtesttensor)

, predicted = torch.max(outputs, 1)

accuracy = (predicted.numpy() == ytest).mean()

mlflow.logmetric("testaccuracy", accuracy)

mlflow.pytorch.logmodel(model, "model")

TensorFlow/Keras Integration

import mlflow

import mlflow.tensorflow

import tensorflow as tf

mlflow.tensorflow.autolog()

mlflow.setexperiment("iris-tensorflow")

with mlflow.startrun():

model = tf.keras.Sequential([

tf.keras.layers.Dense(64, activation="relu", inputshape=(4,)),

tf.keras.layers.Dropout(0.2),

tf.keras.layers.Dense(32, activation="relu"),

tf.keras.layers.Dense(3, activation="softmax")

])

model.compile(

optimizer="adam",

loss="sparsecategoricalcrossentropy",

metrics=["accuracy"]

)

model.fit(

Xtrain, ytrain,

epochs=50,

batchsize=16,

validationsplit=0.2,

verbose=0

)

loss, accuracy = model.evaluate(Xtest, ytest, verbose=0)

print(f"Test Accuracy: {accuracy:.4f}")

MLflow Evaluate

MLflow Evaluate menyediakan evaluasi otomatis untuk model ML dan LLM:

import mlflow

import pandas as pd

from sklearn.ensemble import RandomForestClassifier

mlflow.setexperiment("iris-evaluate")

with mlflow.startrun():

model = RandomForestClassifier(nestimators=100, randomstate=42)

model.fit(Xtrain, ytrain)

mlflow.sklearn.logmodel(model, "model")

modeluri = mlflow.getartifacturi("model")

evaldata = pd.DataFrame(Xtest, columns=["sepallength", "sepalwidth", "petallength", "petalwidth"])

evaldata["label"] = ytest

result = mlflow.evaluate(

model=modeluri,

data=evaldata,

targets="label",

modeltype="classifier",

evaluators=["default"]

)

print(f"Metrics: {result.metrics}")

Best Practices

1. Organisasi Eksperimen

Gunakan naming convention yang konsisten:

mlflow.setexperiment("project-name/task/sub-task")

mlflow.setexperiment("fraud-detection/training/v2")

2. Tagging untuk Pencarian

with mlflow.startrun():

mlflow.settag("team", "ml-platform")

mlflow.settag("dataversion", "2026-01-15")

mlflow.settag("environment", "staging")

mlflow.settag("commithash", "abc123")

3. Environment Management

Selalu log environment untuk reproducibility:

import mlflow

import sys

with mlflow.startrun():

mlflow.logparam("pythonversion", sys.version)

mlflow.logartifact("requirements.txt")

4. Gunakan Context Manager

Selalu gunakan context manager with mlflow.startrun() agar run otomatis di-close meskipun terjadi error:

with mlflow.startrun() as run:

try:

model.fit(Xtrain, ytrain)

mlflow.logmetric("accuracy", accuracy)

except Exception as e:

mlflow.settag("error", str(e))

raise

5. Model Signature dan Input Example

Selalu sertakan signature dan input example saat logging model:

from mlflow.models import infersignature

signature = infersignature(Xtrain, model.predict(Xtrain))

mlflow.sklearn.logmodel(

model,

"model",

signature=signature,

inputexample=Xtrain[:2]

)

6. Tracking Server untuk Tim

Untuk production, gunakan tracking server terpusat dengan database backend dan object storage:

mlflow server \

--backend-store-uri postgresql://user:pass@db:5432/mlflow \

--default-artifact-root s3://mlflow-artifacts/ \

--host 0.0.0.0

Integrasi dengan CI/CD

Contoh GitHub Actions workflow untuk training dan registrasi model:

name: ML Training Pipeline

on:

push:

paths:

  • 'training/'
  • 'data/'

jobs:

train:

runs-on: ubuntu-latest

steps:

  • uses: actions/checkout@v4
  • name: Setup Python
uses: actions/setup-python@v5

with:

python-version: '3.11'

  • name: Install dependencies
run: pip install -r requirements.txt

  • name: Train and register model
env:

MLFLOWTRACKINGURI: ${{ secrets.MLFLOWTRACKINGURI }}

run: |

python train.py --n-estimators 200 --max-depth 10

Kesimpulan

MLflow adalah platform MLOps yang lengkap dan mature untuk mengelola seluruh lifecycle machine learning. Fitur utamanya meliputi:

  • Experiment Tracking: Catat semua parameter, metrik, dan artefak secara otomatis
  • Model Registry: Kelola model versions dengan aliases dan tags
  • Model Serving: Deploy model via REST API, Docker, atau batch prediction
  • MLflow Projects: Package kode ML untuk reproducibility
  • MLflow Evaluate**: Evaluasi otomatis untuk model ML dan LLM

Dengan dukungan untuk hampir semua framework ML populer dan integrasi yang mudah dengan infrastruktur existing, MLflow adalah pilihan solid untuk memulai atau meningkatkan praktik MLOps di organisasi Anda. Mulailah dengan experiment tracking sederhana, lalu secara bertahap adopsi fitur-fitur lainnya sesuai kebutuhan tim.

Artikel Terkait

Tutorial Integrasi Azure MLflow: Experiment Tracking di Azure

Tutorial Lengkap Azure MLflow Integration: Experiment Tracking dan Model Management Azure Machine Learning menyediakan i...

MLflow vs Neptune.ai: Panduan Lengkap Experiment Tracking untuk MLOps

MLflow vs Neptune.ai: Panduan Lengkap Experiment Tracking untuk MLOps Experiment tracking adalah komponen krusial dalam ...

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

ZenML: Bikin Pipeline ML dan LLM yang Portable dan Siap Produksi Halo temen-temen, ketemu lagi sama aku, Ruby Abdullah. ...

Tutorial Lengkap Comet ML: Platform MLOps untuk Experiment Tracking dan Model Management

Tutorial Lengkap Comet ML: Platform MLOps untuk Experiment Tracking dan Model Management Dalam dunia machine learning mo...