Ray

Ray is an open-source unified framework that provides a simple, universal API for building and running distributed applications. It enables Python code to seamlessly scale from a laptop to a large cluster, making it a powerful tool for developing scalable AI and machine learning applications.

At its core, Ray offers two fundamental primitives for distributed computation:
- Tasks: These are stateless functions that can be executed asynchronously and in parallel across a cluster. You can think of them as remote function calls, ideal for embarrassingly parallel computations.
- Actors: These are stateful services that can be instantiated and invoked asynchronously. Actors are essentially classes that live in the Ray object store and can maintain internal state, making them suitable for stateful computations, long-running services, or managing distributed resources.

Ray manages the underlying complexities of distributed computing, such as task scheduling, inter-process communication, fault tolerance, and distributed object management. It achieves this by transforming ordinary Python functions into -Ray tasks- and Python classes into -Ray actors- using a simple decorator (`@ray.remote`). This allows developers to write single-node Python code and scale it to a cluster with minimal changes.

Key Components and Libraries built on Ray:
Ray is not just a core framework; it's an ecosystem of libraries designed for specific AI/ML workloads, all leveraging Ray Core's distributed capabilities:
- Ray Core: Provides the fundamental primitives (tasks, actors) for parallelizing Python.
- Ray Data: For distributed data processing (ETL, batch inference, large-scale data loading) with unified APIs across various data sources.
- Ray Train: Simplifies distributed training of machine learning models across various frameworks (e.g., PyTorch, TensorFlow, scikit-learn).
- Ray Tune: A library for hyperparameter optimization and experiment management at scale, capable of running thousands of trials concurrently.
- Ray Serve: For building scalable and high-performance model serving endpoints, enabling dynamic traffic routing and auto-scaling.
- Ray RLlib: A library for scalable reinforcement learning, supporting a wide range of algorithms and environments.

Benefits of Ray:
- Simplicity: Scales Python code with minimal changes using intuitive decorators.
- Performance: Achieves high performance through efficient task scheduling, distributed object management, and optimized inter-node communication.
- Flexibility: Supports a wide range of distributed workloads, from simple embarrassingly parallel tasks to complex, stateful distributed systems.
- Unified API: Provides a consistent and unified way to handle various distributed computing patterns within a single framework.
- Ecosystem: Integrates seamlessly with popular ML frameworks (PyTorch, TensorFlow, scikit-learn) and data processing tools (Pandas, Dask).

Common Use Cases:
- Large-scale data processing and ETL pipelines.
- Distributed machine learning model training and fine-tuning.
- Hyperparameter optimization and model selection.
- Reinforcement learning simulations and agent training.
- Real-time and batch model serving for online inference.
- Distributed simulations and scientific computing.

import ray
import time
import random

 Initialize Ray. This starts a Ray runtime. If not running in a Ray cluster,
 it will start a local Ray instance (a single-node cluster).
 ignore_reinit_error=True is useful for interactive environments like Jupyter notebooks
 where ray.init() might be called multiple times.
ray.init(ignore_reinit_error=True)

print("Ray initialized successfully.")

 --- Example 1: Ray Task (stateless function) ---
 Decorate a regular Python function to make it a Ray remote task.
 When called with .remote(), it executes asynchronously on a Ray worker.
@ray.remote
def calculate_square(x):
     Simulate some computational work
    time.sleep(0.1)
    return x - x

print("\n--- Running Ray Tasks ---")
 Launch multiple tasks in parallel
task_refs = []
for i in range(10):
     Call the remote function. It immediately returns an ObjectRef (a future).
     The actual computation happens in the background.
    ref = calculate_square.remote(i)
    task_refs.append(ref)

 Retrieve the actual results from the ObjectRefs.
 ray.get() blocks until the results for all specified ObjectRefs are ready.
results = ray.get(task_refs)
print(f"Results from square tasks: {results}")

 --- Example 2: Ray Actor (stateful class) ---
 Decorate a regular Python class to make it a Ray remote actor.
 An actor is a stateful service that can be instantiated and invoked asynchronously.
@ray.remote
class Accumulator:
    def __init__(self, initial_value=0):
        self.value = initial_value

    def add_value(self, amount):
         Simulate some work
        time.sleep(0.05)
        self.value += amount
        return self.value  Return current state after addition

    def get_current_value(self):
        return self.value

print("\n--- Running Ray Actor ---")
 Instantiate an actor. This creates an actor handle.
 The actor itself runs on a Ray worker.
my_accumulator = Accumulator.remote(initial_value=100)

 Call methods on the actor handle. These calls are also asynchronous and return ObjectRefs.
add_refs = []
for i in range(5):
     Each call modifies the internal state of the 'my_accumulator' actor.
    ref = my_accumulator.add_value.remote(i + 1)
    add_refs.append(ref)

 Get the results of the intermediate additions
intermediate_values = ray.get(add_refs)
print(f"Values reported after each add operation: {intermediate_values}")

 Get the final value from the actor's state
final_value = ray.get(my_accumulator.get_current_value.remote())
print(f"Final value stored in the actor: {final_value}")

 --- Shut down Ray (optional) ---
 This will terminate the Ray runtime. It's good practice for clean exit
 but often not strictly necessary as scripts terminate.
ray.shutdown()
print("\nRay shutdown.")