# ClearML

{% hint style="info" %}
**ClearML** (पूर्व में Trains) एक ओपन-सोर्स MLOps प्लेटफ़ॉर्म है जो प्रयोग ट्रैकिंग, डेटा संस्करणन, मॉडल प्रबंधन, पाइपलाइन ऑर्केस्ट्रेशन और कंप्यूट संसाधन प्रबंधन के लिए एकीकृत सूट में सभी सुविधाएँ प्रदान करता है।
{% endhint %}

## अवलोकन

ClearML Allegro AI का एक व्यापक ML लाइफसाइकल प्रबंधन प्लेटफ़ॉर्म है। यह न्यूनतम कोड परिवर्तनों के साथ स्वतः प्रयोग के पैरामीटर, मीट्रिक्स, आर्टिफैक्ट और कोड को कैप्चर करता है। ClearML पूरे ML वर्कफ़्लो का समर्थन करता है: डेटा प्रबंधन और प्रयोग ट्रैकिंग से लेकर मॉडल रजिस्ट्री, स्वचालित पाइपलाइनों और GPU क्लस्टरों पर वितरित कार्य निष्पादन तक।

| गुण            | मान                                                       |
| -------------- | --------------------------------------------------------- |
| **श्रेणी**     | MLOps / प्रयोग ट्रैकिंग                                   |
| **डेवलपर**     | Allegro AI                                                |
| **लाइसेंस**    | Apache 2.0                                                |
| **GitHub**     | [allegroai/clearml](https://github.com/allegroai/clearml) |
| **स्टार्स**    | 5.5K+                                                     |
| **Docker Hub** | `allegroai/clearml`                                       |
| **पोर्ट्स**    | 22 (SSH), 8008 (API सर्वर), 8081 (वेब UI)                 |

***

## आर्किटेक्चर

ClearML चार मुख्य घटकों से मिलकर बनता है:

| घटक               | पोर्ट | विवरण                              |
| ----------------- | ----- | ---------------------------------- |
| **ClearML सर्वर** | —     | बैकएंड समन्वयक                     |
| **वेब UI**        | 8081  | ब्राउज़र-आधारित डैशबोर्ड           |
| **API सर्वर**     | 8008  | SDK और एजेंट्स के लिए REST API     |
| **फाइल सर्वर**    | 8081  | आर्टिफैक्ट और मॉडल स्टोरेज         |
| **ClearML एजेंट** | —     | ML टास्क निष्पादित करने वाला वर्कर |

***

## मुख्य विशेषताएँ

* **ज़ीरो-कोड प्रयोग ट्रैकिंग** — सब कुछ स्वतः कैप्चर करने के लिए 2 लाइनें कोड जोड़ें
* **स्वचालित लॉगिंग** — मीट्रिक्स, पैरामीटर, मॉडल, कंसोल आउटपुट, प्लॉट्स, इमेजेज़
* **Git एकीकरण** — git कमिट, डिफ़ और अनकमिट किए गए परिवर्तनों को स्वतः कैप्चर करें
* **डेटा प्रबंधन** — लीनेज ट्रैकिंग के साथ versioned datasets
* **मॉडल रजिस्ट्री** — ML मॉडलों को स्टोर, संस्करण और सर्व करें
* **पाइपलाइन ऑर्केस्ट्रेशन** — बहु-स्टेप ML पाइपलाइनों का निर्माण और चलाना
* **रिमोट निष्पादन** — प्रयोगों को कतारबद्ध करें और रिमोट GPU वर्कर्स (ClearML एजेंट) पर चलाएँ
* **हाइपरपैरामीटर ऑप्टिमाइज़ेशन** — पॉपुलेशन-आधारित ट्रेनिंग के साथ स्वचालित HPO
* **संसाधन मॉनिटरिंग** — प्रति प्रयोग GPU/CPU/RAM मॉनिटरिंग
* **स्व-होस्टेड या क्लाउड** — अपना सर्वर चलाएँ या ClearML का होस्टेड प्लेटफ़ॉर्म उपयोग करें

***

## Clore.ai सेटअप

### विकल्प 1 — पूर्ण स्व-होस्टेड सर्वर

पूर्ण नियंत्रण के लिए ClearML सर्वर Clore.ai पर चलाएँ।

### चरण 1 — एक सर्वर चुनें

| उपयोग मामला                     | अनुशंसित     | वीआरएएम | रैम    |
| ------------------------------- | ------------ | ------- | ------ |
| केवल सर्वर (कोई प्रशिक्षण नहीं) | CPU इंस्टेंस | —       | 8 GB+  |
| सर्वर + प्रशिक्षण               | RTX 3080     | 10 GB   | 16 GB  |
| पूर्ण MLOps क्लस्टर             | कई GPUs      | —       | 32 GB+ |

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

1. जाएँ [clore.ai](https://clore.ai) → **मार्केटप्लेस**
2. के लिए **सर्वर** घटक: CPU इंस्टेंस ठीक काम करते हैं
3. के लिए **प्रशिक्षण वर्कर्स**: GPU इंस्टेंस (RTX 3090, 4090, A100)
4. खुले पोर्ट: **22**, **8008**, **8081**
5. सुनिश्चित करें **≥ 50 GB डिस्क** प्रयोग आर्टिफैक्ट के लिए

### चरण 3 — Docker Compose के साथ डिप्लॉय करें

बनाएँ `docker-compose.yml`:

```yaml
संस्करण: "3.6"

सेवाएँ:
  apiserver:
    इमेज: allegroai/clearml:latest
    रीस्टार्ट: unless-stopped
    वॉल्यूम्स:
      - /opt/clearml/logs:/var/log/clearml
      - /opt/clearml/config:/opt/clearml/config
      - /opt/clearml/data/fileserver:/mnt/fileserver
    पर्यावरण:
      CLEARML_MONGODB_SERVICE_HOST: mongo
      CLEARML_MONGODB_SERVICE_PORT: 27017
      CLEARML_ELASTICSEARCH_SERVICE_HOST: elasticsearch
      CLEARML_ELASTICSEARCH_SERVICE_PORT: 9200
      CLEARML_REDIS_SERVICE_HOST: redis
      CLEARML_REDIS_SERVICE_PORT: 6379
    पोर्ट्स:
      - "8008:8008"
    निर्भर_है_उपर:
      - mongo
      - elasticsearch
      - redis

  webserver:
    इमेज: allegroai/clearml-webserver:latest
    रीस्टार्ट: unless-stopped
    पोर्ट्स:
      - "8081:80"
    पर्यावरण:
      CLEARML_API_HOST: http://localhost:8008

  fileserver:
    इमेज: allegroai/clearml-fileserver:latest
    रीस्टार्ट: unless-stopped
    वॉल्यूम्स:
      - /opt/clearml/data/fileserver:/mnt/fileserver
    पोर्ट्स:
      - "8081:8081"

  mongo:
    इमेज: mongo:4.4
    रीस्टार्ट: unless-stopped
    वॉल्यूम्स:
      - /opt/clearml/data/mongo:/data/db
    कमांड: --setParameter internalQueryMaxBlockingSortMemoryUsageBytes=196100200

  elasticsearch:
    इमेज: docker.elastic.co/elasticsearch/elasticsearch:7.17.6
    रीस्टार्ट: unless-stopped
    पर्यावरण:
      ES_JAVA_OPTS: "-Xms512m -Xmx2048m"
      bootstrap.memory_lock: "true"
      cluster.name: "clearml"
      discovery.type: "single-node"
      http.publish_host: "$CLEARML_HOST_IP"
    ulimits:
      memlock:
        soft: -1
        hard: -1
    वॉल्यूम्स:
      - /opt/clearml/data/elastic:/usr/share/elasticsearch/data

  redis:
    इमेज: redis:6
    रीस्टार्ट: unless-stopped
    वॉल्यूम्स:
      - /opt/clearml/data/redis:/data

नेटवर्क्स:
  डिफ़ॉल्ट:
    नाम: clearml_network
```

स्टैक शुरू करें:

```bash
mkdir -p /opt/clearml/{logs,config,data/{fileserver,mongo,elastic,redis}}

# अपने सर्वर का सार्वजनिक IP सेट करें
export CLEARML_HOST_IP=<your-server-ip>

docker-compose up -d
```

{% hint style="warning" %}
ClearML सर्वर को पूर्ण स्टैक (MongoDB + Elasticsearch + Redis + API सर्वर + WebUI) के लिए \~4 GB RAM की आवश्यकता होती है। सुनिश्चित करें कि आपकी Clore.ai इंस्टेंस में पर्याप्त RAM हो।
{% endhint %}

### विकल्प 2 — ClearML Hosted (फ्री) उपयोग करें

सर्वर चलाए बिना प्रयोग ट्रैकिंग के लिए फ्री होस्टेड प्लान का उपयोग करें:

```bash
# SDK इंस्टॉल करें
pip install clearml

# होस्टेड सर्वर के साथ कॉन्फ़िगर करें
clearml-init
# जब API होस्ट के लिए पूछे तो दर्ज करें: https://api.clear.ml
# क्रेडेंशियल्स प्राप्त करें: https://app.clear.ml/settings/workspace-configuration
```

***

## इंटरफ़ेस तक पहुँच

### वेब डैशबोर्ड

```
http://<server-ip>:8081
```

डिफ़ॉल्ट क्रेडेंशियल्स: पहले लॉगिन पर अपना अकाउंट बनाएं।

### API सर्वर

```
http://<server-ip>:8008
```

### SSH के माध्यम से

```bash
ssh root@<server-ip> -p 22
```

***

## SDK एकीकरण

### इंस्टॉलेशन

```bash
pip install clearml
```

### प्रारम्भिक कॉन्फ़िगरेशन

```bash
clearml-init
```

अपने सर्वर URL दर्ज करें (`http://<server-ip>:8008`) और डैशबोर्ड से API क्रेडेंशियल्स।

या प्रोग्रामेटिक रूप से कॉन्फ़िगर करें:

```python
from clearml import Task

Task.set_credentials(
    api_host="http://<server-ip>:8008",
    web_host="http://<server-ip>:8081",
    files_host="http://<server-ip>:8081",
    key="YOUR_ACCESS_KEY",
    secret="YOUR_SECRET_KEY"
)
```

***

## प्रयोग ट्रैक करना

### न्यूनतम एकीकरण (2 लाइनें)

```python
from clearml import Task

# टास्क इनिशियलाइज़ करें — यह सब कुछ स्वतः कैप्चर कर लेता है
task = Task.init(project_name="MyProject", task_name="experiment-001")

# आपका मौजूदा प्रशिक्षण कोड — कोई बदलाव आवश्यक नहीं
import torch
import torch.nn as nn

model = nn.Linear(10, 1)
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

for epoch in range(10):
    loss = torch.tensor(1.0 / (epoch + 1))
    # यदि मानक फ्रेमवर्क का उपयोग कर रहे हैं तो ClearML स्वतः लॉस का पता लगाता और लॉग करता है
    print(f"Epoch {epoch}, Loss: {loss.item():.4f}")

task.close()
```

### मैनुअल मीट्रिक लॉगिंग

```python
from clearml import Task, Logger

task = Task.init(project_name="MyProject", task_name="manual-logging-demo")
logger = task.get_logger()

for epoch in range(50):
    train_loss = 1.0 / (epoch + 1)
    val_accuracy = 0.95 - 0.5 / (epoch + 1)

    # स्केलर लॉग करें
    logger.report_scalar("Loss", "train", value=train_loss, iteration=epoch)
    logger.report_scalar("Accuracy", "validation", value=val_accuracy, iteration=epoch)

    # लर्निंग रेट लॉग करें
    logger.report_scalar("Learning Rate", "lr", value=0.001 * 0.9**epoch, iteration=epoch)

print("प्रशिक्षण पूरा!")
task.close()
```

### हाइपरपैरामीटर ट्रैकिंग

```python
from clearml import Task

task = Task.init(project_name="HPO-Demo", task_name="run-001")

# हाइपरपैरामीटर कनेक्ट करें — स्वतः लॉग होते हैं और रिमोट रूप से ओवरराइड किए जा सकते हैं
params = {
    "learning_rate": 0.001,
    "batch_size": 32,
    "num_layers": 4,
    "dropout": 0.3,
    "optimizer": "adam",
    "epochs": 100,
}
params = task.connect(params)  # अब ClearML HPO द्वारा ओवरराइड किया जा सकता है

print(f"Training with lr={params['learning_rate']}, batch={params['batch_size']}")
```

***

## डेटा प्रबंधन

```python
from clearml import Dataset

# एक versioned dataset बनाएं
dataset = Dataset.create(
    dataset_name="my-training-data",
    dataset_project="MyProject",
    dataset_version="1.0",
)

# फ़ाइलें जोड़ें
dataset.add_files(path="/data/images/", recursive=True)
dataset.add_files(path="/data/labels.csv")

# ClearML सर्वर पर अपलोड करें
dataset.upload()
dataset.finalize()
print(f"Dataset ID: {dataset.id}")

# बाद में: प्रयोगों में dataset का उपयोग करें
dataset = Dataset.get(dataset_name="my-training-data", dataset_version="1.0")
local_path = dataset.get_local_copy()
print(f"Dataset at: {local_path}")
```

***

## मॉडल रजिस्ट्री

```python
from clearml import Task, OutputModel, InputModel
import torch

task = Task.init(project_name="ModelRegistry", task_name="training-run")

# प्रशिक्षण के बाद, मॉडल रजिस्टर करें
model = torch.nn.Linear(100, 10)
torch.save(model.state_dict(), "my_model.pt")

# आउटपुट मॉडल रजिस्टर करें
output_model = OutputModel(task=task, name="MyModel-v1")
output_model.update_weights("my_model.pt")
output_model.publish()  # उपयोग के लिए तैयार मार्क करें

print(f"Model registered: {output_model.id}")

# परिनियोजन में: नाम से मॉडल लोड करें
input_model = InputModel(model_id="<model-id-from-dashboard>")
local_model_path = input_model.get_local_copy()
state_dict = torch.load(local_model_path)
```

***

## पाइपलाइन ऑर्केस्ट्रेशन

```python
from clearml.automation import PipelineController

def step_preprocess(dataset_id: str) -> str:
    """डेटा प्रीप्रोसेसिंग चरण."""
    from clearml import Task, Dataset
    task = Task.init(task_name="step-preprocess")
    # ... प्रीप्रोसेसिंग लॉजिक
    return "processed_data_id"

def step_train(data_id: str, lr: float = 0.001) -> str:
    """मॉडल प्रशिक्षण चरण."""
    from clearml import Task
    task = Task.init(task_name="step-train")
    # ... प्रशिक्षण लॉजिक
    return "model_id"

def step_evaluate(model_id: str) -> float:
    """मॉडल मूल्यांकन चरण."""
    from clearml import Task
    task = Task.init(task_name="step-evaluate")
    # ... मूल्यांकन लॉजिक
    return 0.95

# पाइपलाइन बनाएं
pipe = PipelineController(
    name="ML-Training-Pipeline",
    project="MyPipelines",
    version="1.0"
)

pipe.add_function_step(
    name="preprocess",
    function=step_preprocess,
    function_kwargs={"dataset_id": "raw-data-id"},
    function_return=["processed_id"],
)

pipe.add_function_step(
    name="train",
    parents=["preprocess"],
    function=step_train,
    function_kwargs={"data_id": "${preprocess.processed_id}"},
    function_return=["model_id"],
    execution_queue="gpu-queue",  # GPU वर्कर पर चलाएँ
)

pipe.add_function_step(
    name="evaluate",
    parents=["train"],
    function=step_evaluate,
    function_kwargs={"model_id": "${train.model_id}"},
    function_return=["accuracy"],
)

pipe.start()
pipe.wait()
print("पाइपलाइन पूर्ण!")
```

***

## ClearML एजेंट (वर्कर)

कतारबद्ध प्रयोगों को निष्पादित करने के लिए GPU सर्वर पर ClearML एजेंट चलाएँ:

```bash
# एजेंट इंस्टॉल करें
pip install clearml-agent

# कॉन्फ़िगर करें (SDK के समान क्रेडेंशियल्स का उपयोग करता है)
clearml-agent init

# GPU पर वर्कर शुरू करें
clearml-agent daemon --queue "gpu-queue" --gpus 0,1

# Docker आइसोलेशन के साथ वर्कर शुरू करें (अनुशंसित)
clearml-agent daemon \
    --queue "gpu-queue" \
    --docker pytorch/pytorch:2.1.0-cuda12.1-cudnn8-runtime \
    --gpus all
```

Clore.ai पर, वितरित कंप्यूट क्लस्टर बनाने के लिए कई GPU नोड्स को ClearML एजेंट्स के रूप में स्पिन अप करें।

***

## हाइपरपैरामीटर ऑप्टिमाइज़ेशन

```python
from clearml.automation import (
    HyperParameterOptimizer,
    UniformParameterRange,
    DiscreteParameterValues,
    GridSearch,
)

optimizer = HyperParameterOptimizer(
    base_task_id="<task-id-to-optimize>",
    hyper_parameters=[
        UniformParameterRange("General/learning_rate", min_value=1e-5, max_value=1e-2, step_size=1e-5),
        DiscreteParameterValues("General/batch_size", values=[16, 32, 64, 128]),
        DiscreteParameterValues("General/optimizer", values=["adam", "sgd", "adamw"]),
    ],
    objective_metric_title="Accuracy",
    objective_metric_series="validation",
    objective_metric_sign="max",  # मान्यता सटीकता अधिकतम करें
    max_number_of_concurrent_tasks=4,
    optimizer_class=GridSearch,
    execution_queue="gpu-queue",
    total_max_jobs=50,
)

optimizer.start()
top_exps = optimizer.get_top_experiments(top_k=3)
print("सर्वश्रेष्ठ प्रयोग:", top_exps)
```

***

## मॉनिटरिंग और अलर्ट्स

```python
from clearml import Task

task = Task.init(project_name="Production", task_name="monitoring")

# आसान फ़िल्टरिंग के लिए टास्क टैग सेट करें
task.add_tags(["production", "v2.1", "gpu"])

# सिस्टम मीट्रिक्स स्वतः लॉग करें — बस टास्क इनिशियलाइज़ करें
# ClearML यह कैप्चर करता है: CPU, RAM, GPU उपयोग, GPU VRAM स्वतः

# कस्टम स्केलर मॉनिटरिंग जोड़ें
logger = task.get_logger()
import time
for i in range(100):
    gpu_util = 85 + (i % 10)
    logger.report_scalar("GPU", "utilization_%", value=gpu_util, iteration=i)
    time.sleep(1)
```

***

## ट्रबलशूटिंग

{% hint style="warning" %}
**Elasticsearch शुरू नहीं हो रहा है** — सेट करें `vm.max_map_count=262144` होस्ट पर: `sysctl -w vm.max_map_count=262144`. जोड़ें `/etc/sysctl.conf` स्थायित्व के लिए।
{% endhint %}

{% hint style="warning" %}
**सर्वर से कनेक्ट नहीं कर पा रहे** — Clore.ai पोर्ट सेटिंग्स में सुनिश्चित करें कि 8008 और 8081 पोर्ट खुलें हैं। जाँच करें `docker ps` यह सुनिश्चित करने के लिए कि सभी कंटेनर चल रहे हैं।
{% endhint %}

{% hint style="info" %}
**प्रयोग UI में दिखाई नहीं रहे** — जाँच करें कि `CLEARML_API_HOST` आपके SDK कॉन्फ़िग में यह दर्शाता है `http://<server-ip>:8008`, न कि localhost।
{% endhint %}

{% hint style="info" %}
**डिस्क स्पेस समाप्त** — ClearML सभी आर्टिफैक्ट स्थानीय रूप से स्टोर करता है। S3/GCS स्टोरेज कॉन्फ़िगर करें या Clore.ai में डिस्क एलोकेशन बढ़ाएँ।
{% endhint %}

| इशू                      | फ़िक्स                                                                             |
| ------------------------ | ---------------------------------------------------------------------------------- |
| MongoDB कनेक्शन अस्वीकृत | mongo कंटेनर की जाँच करें: `docker logs clearml_mongo_1`                           |
| टास्क कतार में अटक गया   | सुनिश्चित करें कि ClearML एजेंट चल रहा है और क्यू से जुड़ा हुआ है                  |
| UI धीमा                  | Elasticsearch को इंडेक्स करने में समय चाहिए — स्टार्टअप के 2–3 मिनट प्रतीक्षा करें |
| API 401 अनअथॉराइज़्ड     | ClearML वेब डैशबोर्ड में API क्रेडेंशियल्स पुनः उत्पन्न करें                       |

***

## GPU शोधकर्ताओं के लिए उपयोग मामले

* **प्रशिक्षण रन ट्रैक करें** — हाइपरपैरामीटर या परिणाम कभी खोएँ नहीं
* **प्रयोगों की तुलना करें** — UI में बगल-बगल मीट्रिक तुलना
* **परिणाम पुनरुत्पादन करें** — ClearML स्वतः git कमिट + कोड डिफ़ कैप्चर करता है
* **परिणाम साझा करें** — सहयोगी साझा डैशबोर्ड में सभी प्रयोग देख सकते हैं
* **रिमोट GPU जॉब्स** — लैपटॉप से प्रशिक्षण जॉब्स कतारबद्ध करें, Clore.ai GPU नोड्स पर चलाएँ
* **स्वचालित HPO** — कई GPU नोड्स पर समानांतर रूप से हाइपरपैरामीटर सर्च चलाएँ

***

## संबंधित टूल्स

* [MLflow](https://docs.clore.ai/guides/guides_v2-hi/mlops/mlflow) — प्रयोग ट्रैकिंग विकल्प
* [Weights & Biases](https://wandb.ai/) — होस्टेड ML प्रयोग ट्रैकिंग
* [Ray](https://www.ray.io/) — वितरित ML प्रशिक्षण और HPO

***

*Clore.ai पर ClearML प्रयोग ट्रैकिंग को GPU कंप्यूट प्रबंधन के साथ जोड़ता है — आपकी ML टीम को क्लाउड वेंडर लॉक-इन के बिना पूर्ण MLOps क्षमताएं देता है।*

***

## 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 सर्वर। उपलब्ध GPU ब्राउज़ करें और प्रति घंटे किराए पर लें — कोई प्रतिबद्धताएँ नहीं, पूर्ण रूट एक्सेस।