Communitygithub.com

G1Joshi/Agent-Skills

Experte für verteiltes Ray-Computing mit Fokus auf Ray Core (Aktoren, Tasks), Ray Train, Ray Tune und Ray Serve. Verwenden Sie diese Fähigkeit, um Python-Berechnungen und ML-Training auf Multi-Node-Cluster zu skalieren.

Was ist Agent-Skills?

Diese KI-Agenten-Fertigkeit bietet umfassende Unterstützung für das verteilte Ray-Computing-Framework, das in der KI-Infrastruktur weit verbreitet ist (z. B. für das Training von ChatGPT). Sie deckt die Kernkomponenten ab: Ray Core für verteilte Tasks und zustandsbehaftete Aktoren, Ray Train für Multi-Node-ML-Training mit PyTorch und XGBoost, Ray Serve für die serverseitige Modellbereitstellung mit dynamischer Skalierung und Ray Tune für Hyperparameter-Optimierung. Die Fertigkeit eignet sich ideal für Entwickler, die Python-Workloads mit minimalem Codeaufwand von einem einzelnen Laptop auf einen gesamten Cluster skalieren möchten. Sie enthält Best Practices für die Ressourcenplanung, die Vermeidung von Anti-Patterns (z. B. `ray.get()` in Tasks oder zu viele Micro-Tasks) und die Fehlerbehebung bei häufigen Problemen wie Speicherüberläufen oder nicht erfüllbaren Ressourcenanfragen. Die Fertigkeit ist plattformunabhängig und funktioniert mit jeder Umgebung, die Ray unterstützt, einschließlich lokaler Cluster, Kubernetes und Cloud-Anbieter.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/G1Joshi/Agent-Skills/tree/HEAD/skills/ai-ml/ray

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

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

FehlerUrsacheLösung
RaySystemError: Object store fullTasks 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 unexpectedlyWorker-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 requestEs wurden mehr CPUs/GPUs angefordert (num_gpus=2) als im Cluster verfügbar.Überprüfen Sie die verfügbaren Ressourcen über ray.cluster_resources().

Referenzen

Individual skills in this repo

This repo contains 11 individual skills — each has its own dedicated page.

G1Joshi/Agent-Skills

Expert Dask distributed computing assistance covering Dask DataFrames, Arrays, Futures, and cluster scaling. Use when analyzing datasets too large for pandas on a single machine or multi-node cluster.

G1Joshi/Agent-Skills

Expert dbt (data build tool) assistance covering SQL modeling, Jinja macros, tests, documentation, and semantic layer. Use when building analytics engineering pipelines on BigQuery, Snowflake, or PostgreSQL.

G1Joshi/Agent-Skills

Expert JAX assistance covering Autograd, XLA compilation (`jit`), vectorization (`vmap`), and parallelization (`pmap`). Use when building high-performance numerical computing and cutting-edge deep learning research.

G1Joshi/Agent-Skills

Expert Git version control assistance covering branching, interactive rebase, cherry-pick, submodules, worktrees, and conflict resolution. Use when managing source code history and collaboration workflows.

G1Joshi/Agent-Skills

Expert K9s CLI assistance covering terminal Kubernetes cluster navigation, real-time log streaming, port forwarding, and pod debugging. Use when managing and troubleshooting Kubernetes clusters with speed.

G1Joshi/Agent-Skills

Expert SWC assistance covering high-performance Rust-based JavaScript/TypeScript compilation, .swcrc configuration, Jest testing via @swc/jest, and minification. Use when replacing Babel with SWC for faster builds, accelerating test execution, or compiling modern ECMAScript features.

G1Joshi/Agent-Skills

Expert Tig assistance covering text-mode interface for Git, interactive staging, commit graph visualization, diff exploration, and blame navigation. Use when navigating Git commit history in the terminal, staging hunks interactively, browsing file changes, or reviewing revisions.

G1Joshi/Agent-Skills

Expert Vim assistance covering modal editing, .vimrc configuration, registers, macros, search/replace, and plugin management via vim-plug. Use when editing text efficiently in terminal environments, writing Vimscript, recording macros, or configuring core Vim settings.

G1Joshi/Agent-Skills

Expert Zed editor assistance covering high-performance Rust-based text editing, multi-buffer editing, language server protocols (LSP), and AI assistant integrations. Use when configuring Zed settings.json, setting up language extensions, collaborating in real-time channels, or optimizing editor startup speed.

G1Joshi/Agent-Skills

Expert Zsh assistance covering shell customization, Oh My Zsh plugins, Zinit plugin manager, prompt engineering (Starship/Powerlevel10k), and shell scripting. Use when configuring .zshrc, writing Zsh automation scripts, optimizing shell startup time, or configuring tab-completion.

G1Joshi/Agent-Skills

Expert [skill-name] assistance covering [feature 1], [feature 2], and [feature 3]. Use when [working with X], [debugging Y], or [implementing Z].

Verwandte Skills