> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-hi/mlops/clearml.md).

# 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+                                                     |
| **डॉकर हब** | `allegroai/clearml`                                       |
| **पोर्ट्स** | 22 (SSH), 8008 (API सर्वर), 8081 (वेब UI)                 |

***

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

ClearML में चार मुख्य घटक शामिल हैं:

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

***

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

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

***

## Clore.ai सेटअप

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

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

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

| उपयोग-प्रकरण                    | अनुशंसित     | VRAM  | RAM    |
| ------------------------------- | ------------ | ----- | ------ |
| केवल सर्वर (कोई प्रशिक्षण नहीं) | CPU इंस्टेंस | —     | 8 GB+  |
| सर्वर + प्रशिक्षण               | RTX 3080     | 10 GB | 16 GB  |
| पूर्ण MLOps क्लस्टर             | कई GPU       | —     | 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
version: "3.6"

services:
  apiserver:
    image: allegroai/clearml:latest
    restart: unless-stopped
    volumes:
      - /opt/clearml/logs:/var/log/clearml
      - /opt/clearml/config:/opt/clearml/config
      - /opt/clearml/data/fileserver:/mnt/fileserver
    environment:
      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
    ports:
      - "8008:8008"
    depends_on:
      - mongo
      - elasticsearch
      - redis

  webserver:
    image: allegroai/clearml-webserver:latest
    restart: unless-stopped
    ports:
      - "8081:80"
    environment:
      CLEARML_API_HOST: http://localhost:8008

  fileserver:
    image: allegroai/clearml-fileserver:latest
    restart: unless-stopped
    volumes:
      - /opt/clearml/data/fileserver:/mnt/fileserver
    ports:
      - "8081:8081"

  mongo:
    image: mongo:4.4
    restart: unless-stopped
    volumes:
      - /opt/clearml/data/mongo:/data/db
    command: --setParameter internalQueryMaxBlockingSortMemoryUsageBytes=196100200

  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.17.6
    restart: unless-stopped
    environment:
      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
    volumes:
      - /opt/clearml/data/elastic:/usr/share/elasticsearch/data

  redis:
    image: redis:6
    restart: unless-stopped
    volumes:
      - /opt/clearml/data/redis:/data

networks:
  default:
    name: 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 Server को पूरे स्टैक (MongoDB + Elasticsearch + Redis + API सर्वर + WebUI) के लिए लगभग 4 GB RAM की आवश्यकता होती है। सुनिश्चित करें कि आपका Clore.ai इंस्टेंस पर्याप्त RAM वाला है।
{% endhint %}

### विकल्प 2 — ClearML होस्टेड का उपयोग करें (निःशुल्क)

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

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

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

***

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

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

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

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

### एपीआई सर्वर

```
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 loss को स्वचालित रूप से पहचानता और लॉग करता है
    print(f"एपोक {epoch}, लॉस: {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)

प्रशिक्षण पूरा हुआ!
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"lr={params['learning_rate']}, batch={params['batch_size']} के साथ प्रशिक्षण")
```

***

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

```python
from clearml import 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"डेटासेट ID: {dataset.id}")

# बाद में: प्रयोगों में डेटासेट का उपयोग करें
dataset = Dataset.get(dataset_name="my-training-data", dataset_version="1.0")
local_path = dataset.get_local_copy()
print(f"डेटासेट यहाँ है: {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"मॉडल पंजीकृत: {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()
"Pipeline complete!"
```

***

## 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.11.0-cuda12.8-cudnn9-runtime \\
    --gpus all
```

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

***

## हाइपरपैरामीटर अनुकूलन

```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 Agent चल रहा है और कतार से जुड़ा हुआ है                        |
| धीमा UI                    | Elasticsearch को इंडेक्स करने में समय लगता है — स्टार्टअप के बाद 2–3 मिनट प्रतीक्षा करें |
| API 401 अनधिकृत            | ClearML वेब डैशबोर्ड में API क्रेडेंशियल्स पुनः जनरेट करें                               |

***

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

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

***

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

* [MLflow](/guides/guides_v2-hi/mlops/mlflow.md) — प्रयोग ट्रैकिंग का विकल्प
* [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.07–0.21/gpu/hr                         |
| प्रोडक्शन प्रशिक्षण   | RTX 4090 (24GB) | $0.14–0.42/gpu/hr                         |
| बड़े पैमाने के प्रयोग | A100 80GB       | [bare metal](https://clore.ai/bare-metal) |

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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-hi/mlops/clearml.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.