AI के लिए Ray Clusters: वितरित कंप्यूटिंग आर्किटेक्चर

11 दिसंबर, 2025 को अपडेट किया गया

दिसंबर 2025 अपडेट: OpenAI ChatGPT ट्रेनिंग को समन्वित करने के लिए Ray का उपयोग कर रहा है। Ray का PyTorch Foundation में शामिल होना एंटरप्राइज अडॉप्शन को मान्य करता है। फ्रेमवर्क लैपटॉप से लेकर हजारों GPUs तक स्केल करता है। AI पैटर्न के लिए Spark से एक ऑर्डर ऑफ मैग्नीट्यूड तेज—सब-मिलीसेकंड लेटेंसी के साथ प्रति सेकंड लाखों टास्क प्राप्त करना। CPU/GPU वर्कलोड मिक्सिंग को सपोर्ट करने वाला नेटिव हेटेरोजीनियस कंप्यूट।

OpenAI ChatGPT और अन्य मॉडल्स की ट्रेनिंग को समन्वित करने के लिए Ray का उपयोग करता है।¹ यह फ्रेमवर्क लैपटॉप से लेकर हजारों GPUs के क्लस्टर तक स्केल करता है, जो वितरित कंप्यूटिंग जटिलता को संभालता है जिसके लिए अन्यथा हर प्रोजेक्ट के लिए कस्टम इंफ्रास्ट्रक्चर की आवश्यकता होती। 2025 में Ray की अडॉप्शन में विस्फोट हुआ, जिसे PyTorch Foundation में फ्रेमवर्क के शामिल होने और Anyscale द्वारा एंटरप्राइज डिप्लॉयमेंट को सपोर्ट करने के लिए पूंजी जुटाने से मान्यता मिली।² Ray की आर्किटेक्चर और डिप्लॉयमेंट पैटर्न को समझना संगठनों को वितरित AI इंफ्रास्ट्रक्चर बनाने में मदद करता है जो प्रयोग से लेकर प्रोडक्शन तक स्केल करता है।

Ray वितरित AI वर्कलोड—ट्रेनिंग, ट्यूनिंग, इन्फरेंस, और डेटा प्रोसेसिंग—के लिए एक एकीकृत फ्रेमवर्क प्रदान करता है जो क्लस्टर मैनेजमेंट की जटिलता को एब्स्ट्रैक्ट करता है जबकि रिसोर्स एलोकेशन पर फाइन-ग्रेन्ड कंट्रोल बनाए रखता है। सिंगल-GPU प्रयोग से आगे मल्टी-नोड प्रोडक्शन सिस्टम में जाने वाले संगठनों के लिए, Ray स्केलेबल AI इंफ्रास्ट्रक्चर का सबसे सीधा रास्ता प्रदान करता है।

AI इंफ्रास्ट्रक्चर के लिए Ray क्यों

Ray UC Berkeley के RISELab से वितरित AI वर्कलोड की विशिष्ट चुनौतियों को संबोधित करने के लिए उभरा जिन्हें Apache Spark जैसे पारंपरिक फ्रेमवर्क खराब तरीके से संभालते हैं:

AI वर्कलोड आवश्यकताएं

हेटेरोजीनियस कंप्यूट: AI पाइपलाइन CPU-इंटेंसिव डेटा प्रोसेसिंग को GPU-एक्सेलरेटेड ट्रेनिंग और इन्फरेंस के साथ मिलाती हैं। Ray नेटिव रूप से हेटेरोजीनियस रिसोर्स एलोकेशन को सपोर्ट करता है, वर्कलोड की मांग के अनुसार CPUs और GPUs में टास्क शेड्यूल करता है।³

फाइन-ग्रेन्ड पैरेललिज्म: डीप लर्निंग ट्रेनिंग के लिए वर्कर्स में ग्रेडिएंट्स को समन्वित करना, मॉडल स्टेट को मैनेज करना, और फेलर्स को ग्रेसफुली हैंडल करना आवश्यक है। Ray की टास्क और एक्टर एब्स्ट्रैक्शन इन पैटर्न के लिए आवश्यक प्रिमिटिव प्रदान करती हैं।

स्टेटफुल कम्प्यूटेशन: MapReduce-स्टाइल फ्रेमवर्क के विपरीत, AI वर्कलोड अक्सर इटरेशन में स्टेट बनाए रखते हैं। Ray एक्टर्स इनवोकेशन के बीच स्टेट पर्सिस्ट करते हैं, पैरामीटर सर्वर और रीइन्फोर्समेंट लर्निंग एजेंट्स जैसे पैटर्न को सपोर्ट करते हैं।

लो लेटेंसी: रीयल-टाइम इन्फरेंस और हाइपरपैरामीटर सर्च के लिए माइक्रोसेकंड टास्क शेड्यूलिंग की आवश्यकता होती है। Ray सब-मिलीसेकंड लेटेंसी के साथ प्रति सेकंड लाखों टास्क प्राप्त करता है—इन पैटर्न के लिए Spark से एक ऑर्डर ऑफ मैग्नीट्यूड तेज।⁴

विकल्पों के साथ तुलना

Apache Spark: SQL और DataFrames के साथ बैच डेटा प्रोसेसिंग के लिए ऑप्टिमाइज्ड। ETL, फीचर इंजीनियरिंग, और स्ट्रक्चर्ड डेटा पर एनालिटिक्स में उत्कृष्ट। GPU वर्कलोड, स्टेटफुल कम्प्यूटेशन, और लो-लेटेंसी आवश्यकताओं के लिए कम उपयुक्त।⁵

Dask: DataFrame और array APIs के साथ Python-नेटिव डिस्ट्रिब्यूटेड कंप्यूटिंग। Spark से हल्का लेकिन Ray के एक्टर मॉडल और ML-स्पेसिफिक लाइब्रेरीज का अभाव।

Horovod: विशेष रूप से डिस्ट्रिब्यूटेड डीप लर्निंग ट्रेनिंग पर फोकस्ड। विविध AI वर्कलोड के लिए Ray से कम फ्लेक्सिबल लेकिन प्योर ट्रेनिंग सिनेरियो के लिए सरल।

Ray का एडवांटेज: एक ही फ्रेमवर्क डेटा प्रोसेसिंग, ट्रेनिंग, हाइपरपैरामीटर ट्यूनिंग, और इन्फरेंस सर्विंग को संभालता है। टीमें मल्टीपल सिस्टम मैनेज करने और उनके बीच इंटीग्रेशन जटिलता से बचती हैं।

प्रोडक्शन अडॉप्शन

प्रमुख संगठन प्रोडक्शन में Ray चलाते हैं:⁶

• OpenAI: ChatGPT ट्रेनिंग समन्वय
• Uber: डिस्ट्रिब्यूटेड ML प्लेटफॉर्म
• Instacart: ML इंफ्रास्ट्रक्चर बैकबोन
• Shopify: प्रोडक्शन ML वर्कलोड
• Ant Group: लार्ज-स्केल फाइनेंशियल ML

Ray क्लस्टर आधिकारिक रूप से 2,000 नोड्स तक सपोर्ट करते हैं, जो फ्रंटियर मॉडल ट्रेनिंग और हाई-वॉल्यूम इन्फरेंस के लिए आवश्यक स्केल को सक्षम करता है।

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

कोर एब्स्ट्रैक्शन

Ray डिस्ट्रिब्यूटेड कम्प्यूटेशन के लिए दो मौलिक एब्स्ट्रैक्शन प्रदान करता है:

Tasks: रिमोटली एक्जीक्यूट होने वाले स्टेटलेस फंक्शन। Ray ऑटोमैटिकली उपलब्ध वर्कर्स में टास्क शेड्यूल करता है, फेलर्स हैंडल करता है, और रिजल्ट्स रिटर्न करता है।

import ray

ray.init()

@ray.remote
def process_batch(data):
    # किसी भी उपलब्ध वर्कर पर चलता है
    return transform(data)

# पैरेलल में एक्जीक्यूट करें
futures = [process_batch.remote(batch) for batch in batches]
results = ray.get(futures)

Actors: क्लस्टर में डिस्ट्रिब्यूटेड स्टेटफुल ऑब्जेक्ट्स। प्रत्येक एक्टर मेथड कॉल्स के बीच स्टेट मेंटेन करता है, जो मॉडल सर्विंग, पैरामीटर सर्वर, और गेम एनवायरनमेंट जैसे पैटर्न को सक्षम करता है।

@ray.remote
class ModelServer:
    def __init__(self, model_path):
        self.model = load_model(model_path)

    def predict(self, input_data):
        return self.model(input_data)

# एक्टर इंस्टेंस बनाएं
server = ModelServer.remote("model.pt")
# रिमोटली मेथड्स कॉल करें
prediction = ray.get(server.predict.remote(data))

क्लस्टर आर्किटेक्चर

Ray क्लस्टर एक हेड नोड और वर्कर नोड्स से मिलकर बनते हैं:

Head node: क्लस्टर स्टेट मैनेज करने वाला Global Control Store (GCS), डेटा लोकेशन ट्रैक करने वाली ऑब्जेक्ट डायरेक्टरी, और टास्क प्लेसमेंट समन्वित करने वाला शेड्यूलर चलाता है।

Worker nodes: टास्क और एक्टर्स एक्जीक्यूट करते हैं। प्रत्येक वर्कर एक Raylet डेमन चलाता है जो लोकल शेड्यूलिंग और ऑब्जेक्ट मैनेजमेंट हैंडल करता है।

Object store: डिस्ट्रिब्यूटेड शेयर्ड मेमोरी जो एक ही नोड पर टास्क के बीच जीरो-कॉपी डेटा पासिंग और नोड्स के बीच एफिशिएंट सीरियलाइजेशन सक्षम करती है।

रिसोर्स मैनेजमेंट

Ray हेटेरोजीनियस रिसोर्सेज को एक्सप्लिसिटली मैनेज करता है:

@ray.remote(num_cpus=4, num_gpus=1)
def train_step(model, data):
    # गारंटीड 4 CPUs और 1 GPU
    return model.train(data)

कस्टम रिसोर्सेज फाइन-ग्रेन्ड शेड्यूलिंग सक्षम करते हैं:

# स्पेसिफिक हार्डवेयर रिक्वेस्ट करें
@ray.remote(resources={"TPU": 1})
def tpu_inference(data):
    return run_on_tpu(data)

Ray AI लाइब्रेरीज

Ray में सामान्य AI वर्कलोड के लिए पर्पस-बिल्ट लाइब्रेरीज शामिल हैं:

Ray Train

PyTorch, TensorFlow, और अन्य फ्रेमवर्क को सपोर्ट करने वाला डिस्ट्रिब्यूटेड ट्रेनिंग एब्स्ट्रैक्शन:

from ray.train.torch import TorchTrainer
from ray.train import ScalingConfig

def train_func():
    # स्टैंडर्ड PyTorch ट्रेनिंग कोड
    model = MyModel()
    for epoch in range(10):
        train_epoch(model)

trainer = TorchTrainer(
    train_loop_per_worker=train_func,
    scaling_config=ScalingConfig(
        num_workers=8,
        use_gpu=True
    ),
)
result = trainer.fit()

मुख्य क्षमताएं:⁷ - कोड की 2 लाइन बदलकर सिंगल GPU से मल्टी-नोड क्लस्टर तक स्केल करें - ऑटोमैटिक डिस्ट्रिब्यूटेड डेटा लोडिंग और ग्रेडिएंट सिंक्रोनाइजेशन - चेकपॉइंट मैनेजमेंट और फॉल्ट रिकवरी - PyTorch Lightning, Hugging Face Transformers, और DeepSpeed के साथ इंटीग्रेशन

Ray Tune

डिस्ट्रिब्यूटेड हाइपरपैरामीटर ऑप्टिमाइजेशन:

from ray import tune
from ray.tune.schedulers import ASHAScheduler

def training_function(config):
    model = build_model(config["learning_rate"], config["batch_size"])
    for epoch in range(100):
        loss = train_epoch(model)
        tune.report(loss=loss)

analysis = tune.run(
    training_function,
    config={
        "learning_rate": tune.loguniform(1e-4, 1e-1),
        "batch_size": tune.choice([32, 64, 128])
    },
    scheduler=ASHAScheduler(metric="loss", mode="min"),
    num_samples=100,
)

Ray Tune प्रदान करता है: - क्लस्टर में पैरेलल ट्रायल एक्जीक्यूशन - ASHA, Population-Based Training, और अन्य शेड्यूलर के साथ अर्ली स्टॉपिंग - Optuna, HyperOpt, और अन्य ऑप्टिमाइजेशन लाइब्रेरीज के साथ इंटीग्रेशन - चेकपॉइंटिंग और रिजम्प्शन

Ray Serve

ऑटोस्केलिंग के साथ प्रोडक्शन मॉडल सर्विंग:

from ray import serve

@serve.deployment(num_replicas=2, ray_actor_options={"num_gpus": 1})
class LLMDeployment:
    def __init__(self):
        self.model = load_llm()

    async def __call__(self, request):
        prompt = await request.json()
        return self.model.generate(prompt["text"])

serve.run(LLMDeployment.bind())

Ray Serve क्षमताएं:⁸ - रिक्वेस्ट रेट के आधार पर ऑटोस्केलिंग - जीरो-डाउनटाइम डिप्लॉयमेंट - मल्टी-मॉडल कम्पोजीशन और रिक्वेस्ट रूटिंग - LLM सर्विंग के लिए OpenAI-कम्पैटिबल API - प्रीफिक्स-अवेयर रूटिंग के साथ time-to-first-token में 60% कमी⁹

Ray Data

डिस्ट्रिब्यूटेड डेटा लोडिंग और प्रीप्रोसेसिंग:

import ray

ds = ray.data.read_parquet("s3://bucket/data/")
ds = ds.map(preprocess)
ds = ds.filter(lambda x: x["label"] > 0)

# PyTorch DataLoader में कन्वर्ट करें
train_loader = ds.iter_torch_batches(batch_size=32)

Ray Data प्रदान करता है: - बड़े डेटासेट के लिए स्ट्रीमिंग एक्जीक्यूशन - GPU-एक्सेलरेटेड प्रीप्रोसेसिंग - डिस्ट्रिब्यूटेड ट्रेनिंग के लिए Ray Train के साथ इंटीग्रेशन - इमेज, टेक्स्ट, और टेबुलर डेटा के लिए नेटिव सपोर्ट

KubeRay के साथ Kubernetes डिप्लॉयमेंट

प्रोडक्शन Ray डिप्लॉयमेंट आमतौर पर KubeRay, आधिकारिक Kubernetes ऑपरेटर का उपयोग करके Kubernetes पर चलते हैं:¹⁰

KubeRay कंपोनेंट्स

RayCluster CRD: हेड और वर्कर नोड स्पेसिफिकेशन, ऑटोस्केलिंग पॉलिसीज, और रिसोर्स रिक्वायरमेंट सहित क्लस्टर कॉन्फिगरेशन को डिफाइन करता है।

apiVersion: ray.io/v1
kind: RayCluster
metadata:
  name: ml-cluster
spec:
  headGroupSpec:
    rayStartParams:
      dashboard-host: '0.0.0.0'
    template:
      spec:
        containers:
        - name: ray-head
          image: rayproject/ray:2.52.0-py310-gpu
          resources:
            limits:
              nvidia.com/gpu: 1
  workerGroupSpecs:
  - replicas: 4
    minReplicas: 2
    maxReplicas: 10
    groupName: gpu-workers
    rayStartParams: {}
    template:
      spec:
        containers:
        - name: ray-worker
          image: rayproject/ray:2.52.0-py310-gpu
          resources:
            limits:
              nvidia.com/gpu: 1

RayJob CRD: ऑटोमैटिकली प्रोविजन्ड क्लस्टर को जॉब सबमिट करें। KubeRay क्लस्टर बनाता है, जॉब चलाता है, और कम्प्लीशन पर ऑप्शनली क्लस्टर डिलीट करता है।

RayService CRD: जीरो-डाउनटाइम अपग्रेड और हेल्थ चेकिंग के साथ मैनेज्ड Ray Serve डिप्लॉयमेंट।

प्रोडक्शन बेस्ट प्रैक्टिसेज

Container images: रनटाइम पर इंस्टॉल करने के बजाय पब्लिश्ड Docker इमेजेज में डिपेंडेंसीज बेक करें। यह रिप्रोड्यूसिबिलिटी और तेज स्टार्टअप सुनिश्चित करता है।¹¹

Autoscaling: Ray ऑटोस्केलिंग (क्लस्टर के भीतर वर्कर्स स्केलिंग) और Kubernetes ऑटोस्केलिंग (क्लस्टर नोड्स स्केलिंग) दोनों इनेबल करें:

spec:
  enableInTreeAutoscaling: true
  autoscalerOptions:
    upscalingMode: Default
    idleTimeoutSeconds: 60

Storage: चेकपॉइंट्स के लिए पर्सिस्टेंट वॉल्यूम और बड़े डेटासेट के लिए शेयर्ड स्टोरेज का उपयोग करें:

volumes:
- name: shared-storage
  persistentVolumeClaim:
    claimName: ml-data-pvc

Monitoring: ऑब्जर्वेबिलिटी के लिए Prometheus और Grafana के साथ इंटीग्रेट करें:

metadata:
  annotations:
    prometheus.io/scrape: "true"
    prometheus.io/port: "8080"

क्लाउड-स्पेसिफिक डिप्लॉयमेंट

GKE: Ray on GKE add-on ऑटोमैटिक प्रोविजनिंग और Google Cloud सर्विसेज के साथ इंटीग्रेशन के साथ मैनेज्ड Ray क्लस्टर प्रदान करता है।¹²

EKS: नोड स्केलिंग के लिए Cluster Autoscaler या Karpenter के साथ KubeRay डिप्लॉय करें। FSx for Lustre के साथ इंटीग्रेशन हाई-परफॉर्मेंस शेयर्ड स्टोरेज प्रदान करता है।

AKS: Microsoft और Anyscale Azure Portal से एक्सेसिबल फर्स्ट-पार्टी सर्विस के रूप में Anyscale on Azure ऑफर करते हैं।¹³

Anyscale मैनेज्ड Ray

Anyscale, Ray के क्रिएटर्स द्वारा स्थापित कंपनी, मैनेज्ड Ray डिप्लॉयमेंट ऑफर करती है:

Anyscale Platform

Managed clusters: इंफ्रास्ट्रक्चर मैनेजमेंट के बिना ऑटोमैटिक स्केलिंग, फॉल्ट टॉलरेंस, और मॉनिटरिंग के साथ प्रोडक्शन-ग्रेड Ray क्लस्टर।

RayTurbo runtime: प्रोप्राइटरी परफॉर्मेंस इम्प्रूवमेंट जो ओपन-सोर्स Ray बनाम हायर रेजिलिएंस, फास्टर परफॉर्मेंस, और लोअर कॉस्ट डिलीवर करती है।¹⁴

Enterprise features: Role-based access control, audit logging, VPC peering, और compliance certifications।

क्लाउड पार्टनरशिप

CoreWeave: Anyscale BYOC (Bring Your Own Cloud) CoreWeave Kubernetes Service के माध्यम से सीधे CoreWeave कस्टमर अकाउंट्स में डिप्लॉय होता है।¹⁵

Azure: नेटिव इंटीग्रेशन के साथ Azure Portal में फर्स्ट-पार्टी Anyscale सर्विस उपलब्ध।

AWS: Anyscale मौजूदा AWS सर्विसेज के साथ इंटीग्रेशन के साथ AWS पर ऑपरेट करता है।

Anyscale कब उपयोग करें

**Anysc पर विचार करें

[अनुवाद के लिए सामग्री संक्षिप्त की गई]