Ray
Ray ist die Compute-Schicht für KI. Es treibt das Training von ChatGPT und Workloads in massivem Maßstab an. Version 3.0 (2025) verbessert die Effizienz und fügt einen MCP-Server für Agenten hinzu.
Wann zu verwenden
- Verteilte Python-Anwendungen: Nahtloses Skalieren rechenintensiver Python-Aufgaben von einem einzelnen Laptop auf große Cloud-Cluster.
- Verteiltes ML-Training mit Ray Train: Orchestrierung von Multi-Node-PyTorch-, XGBoost- und LightGBM-Trainingsaufträgen.
- Produktionsbereitstellung von Modellen mit Ray Serve: Bereitstellung von LLMs und Microservice-Pipelines mit mehreren Modellen und dynamischer automatischer Skalierung.
- Hyperparameteroptimierung mit Ray Tune: Durchführen von Bayesian-, Optuna- und populationsbasierten Trainingsdurchläufen über Hunderte von Workern.
Schnellstart
import ray
ray.init()
# Entfernter verteilter Task
@ray.remote
def square(x):
return x * x
# Tasks parallel im Cluster starten
futures = [square.remote(i) for i in range(10)]
results = ray.get(futures)
print("Berechnete Quadrate:", results)
Kernkonzepte
#Verteilte Tasks & Zustandsbehaftete Aktoren
Skalieren von Funktionen und Klassen über Cluster-Worker:
import ray
import time
# Lokal initialisieren oder mit entferntem Ray-Cluster verbinden
ray.init(ignore_reinit_error=True)
# 1. Zustandslose entfernte Funktion (Verteilter Task)
@ray.remote
def process_data_chunk(chunk_id: int) -> dict:
time.sleep(0.5) # Simuliert CPU-/IO-gebundene Berechnung
return {"chunk_id": chunk_id, "processed_items": 1000 * chunk_id}
# Tasks gleichzeitig im Cluster starten
futures = [process_data_chunk.remote(i) for i in range(8)]
results = ray.get(futures) # Ergebnisse sammeln
print("Verarbeitete Chunks:", results)
# 2. Zustandsbehaftete entfernte Klasse (Verteilter Aktor)
@ray.remote
class GlobalCounter:
def __init__(self):
self.count = 0
def increment(self) -> int:
self.count += 1
return self.count
counter_actor = GlobalCounter.remote()
inc_futures = [counter_actor.increment.remote() for _ in range(5)]
print("Aktor-Endzählerstand:", ray.get(inc_futures[-1]))
#Produktionsbereitstellung von Modellen mit Ray Serve
Bereitstellung skalierbarer REST-Endpunkte mit dynamischem Request-Batching:
from ray import serve
import torch
from transformers import pipeline
@serve.deployment(num_replicas=2, ray_actor_options={"num_cpus": 1, "num_gpus": 0})
class SentimentClassifier:
def __init__(self):
self.classifier = pipeline("sentiment-analysis")
async def __call__(self, request):
json_data = await request.json()
text = json_data.get("text", "")
return self.classifier(text)
app = SentimentClassifier.bind()
# serve.run(app)
#Verteilte Hyperparameteroptimierung mit Ray Tune
Durchführen paralleler Hyperparameter-Durchläufe:
from ray import tune
def training_function(config):
# Simuliertes Modelltraining
for step in range(10):
intermediate_score = config["alpha"] * step + config["beta"]
tune.report(loss=1.0 / (intermediate_score + 0.1))
search_space = {
"alpha": tune.uniform(0.1, 1.0),
"beta": tune.choice([1, 2, 5])
}
tuner = tune.Tuner(
training_function,
param_space=search_space,
tune_config=tune.TuneConfig(num_samples=10, metric="loss", mode="min")
)
results = tuner.fit()
print("Beste Hyperparameter:", results.get_best_result().config)
Häufige Muster
Zustandsbehaftete verteilte Aktoren für die Modellbereitstellung
Problem: Erneutes Laden großer Modellgewichte in den Speicher bei jedem Funktionsaufruf.
Lösung: Ray-Aktoren verwenden, um den In-Memory-Zustand über Anfragen hinweg zu halten:
@ray.remote(num_gpus=1)
class ModelServer:
def __init__(self):
# Gewichte einmal in den GPU-VRAM laden
self.model = load_large_model()
def predict(self, sample):
return self.model(sample)
server_actor = ModelServer.remote()
prediction = ray.get(server_actor.predict.remote(sample_data))
Best Practices (2026)
- Tun: Überprüfen Sie das Ray-Dashboard (Port 8265), um die CPU-/GPU-Auslastung der Knoten, die Aktorplatzierung und den Objektspeicher zu überwachen.
- Tun: Übergeben Sie große schreibgeschützte Datensätze über den Ray-Plasma-Objektspeicher (
ray.put(data)), um wiederholte Serialisierungen zu vermeiden. - Tun: Geben Sie Ressourcenanforderungen explizit in Dekorateuren an (
@ray.remote(num_cpus=2, num_gpus=1)). - Tun: Verwenden Sie Ray Serve für produktive Multi-Modell-Microservices mit integriertem automatischen Batching.
- Nicht: Rufen Sie
ray.get()innerhalb von entfernten Tasks auf; übergeben Sie ObjectRefs direkt an andere entfernte Tasks, um die Pipelining-Funktion zu erhalten. - Nicht: Erstellen Sie Millionen von Mikro-Tasks; bündeln Sie feinkörnige Tasks, um den Scheduler-Overhead zu minimieren.
- Nicht: Übergeben Sie große zustandsbehaftete Objekte (wie Datenbankverbindungen oder geöffnete Dateien) in entfernten Argumenten.
Fehlerbehebung
| Fehler | Ursache | Lösung |
|---|---|---|
RaySystemError: Object store full | Tasks produzieren mehr Daten, als der zugewiesene Shared-Memory-Plasma-Speicher fassen kann. | Verwenden Sie ray.get(), um Ergebnisse zu konsumieren, oder speichern Sie große Arrays im Festplattenspeicher. |
Actor died unexpectedly | Worker-Prozess aufgrund einer nicht behandelten Ausnahme oder OOM abgestürzt. | Überprüfen Sie die Protokolle im Ray-Dashboard (http://localhost:8265) und erhöhen Sie den Worker-RAM. |
Task failed to schedule: Unsatisfiable resource request | Es wurden mehr CPUs/GPUs angefordert (num_gpus=2) als im Cluster verfügbar. | Überprüfen Sie die verfügbaren Ressourcen über ray.cluster_resources(). |