Chapter 37: MLflow for Tracking
MODULE 6 | MLOps
Chapter 37: MLflow for Tracking
Jab tum model par kaam karti ho to bohat sare experiments hote hain: kabhi 10 trees, kabhi 100 trees, kabhi alag learning rate. Kuch dino baad yaad nahi rehta ke kaun sa model kis setting par kitni accuracy de gaya tha. MLflow ye saara hisaab khud ba khud likh kar rakhta hai, aur ek khoobsurat page par dikhata bhi hai.
37.1 Experiment Tracking kya hai?
37.2 Pehla Experiment: Parameters, Metrics aur Model log karna
Hum Iris par teen alag settings ka Random Forest chalate hain aur har ek ko MLflow me likhte hain. Pehle sqlite ko tracking ka ghar banate hain (ek chhoti si file mlflow.db), taake sab kuch ek jagah rahe:
train_mlflow.py
import mlflow
import mlflow.sklearn
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
mlflow.set_tracking_uri("sqlite:///mlflow.db")
mlflow.set_experiment("iris-experiments")
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42, stratify=y)
for n_trees, depth in [(2, 1), (50, 5), (100, None)]:
with mlflow.start_run(run_name=f"rf_{n_trees}_{depth}"):
model = RandomForestClassifier(n_estimators=n_trees, max_depth=depth,
random_state=42)
model.fit(X_train, y_train)
acc = accuracy_score(y_test, model.predict(X_test))
mlflow.log_param("n_estimators", n_trees)
mlflow.log_param("max_depth", depth)
mlflow.log_metric("accuracy", acc)
mlflow.sklearn.log_model(model, name="model",
serialization_format="cloudpickle")
print(f"n_estimators={n_trees}, max_depth={depth} -> accuracy={acc:.3f}")
OUTPUT
n_estimators=2, max_depth=1 ->
accuracy=0.667
n_estimators=50, max_depth=5 ->
accuracy=0.900
n_estimators=100, max_depth=None ->
accuracy=0.900
(MLflow shuru me kuch INFO aur warning lines bhi chhapta hai; wo normal hain.)
| Code | Kya karta hai |
|---|---|
mlflow.set_tracking_uri("sqlite:///mlflow.db") | Saara record**mlflow.db**file me rakho |
mlflow.set_experiment("iris-experiments") | Experiment (folder) chuno; na ho tonaya bana do |
with mlflow.start_run(run_name=...) | Ek runshuru karo; with ke baad khud band |
mlflow.log_param(naam, qeemat) | Settinglikho |
mlflow.log_metric(naam, qeemat) | Nateejalikho (training ke dauran kai baar bhi likh sakte ho) |
mlflow.sklearn.log_model(...) | Trainedmodel ko run ke sath savekaro |
mlflow.log_artifact("report.txt") | Koi bhifile(plot, report) run ke sath rakho |
VERSION NOTE
Naye MLflow (3.x) me log_model me naam name="model" likhte hain; purane versions (2.x) me artifact_path="model" hota tha. Aur naye versions sklearn models ko default me skops format me save karte hain jo RandomForest jese models par "untrusted types" ka error de sakta hai. Isi liye humne serialization_format="cloudpickle" diya. Agar tumhare version me koi argument na mile to help(mlflow.sklearn.log_model) dekho.
37.3 MLflow UI me Experiments compare karna
Ab sab se maza ka hissa: ek web page jahan tumhare saare runs tasveer ki tarah nazar aate hain. Usi folder me (jahan mlflow.db hai) terminal me ye chalao:
TERMINAL
mlflow ui --backend-store-uri sqlite:///mlflow.db
Phir browser me http://127.0.0.1:5000 kholo. (MLflow ka server chalte waqt terminal band mat karna.)
-
Left side par
iris-experimentsexperiment par click karo. -
Tumhe runs ki table milegi: har run ka naam, parameters (
n_estimators,max_depth) aur metrics (accuracy). -
Accuracy ke column par click karke runs ko tarteeb me lagao; sab se achha model upar aa jayega.
-
Do ya teen runs ke checkbox chuno aur Compare dabao: parameters aur metrics ek sath, side by side dikhenge.
-
Kisi run ke naam par click karo: us ke parameters, metrics aur saved model (Artifacts) alag page par milte hain.
PRACTICAL TIP
Hamare teeno runs me accuracy 0.667, 0.900, 0.900 thi. Dhyan do: 100 trees ne 50 trees se behtar kaam nahi kiya, lekin zyada waqt aur memory lagayi. MLflow ka asal faida yehi hai: tum numbers dekh kar faisla karti ho, andaze se nahi. Chhote test set (30 sample) par accuracy 0.033 ke qadmon me badalti hai, isliye kabhi kabhi do models barabar nikalte hain.
UI ke baghair, code se bhi runs dekh sakte ho:
compare_runs.py
import mlflow
mlflow.set_tracking_uri("sqlite:///mlflow.db")
runs = mlflow.search_runs(experiment_names=["iris-experiments"],
order_by=["metrics.accuracy DESC"])
print(runs[["tags.mlflow.runName", "params.n_estimators", "params.max_depth",
"metrics.accuracy"]].to_string(index=False))
OUTPUT
tags.mlflow.runName params.n_estimators params.max_depth metrics.accuracy
rf_100_None 100 None 0.900000
rf_50_5 50 5 0.900000
rf_2_1 2 1 0.666667
search_runs ek pandas DataFrame deta hai, to tum us par apna filter, sort ya plot bhi laga sakti ho.
37.4 Model ko Save aur Register karna
Achha model mil gaya. Ab usay Model Registry me daalte hain, jahan har model ka naam aur version hota hai, taake deployment wala sirf naam se sahi model utha sake:
OUTPUT
Registered: iris-classifier | version: 1
Loaded prediction: 0
| Address | Matlab |
|---|---|
runs:/<run_id>/model | Wo model jous khaas runne save kiya tha |
models:/iris-classifier/1 | Registry me iris-classifier kaversion 1 |
models:/iris-classifier@champion | Registry me wo version jis par**"champion"kaalias**laga ho |
Naya model train karo to wohi naam dobara register_model karne se version 2 ban jata hai. Ab "production wala model kaun sa hai" batane ke liye alias lagao:
set_alias.py
import mlflow
import mlflow.sklearn
from mlflow.tracking import MlflowClient
mlflow.set_tracking_uri("sqlite:///mlflow.db")
client = MlflowClient()
client.set_registered_model_alias("iris-classifier", "champion", 1)
model = mlflow.sklearn.load_model("models:/iris-classifier@champion")
print("Champion model prediction:", model.predict([[6.7, 3.0, 5.2, 2.3]])[0])
mv = client.get_model_version_by_alias("iris-classifier", "champion")
print("Champion = version", mv.version)
OUTPUT
Champion model prediction: 2
Champion = version 1
Prediction 2 ka matlab virginica. Ab agar kal version 2 behtar nikle, to tum sirf alias ko 2 par muntaqil karti ho; deployment ka code models:/iris-classifier@champion hi rehta hai, us me kuch badalna nahi parta .
VERSION NOTE
Purane MLflow me models ko Stages (Staging, Production) diye jate the. Naye versions me stages ki jagah aliases (jese champion) aur tags use hote hain. Agar koi purani tutorial me stages dekho, to ye farq yaad rakhna.
37.5 autolog: Kam code, zyada tracking
Har cheez log_param se likhna lamba lagta hai? scikit-learn, Keras, XGBoost jese libraries ke liye autolog sab kuch khud likh leta hai:
autolog_demo.py
import mlflow
from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
mlflow.set_tracking_uri("sqlite:///mlflow.db")
mlflow.set_experiment("iris-autolog")
mlflow.sklearn.autolog()
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
random_state=42)
with mlflow.start_run(run_name="logreg_autolog"):
model = LogisticRegression(max_iter=200, C=0.5)
model.fit(X_train, y_train)
print("Test accuracy:", round(model.score(X_test, y_test), 3))
run = mlflow.last_active_run()
print("Params logged:", sorted(k for k in run.data.params if k in ("C", "max_iter")))
OUTPUT
Test accuracy: 1.0
Params logged: ['C', 'max_iter']
Humne C aur max_iter khud log nahi kiye, phir bhi MLflow ne model.fit() ke waqt khud likh liye (training ke metrics aur model bhi). Naye shuru karne walon ke liye autolog se shuru karo , phir zaroorat par log_param / log_metric se apni cheezein jodo.
37.6 MLflow ko asli projects me kaise use karein
| Kab | Kaise |
|---|---|
| Har training script me | start_run ke andarparameters aur metricslog karo |
| Models compare karne par | UI meCompareya search_runs se sab se achha chuno |
| Achha model mil jaye | register_model + champion alias |
| Deployment (FastAPI/Docker) | Registry se models:/naam@champion load karo, ya model file ko Docker imageme rakho |
| Team ke sath kaam | Tracking server alag jagah chalao taake sab ke runs ek jagah aayen |
37.7 Aam Galtiyan aur Hands-on
AAM GALTIYAN
-
mlflow uiko galat folder me chalana : tumhe empty page milta hai kyunkemlflow.db/mlrunsdoosre folder me hain.--backend-store-urihamesha wohi dena jo training me tha. -
Hamesha
set_tracking_urina dena : kabhimlrunsfolder me, kabhimlflow.dbme record chala jata hai aur UI me kuch nazar nahi aata. -
mlflow.dbaurmlruns/ko GitHub par push karna (ye bare ho sakte hain). Inhen.gitignoreaur.dockerignoreme rakho. -
Metric ko test data ki jagah training data par naap kar log karna aur khush ho jana.
-
Sirf accuracy dekh kar model chun lena (kabhi precision/recall zyada ahem hote hain, jese medical masle me).
Hands-on
-
train_mlflow.pyme ek aur setting jodo (maslan(200, 10)) aur UI me 4 runs compare karo. -
log_metric("train_accuracy", ...)bhi log karo aur dekho train aur test me kitna farq hai. -
DecisionTreeClassifierka naya run alag naam se log karo aur Random Forest se compare karo. -
Sab se achhe run ko register karo aur
championalias laga kar@championse model load karo. -
Apne kisi purane project (maslan Titanic) ke experiments MLflow me likh kar dekho.
KEY TAKEAWAYS
-
MLflow ML experiments ki diary hai: parameters, metrics aur models ka record rakhta hai.
-
set_tracking_uri,set_experiment,start_run,log_param,log_metric,log_modelbunyadi cheezein hain. -
mlflow ui --backend-store-uri sqlite:///mlflow.dbse UI khulta hai jahan runs compare hote hain. -
Model Registry me model ka naam aur version hota hai;
championjese alias se production wala model tay hota hai. -
autologkam code me zyada tracking deta hai; lekin accuracy hi sab kuch nahi hoti.