ClearML

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

अवलोकन

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

गुण

मान

श्रेणी

MLOps / प्रयोग ट्रैकिंग

डेवलपर

Allegro AI

लाइसेंस

Apache 2.0

GitHub

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 पर सर्वर किराए पर लें

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

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

बनाएँ docker-compose.yml:

संस्करण: "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

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

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

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

docker-compose up -d

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

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

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

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

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 स्वतः लॉस का पता लगाता और लॉग करता है
    print(f"Epoch {epoch}, Loss: {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)

print("प्रशिक्षण पूरा!")
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"Training with lr={params['learning_rate']}, batch={params['batch_size']}")

डेटा प्रबंधन

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

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

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)

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

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

# एजेंट इंस्टॉल करें
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 एजेंट्स के रूप में स्पिन अप करें।

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

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>:8008, न कि localhost।

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

इशू

फ़िक्स

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 नोड्स पर समानांतर रूप से हाइपरपैरामीटर सर्च चलाएँ

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

PreviousBentoML Nextअवलोकन

Last updated 8 hours ago

Was this helpful?

hashtagअवलोकन

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

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

hashtagClore.ai सेटअप

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

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

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

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

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

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

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

hashtagAPI सर्वर

hashtagSSH के माध्यम से

hashtagSDK एकीकरण

hashtagइंस्टॉलेशन

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

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

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

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

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

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

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

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

hashtagClearML एजेंट (वर्कर)

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

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

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

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

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

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

अवलोकन

आर्किटेक्चर

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

Clore.ai सेटअप

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

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

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

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

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

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

वेब डैशबोर्ड

API सर्वर

SSH के माध्यम से

SDK एकीकरण

इंस्टॉलेशन

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

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

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

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

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

डेटा प्रबंधन

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

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

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

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

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

ट्रबलशूटिंग

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

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

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