Przejdź do treści
Biblioteka skilli
AI i agenci · Budowanie i kod

ray

/ray

Wspiera pracę z Ray: aktory, zadania, Ray Train, Tune i Serve przy skalowaniu obliczeń Pythona i trenowania ML na klastrach wielowęzłowych.

Repozytorium
Agent-Skills ↗
Licencja
MIT
Ostatnia zmiana repozytorium
01.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
2
Przestarzałość

Brak sygnałów. Repozytorium zmienione 01.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Wspiera pracę z Ray: aktory, zadania, Ray Train, Tune i Serve przy skalowaniu obliczeń Pythona i trenowania ML na klastrach wielowęzłowych.

Oryginalny opis (EN)

Expert Ray distributed computing assistance covering Ray Core (actors, tasks), Ray Train, Ray Tune, and Ray Serve. Use when scaling Python compute and ML training across multi-node clusters.

Jak działa

  1. When to Use
  2. Quick Start
  3. Core Concepts
  4. Common Patterns
  5. Best Practices
  6. Troubleshooting
  7. References
Sekcje z nagłówków SKILL.md, w oryginale · 169 linii, 641 słów
Podgląd SKILL.md
---
name: ray
description: Expert Ray distributed computing assistance covering Ray Core (actors, tasks), Ray Train, Ray Tune, and Ray Serve. Use when scaling Python compute and ML training across multi-node clusters.
---

# Ray

Ray is an open-source unified compute framework that makes it easy to scale AI and Python workloads across distributed clusters with Ray Train, Ray Data, and Ray Serve.

## When to Use

- **Distributed Python Applications**: Scaling compute-heavy Python tasks seamlessly from a single laptop to large cloud clusters.
- **Distributed ML Training with Ray Train**: Orchestrating multi-node PyTorch, XGBoost, and LightGBM training jobs.
- **Production Model Serving with Ray Serve**: Serving LLMs and multi-model microservice pipelines with dynamic autoscaling.
- **Hyperparameter Optimization with Ray Tune**: Running Bayesian, Optuna, and population-based training sweeps across hundreds of workers.

## Quick Start

```python
import ray

ray.init()

# Remote distributed task
@ray.remote
def square(x):
    return x * x

# Launch tasks in parallel across cluster
futures = [square.remote(i) for i in range(10)]
results = ray.get(futures)
print("Computed squares:", results)
```

## Core Concepts

### Distributed Tasks & Stateful Actors

Scaling functions and classes across cluster workers:

```python
import ray
import time

# Initialize local or connect to remote Ray cluster
ray.init(ignore_reinit_error=True)

# 1. Stateless Remote Function (Distributed Task)
@ray.remote
def process_data_chunk(chunk_id: int) -> dict:
    time.sleep(0.5) # Simulating CPU/IO bound computation
    return {"chunk_id": chunk_id, "processed_items": 1000 * chunk_id}

# Launch tasks concurrently across cluster
futures = [process_data_chunk.remote(i) for i in range(8)]
results = ray.get(futures) # Gather results
print("Processed Chunks:", results)

# 2. Stateful Remote Class (Distributed Actor)
@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("Final actor count:", ray.get(inc_futures[-1]))
```

### Production Model Serving with Ray Serve

Deploying scalable REST endpoints with dynamic request batching:

```python
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)
```

### Distributed Hyperparameter Tuning with Ray Tune

Running parallel hyperparameter trials:

```python
from ray import tune

def training_function(config):
    # Simulated model training
    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("Best hyperparameters:", results.get_best_result().config)
```

## Common Patterns

### Stateful Distributed Actors for Model Serving

**Problem**: Re-loading large model weights into memory on every function invocation.

**Solution**:
Use Ray Actors to hold in-memory state across requests:

```python
@ray.remote(num_gpus=1)
class ModelServer:
    def __init__(self):
        # Load weights once into GPU VRAM
        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

**Do**:

- Check the Ray Dashboard (port 8265) to monitor node CPU/GPU utilization, actor placement, and object store memory.
- Pass large read-only datasets via the Ray plasma object store (`ray.put(data)`) to prevent repetitive serializations.
- Specify resource requirements explicitly in decorators (`@ray.remote(num_cpus=2, num_gpus=1)`).
- Use Ray Serve for production multi-model microservices with built-in auto-batching.

**Don't**:

- Call `ray.get()` inside remote tasks; pass ObjectRefs directly to other remote tasks to preserve pipelining.
- Create millions of micro-tasks; batch fine-grained tasks together to minimize scheduler overhead.
- Pass large stateful objects (like database connections or open files) inside remote arguments.

## Troubleshooting

| Error                                                     | Cause                                                                | Solution                                                                       |
| :-------------------------------------------------------- | :------------------------------------------------------------------- | :----------------------------------------------------------------------------- |
| `RaySystemError: Object store full`                       | Tasks producing more data than allocated shared memory plasma store. | Use `ray.get()` to consume results, or store large arrays in disk storage.     |
| `Actor died unexpectedly`                                 | Worker process crashed due to unhandled exception or OOM.            | Check logs in Ray dashboard (`http://localhost:8265`) and increase worker RAM. |
| `Task failed to schedule: Unsatisfiable resource request` | Requested more CPUs/GPUs (`num_gpus=2`) than available on cluster.   | Verify available resources via `ray.cluster_resources()`.                      |

## References

- [Ray Documentation](https://docs.ray.io/)

Wersje

RepozytoriumWynikLicencja
Ta strona · G1Joshi/Agent-Skills100MIT
spatie/ray-skills100MIT
pproenca/dot-skills100MIT

Migawka bazy z 13.11.2026 · wersja paczki 4b60884cc859 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 1 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100ray-distributed-ml-orchestration
    Prowadzi przez użycie Ray (Core, Train, Tune, Serve) z operatorem KubeRay do rozproszonego trenowania ML, strojenia hiperparametrów i serwowania modeli.
  • 100ray-train
    Orkiestruje rozproszone trenowanie PyTorch, TensorFlow i HuggingFace na klastrach, z Ray Tune, odpornością na awarie i elastycznym skalowaniem.
  • 95ray-train
    Organizuje rozproszone trenowanie modeli w PyTorch, TensorFlow i HuggingFace na wielu maszynach, z dostrajaniem Ray Tune.
  • 100ray-llm
    Wdraża obciążenia LLM na Ray 2.57: serwowanie zgodne z OpenAI przez ray.serve.llm z vLLM oraz wsadowe wnioskowanie przez ray.data.llm, z poprawkami przestarzałych wzorców.
  • 95domino-distributed-computing
    Konfiguruje klastry Spark, Ray i Dask w Domino do przetwarzania dużych zbiorów i równoległego trenowania modeli.
  • 95debugging-output-and-previewing-html-using-ray
    Wysyła dane, komunikaty debugowania i diagramy HTML do aplikacji Ray na komputerze, gdy trzeba je zwizualizować.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.