MLflow

MLflow संपूर्ण को प्रबंधित करने के लिए एक ओपन-सोर्स प्लेटफ़ॉर्म है मशीन लर्निंग जीवनचक्र — प्रयोग ट्रैकिंग और मॉडल संस्करणिंग से लेकर परिनियोजन और मॉनिटरिंग तक। दुनिया भर की हज़ारों संस्थाओं द्वारा उपयोग किया जाने वाला MLflow, ML वर्कफ़्लो में संरचना और पुनरुत्पादनशीलता लाता है। इसे Clore.ai के GPU क्लाउड पर चलाएँ ताकि आपको अपने प्रशिक्षण जॉब्स के साथ एक केंद्रीकृत ट्रैकिंग सर्वर मिले।

---

MLflow क्या है?

MLflow चार मुख्य घटक प्रदान करता है:

घटक	विवरण
ट्रैकिंग	ML रन से पैरामीटर, मेट्रिक्स, आर्टिफैक्ट्स और कोड लॉग करें
प्रोजेक्ट्स	पुनरुत्पादन योग्य रन के लिए कोड पैकेज करें
मॉडल्स	फ्रेमवर्क्स के बीच परिनियोजन के लिए मानक मॉडल प्रारूप
मॉडल रजिस्ट्री	संस्करणिंग और जीवनचक्र के साथ केंद्रीकृत मॉडल स्टोर

समर्थित फ्रेमवर्क (अंतर्निर्मित ऑटोलॉगिंग):

• PyTorch, TensorFlow/Keras

• Scikit-learn, XGBoost, LightGBM

• HuggingFace Transformers

• Spark MLlib, statsmodels, Prophet

---

पूर्वापेक्षाएँ

आवश्यकता	मान
GPU VRAM	कोई भी (MLflow सर्वर स्वयं CPU-आधारित है)
स्टोरेज	20 GB+ (आर्टिफैक्ट्स के लिए)
RAM	सर्वर के लिए न्यूनतम 4 GB
पोर्ट्स	22 (SSH), 5000 (MLflow UI)

MLflow ट्रैकिंग सर्वर हल्का है। आप इसे एक छोटे CPU इंस्टेंस पर चला सकते हैं और अपने GPU प्रशिक्षण जॉब्स को इससे जोड़ सकते हैं। वैकल्पिक रूप से, इसे अपने प्रशिक्षण GPU इंस्टेंस के साथ सह-स्थित कर सकते हैं।

---

चरण 1 — Clore.ai पर सर्वर किराए पर लें

1. में लॉग इन करें clore.ai.

2. क्लिक करें मार्केटप्लेस.

3. एक समर्पित ट्रैकिंग सर्वर के लिए: RAM ≥ 8 GB के अनुसार फ़िल्टर करें (GPU वैकल्पिक)।

4. सह-स्थित के लिए: अपने मौजूदा प्रशिक्षण इंस्टेंस का उपयोग करें।

5. Docker इमेज सेट करें: ghcr.io/mlflow/mlflow:latest

6. ओपन पोर्ट सेट करें: 22 (SSH) और 5000 (MLflow UI)।

7. क्लिक करें किराए पर लें.

---

चरण 2 — MLflow ट्रैकिंग सर्वर लॉन्च करें

आधिकारिक ghcr.io/mlflow/mlflow इमेज को स्टार्टअप कमांड ओवरराइड की आवश्यकता होती है।

Clore.ai Docker कॉन्फ़िगरेशन में

को command (या entrypoint override) को इस पर सेट करें:

bash -c "apt-get update -q && apt-get install -y -q openssh-server && \
    mkdir /var/run/sshd && \
    echo 'root:clore123' | chpasswd && \\
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config && \\
    service ssh start && \
    mlflow server \
        --host 0.0.0.0 \\
        --port 5000 \
        --default-artifact-root /mlflow/artifacts \
        --backend-store-uri sqlite:////mlflow/mlflow.db"

वैकल्पिक: कस्टम Dockerfile

FROM ghcr.io/mlflow/mlflow:latest

RUN apt-get update && apt-get install -y \\
    openssh-server \\
    && rm -rf /var/lib/apt/lists/*

# SSH कॉन्फ़िगर करें
RUN mkdir /var/run/sshd && \\
    echo 'root:clore123' | chpasswd && \\
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config

# अतिरिक्त Python पैकेज
RUN pip install boto3 psycopg2-binary

RUN mkdir -p /mlflow/artifacts

EXPOSE 22 5000

CMD service ssh start && \\
    mlflow server \
        --host 0.0.0.0 \\
        --port 5000 \
        --default-artifact-root /mlflow/artifacts \
        --backend-store-uri sqlite:////mlflow/mlflow.db

---

चरण 3 — MLflow UI तक पहुँचें

अपना ब्राउज़र खोलें:

http://<clore-host>:<public-port-5000>

आपको MLflow Experiments डैशबोर्ड दिखना चाहिए।

डिफ़ॉल्ट SQLite बैकएंड (mlflow.db) सभी रन मेटाडेटा को स्थानीय रूप से संग्रहीत करता है। प्रोडक्शन या टीम उपयोग के लिए, PostgreSQL पर स्विच करें — नीचे Advanced Configuration देखें।

---

चरण 4 — अपना पहला प्रयोग लॉग करें

दूरस्थ प्रशिक्षण जॉब से कनेक्ट करें

अपने प्रशिक्षण मशीन पर (या किसी अन्य Clore.ai इंस्टेंस पर), tracking URI सेट करें:

export MLFLOW_TRACKING_URI=http://<clore-host>:<public-port-5000>

बेसिक PyTorch प्रयोग लॉगिंग

import mlflow
import mlflow.pytorch
import torch
import torch.nn as nn
import torch.optim as optim

# MLflow सर्वर से कनेक्ट करें
mlflow.set_tracking_uri("http://<clore-host>:<public-port-5000>")
mlflow.set_experiment("my-first-experiment")

# एक सरल मॉडल परिभाषित करें
class SimpleNet(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super().__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        return self.fc2(self.relu(self.fc1(x)))

# MLflow ट्रैकिंग के साथ प्रशिक्षण
with mlflow.start_run(run_name="training-run-001"):
    # हाइपरपैरामीटर लॉग करें
    params = {
        "learning_rate": 0.001,
        "batch_size": 64,
        "epochs": 100,
        "hidden_size": 256,
        "optimizer": "adam"
    }
    mlflow.log_params(params)
    
    # मॉडल आरंभ करें
    model = SimpleNet(784, 256, 10).cuda()
    optimizer = optim.Adam(model.parameters(), lr=params["learning_rate"])
    criterion = nn.CrossEntropyLoss()
    
    # प्रशिक्षण लूप
    for epoch in range(params["epochs"]):
        loss = torch.tensor(0.5 / (epoch + 1))  # अनुकरणित
        accuracy = 0.7 + epoch * 0.003
        
        # हर epoch पर मेट्रिक्स लॉग करें
        mlflow.log_metrics({
            "train_loss": loss.item(),
            "train_accuracy": accuracy,
        }, step=epoch)
    
    # अंतिम मॉडल लॉग करें
    mlflow.pytorch.log_model(model, "model")
    
    # अंतिम मेट्रिक्स लॉग करें
    mlflow.log_metric("final_accuracy", accuracy)
    
    print(f"रन MLflow में लॉग किया गया। ID: {mlflow.active_run().info.run_id}")

HuggingFace Transformers ऑटोलॉगिंग

import mlflow
from transformers import TrainingArguments, Trainer

mlflow.set_tracking_uri("http://<clore-host>:<public-port-5000>")
mlflow.set_experiment("llm-finetuning")

# ऑटोलॉगिंग सक्षम करें — स्वचालित रूप से params, metrics, और model लॉग करता है
mlflow.transformers.autolog()

training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=64,
    learning_rate=2e-5,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir="./logs",
    logging_steps=10,
    evaluation_strategy="epoch",
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
)

with mlflow.start_run():
    trainer.train()

---

चरण 5 — ऑटोलॉगिंग के साथ Scikit-learn

import mlflow
import mlflow.sklearn
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_digits

mlflow.set_tracking_uri("http://<clore-host>:<public-port-5000>")
mlflow.set_experiment("sklearn-experiments")

# सब कुछ ऑटोलॉग करें
mlflow.sklearn.autolog()

X, y = load_digits(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

with mlflow.start_run(run_name="random-forest-v1"):
    rf = RandomForestClassifier(n_estimators=100, max_depth=10, random_state=42)
    rf.fit(X_train, y_train)
    
    score = rf.score(X_test, y_test)
    print(f"परीक्षण सटीकता: {score:.4f}")
    # सभी params, metrics, और model स्वचालित रूप से लॉग हो गए!

---

चरण 6 — मॉडल रजिस्ट्री

UI या API के माध्यम से मॉडल संस्करण पंजीकृत और प्रबंधित करें:

import mlflow

client = mlflow.MlflowClient("http://<clore-host>:<public-port-5000>")

# रन से एक मॉडल पंजीकृत करें
run_id = "your-run-id-here"
model_uri = f"runs:/{run_id}/model"

registered = mlflow.register_model(
    model_uri=model_uri,
    name="production-classifier"
)

print(f"संस्करण: {registered.version}")

# मॉडल स्टेज बदलें
client.transition_model_version_stage(
    name="production-classifier",
    version=registered.version,
    stage="Production"
)

# कहीं भी प्रोडक्शन मॉडल लोड करें
model = mlflow.pyfunc.load_model(
    model_uri="models:/production-classifier/Production"
)

---

चरण 7 — मॉडल सर्व करें

MLflow किसी भी लॉग किए गए मॉडल को REST API के रूप में सर्व कर सकता है:

# MLflow सर्वर इंस्टेंस पर
export MLFLOW_TRACKING_URI=http://localhost:5000

mlflow models serve \
    --model-uri "models:/production-classifier/Production" \
    --host 0.0.0.0 \\
    --port 5001 \
    --no-conda

सर्व किए गए मॉडल का परीक्षण करें:

curl -X POST http://<clore-host>:5001/invocations \
    -H "Content-Type: application/json" \
    -d '{"inputs": [[1.0, 2.0, 3.0, ...]]}'

---

उन्नत कॉन्फ़िगरेशन

PostgreSQL बैकएंड (प्रोडक्शन)

# PostgreSQL के साथ लॉन्च करें
mlflow server \
    --host 0.0.0.0 \\
    --port 5000 \
    --backend-store-uri postgresql://user:password@db-host/mlflow \
    --default-artifact-root s3://my-bucket/mlflow-artifacts

S3 आर्टिफैक्ट स्टोर

pip install boto3

export AWS_ACCESS_KEY_ID=your_key
export AWS_SECRET_ACCESS_KEY=your_secret

mlflow server \
    --host 0.0.0.0 \\
    --port 5000 \
    --default-artifact-root s3://my-mlflow-bucket/artifacts \
    --backend-store-uri sqlite:////mlflow/mlflow.db

प्रमाणीकरण (एंटरप्राइज़)

pip install mlflow[auth]

mlflow server \
    --host 0.0.0.0 \\
    --port 5000 \
    --app-name basic-auth \
    --backend-store-uri sqlite:////mlflow/mlflow.db \
    --default-artifact-root /mlflow/artifacts

---

UI में रन की तुलना करना

1. MLflow UI खोलें http://<clore-host>:<port>

2. बाएँ पैनल से एक प्रयोग चुनें

3. कई रन के पास वाले बॉक्स चेक करें

4. क्लिक करें तुलना करें ताकि मेट्रिक्स और पैरामीटर साथ-साथ देख सकें

5. का उपयोग करें Charts दृश्य तुलना के लिए टैब

---

समस्या निवारण

ट्रैकिंग सर्वर से कनेक्ट नहीं हो पा रहा

mlflow.exceptions.MlflowException: API अनुरोध status code 503 के साथ विफल हुआ

समाधान:

• जाँचें कि पोर्ट 5000 खुला है और Clore.ai में फ़ॉरवर्ड किया गया है

• सत्यापित करें कि सर्वर चल रहा है: ps aux | grep mlflow

• कनेक्टिविटी का परीक्षण करें: curl http://<clore-host>:<port>/health

आर्टिफैक्ट अपलोड विफल

समाधान: सुनिश्चित करें कि आर्टिफैक्ट डायरेक्टरी लिखने योग्य है:

chmod 777 /mlflow/artifacts

SQLite लॉक त्रुटि (समवर्ती लेखन)

समाधान: बहु-उपयोगकर्ता सेटअप के लिए PostgreSQL पर स्विच करें:

pip install psycopg2-binary

मॉडल रजिस्ट्री दिखाई नहीं दे रही

समाधान: सत्यापित करें कि आप उपयोग कर रहे हैं --backend-store-uri जो रजिस्ट्री को सपोर्ट करता हो (SQLite या PostgreSQL — सिर्फ़ local path नहीं)।

---

लागत अनुमान

इंस्टेंस	उपयोग-प्रकरण	अनुमानित कीमत	नोट्स
CPU 4-कोर	केवल ट्रैकिंग सर्वर	~$0.05/घंटा	बहुत हल्का
RTX 3080	सह-स्थित प्रशिक्षण	$0.05–0.19/घंटा	प्रशिक्षण + MLflow
RTX 4090	भारी प्रशिक्षण + ट्रैकिंग	$0.14–0.42/hr	सबसे सामान्य सेटअप

MLflow को एक सस्ते CPU इंस्टेंस पर चलाएँ और अपने सभी GPU प्रशिक्षण जॉब्स को उससे जोड़ें। इस तरह ट्रैकिंग सर्वर महंगे GPU क्रेडिट खर्च किए बिना लगातार चलता रहेगा।

---

उपयोगी संसाधन

• MLflow आधिकारिक दस्तावेज़

• MLflow GitHub

• MLflow Docker Hub

• MLflow मॉडल रजिस्ट्री गाइड

• MLflow ट्रैकिंग API संदर्भ

---

Clore.ai GPU अनुशंसाएँ

उपयोग-प्रकरण	अनुशंसित GPU	Clore.ai पर अनुमानित लागत
विकास/परीक्षण	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
प्रोडक्शन प्रशिक्षण	RTX 4090 (24GB)	$0.14–0.42/gpu/hr
बड़े पैमाने के प्रयोग	A100 80GB	bare metal

💡 इस गाइड के सभी उदाहरण Clore.ai GPU servers पर तैनात किए जा सकते हैं। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण root access.