ClearML

ClearML (पूर्व में Trains) प्रयोग ट्रैकिंग, डेटा संस्करणीकरण, मॉडल प्रबंधन, पाइपलाइन ऑर्केस्ट्रेशन, और कंप्यूट संसाधन प्रबंधन के लिए एक ओपन-सोर्स MLOps प्लेटफ़ॉर्म है — सब कुछ एक ही एकीकृत सूट में।

अवलोकन

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

गुण	मान
श्रेणी	MLOps / प्रयोग ट्रैकिंग
डेवलपर	Allegro AI
लाइसेंस	Apache 2.0
GitHub	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 → मार्केटप्लेस

2. के लिए सर्वर घटक: CPU इंस्टेंस ठीक काम करते हैं

3. के लिए प्रशिक्षण वर्कर: GPU इंस्टेंस (RTX 3090, 4090, A100)

4. पोर्ट खोलें: 22, 8008, 8081

5. सुनिश्चित करें ≥ 50 GB डिस्क प्रयोग आर्टिफैक्ट्स के लिए

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

बनाएँ docker-compose.yml:

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

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

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

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

docker-compose up -d

ClearML Server को पूरे स्टैक (MongoDB + Elasticsearch + Redis + API सर्वर + WebUI) के लिए लगभग 4 GB RAM की आवश्यकता होती है। सुनिश्चित करें कि आपका Clore.ai इंस्टेंस पर्याप्त RAM वाला है।

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

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

# 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 के माध्यम से

ssh root@<server-ip> -p 22

---

SDK एकीकरण

इंस्टॉलेशन

pip install clearml

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

clearml-init

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

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

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 पंक्तियाँ)

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

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

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

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

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']} के साथ प्रशिक्षण")

---

डेटा प्रबंधन

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}")

---

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

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)

---

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

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 एजेंट चलाएँ:

# एजेंट इंस्टॉल करें
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 नोड्स चालू करें।

---

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

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)

---

निगरानी और अलर्ट

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)

---

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

Elasticsearch शुरू नहीं होता — सेट करें vm.max_map_count=262144 होस्ट पर: sysctl -w vm.max_map_count=262144. जोड़ें /etc/sysctl.conf स्थायित्व के लिए।

सर्वर से कनेक्ट नहीं हो पा रहा है — Clore.ai पोर्ट सेटिंग्स में 8008 और 8081 पोर्ट खुले हैं, यह सत्यापित करें। जाँचें docker ps सुनिश्चित करने के लिए कि सभी कंटेनर चल रहे हैं।

प्रयोग UI में दिखाई नहीं दे रहे — यह जाँचें कि CLEARML_API_HOST आपकी SDK कॉन्फ़िगरेशन में की ओर इशारा करता है http://<server-ip>:8008localhost नहीं।

डिस्क स्पेस समाप्त हो गया — ClearML सभी आर्टिफैक्ट्स को स्थानीय रूप से संग्रहीत करता है। S3/GCS स्टोरेज कॉन्फ़िगर करें या Clore.ai में डिस्क आवंटन बढ़ाएँ।

समस्या	ठीक करें
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 — प्रयोग ट्रैकिंग का विकल्प

• Weights & Biases — होस्टेड ML प्रयोग ट्रैकिंग

• Ray — वितरित 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

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