# 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)               |

{% hint style="info" %}
MLflow ट्रैकिंग सर्वर हल्का है। आप इसे एक छोटे CPU इंस्टेंस पर चला सकते हैं और अपने GPU प्रशिक्षण जॉब्स को उस पर पॉइंट कर सकते हैं। वैकल्पिक रूप से, इसे अपने प्रशिक्षण GPU इंस्टेंस के साथ सह-स्थित करें।
{% endhint %}

***

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

1. लॉग इन करें [clore.ai](https://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
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

```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 डैशबोर्ड दिखना चाहिए।

{% hint style="info" %}
डिफ़ॉल्ट SQLite बैकएंड (`mlflow.db`) सभी रन मेटाडेटा स्थानीय रूप से संग्रहीत करता है। उत्पादन या टीम उपयोग के लिए, PostgreSQL पर स्विच करें — नीचे उन्नत कॉन्फ़िगरेशन देखें।
{% endhint %}

***

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

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

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

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

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

```python
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 ऑटो-लॉगिंग

```python
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

```python
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 के माध्यम से मॉडल वर्ज़न रजिस्टर और प्रबंधित करें:

```python
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 के रूप में सर्व कर सकता है:

```bash
# 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
```

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

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

***

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

### PostgreSQL बैकएंड (उत्पादन)

```bash
# 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 आर्टिफैक्ट स्टोर

```bash
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
```

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

```bash
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`

### आर्टिफैक्ट अपलोड विफल होता है

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

```bash
chmod 777 /mlflow/artifacts
```

### SQLite लॉक त्रुटि (सह-कालिक लिखावट)

**समाधान:** मल्टी-यूज़र सेटअप के लिए PostgreSQL पर स्विच करें:

```bash
pip install psycopg2-binary
```

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

**समाधान:** सत्यापित करें कि आप उपयोग कर रहे हैं `--backend-store-uri` जो रजिस्ट्री का समर्थन करता है (SQLite या PostgreSQL — केवल स्थानीय पाथ नहीं)।

***

## लागत अनुमान

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

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

***

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

* [MLflow आधिकारिक प्रलेखन](https://mlflow.org/docs/latest/index.html)
* [MLflow GitHub](https://github.com/mlflow/mlflow)
* [MLflow Docker Hub](https://github.com/mlflow/mlflow/pkgs/container/mlflow)
* [MLflow मॉडल रजिस्ट्री गाइड](https://mlflow.org/docs/latest/model-registry.html)
* [MLflow ट्रैकिंग API संदर्भ](https://mlflow.org/docs/latest/python_api/mlflow.html)

***

## 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](https://clore.ai/marketplace) GPU सर्वरों पर। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण रूट एक्सेस।