MLflow

— 4 गाइड्स: कुल के प्रबंधन के लिए एक ओपन-सोर्स प्लेटफ़ॉर्म है मशीन लर्निंग जीवनचक्र — प्रयोग ट्रैकिंग और मॉडल वर्शनिंग से लेकर परिनियोजन और निगरानी तक। दुनिया भर में हजारों संगठनों द्वारा उपयोग किया जाता है, 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 डॉकर कॉन्फ़िगरेशन में

सेट करें कमान्ड (या एंट्रीपॉइंट ओवरराइड) को:

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 पर स्विच करें — नीचे उन्नत कॉन्फ़िगरेशन देखें।

---

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

रिमोट प्रशिक्षण जॉब से कनेक्ट करें

अपने प्रशिक्षण मशीन (या किसी अन्य Clore.ai इंस्टेंस) पर, ट्रैकिंग 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
        
        # प्रत्येक एपोच पर मेट्रिक्स लॉग करें
        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"Run logged to 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")

# ऑटो-लॉगिंग सक्षम करें — स्वचालित रूप से पैरामीटर, मेट्रिक्स और मॉडल लॉग करता है
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 — Autologging के साथ 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"Test Accuracy: {score:.4f}")
    # सभी पैरामीटर, मेट्रिक्स और मॉडल स्वचालित रूप से लॉग हो गए!

---

चरण 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"Version: {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. उपयोग करें चार्ट्स विज़ुअल तुलना के लिए टैब

---

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

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

mlflow.exceptions.MlflowException: API अनुरोध विफल हुआ, स्थिति कोड 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 — केवल स्थानीय पाथ नहीं)।

---

लागत अनुमान

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

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

---

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

• MLflow आधिकारिक प्रलेखन

• MLflow GitHub

• MLflow Docker Hub

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

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

---

Clore.ai GPU सिफारिशें

उपयोग केस	सिफारिश की गई GPU	Clore.ai पर अनुमानित लागत
डेवलपमेंट/टेस्टिंग	RTX 3090 (24GB)	~$0.12/gpu/hr
उत्पादन प्रशिक्षण	RTX 4090 (24GB)	~$0.70/gpu/hr
बड़े पैमाने पर प्रयोग	A100 80GB	~$1.20/gpu/hr

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