Ray基本概念

Ray 是一个开源的分布式计算框架，其核心目标是 简化分布式计算的复杂性和提高开发效率，使开发者能够轻松构建和扩展高性能的分布式应用程序。

Ray-Core

1. Tasks

定义

• Task 是一个无状态的函数，可以在集群中的任意节点上执行。
• Task 是 Ray 中最基本的并行执行单元。

特点

• 无状态：Task 不保存任何状态，每次执行都是独立的。
• 并行执行：多个 Task 可以并行执行，Ray 会自动调度它们到不同的节点。
• 返回值：Task 的返回值是一个 Object，可以通过 ray.get() 获取。

示例

import ray

ray.init()

@ray.remote
def my_task(x):
    return x * 2

# 提交 Task
future = my_task.remote(10)
# 获取结果
result = ray.get(future)
print(result)  # 输出 20

2. Actors

定义

• Actor 是一个有状态的计算单元，类似于面向对象编程中的对象。
• Actor 可以保存内部状态，并且只能在一个节点上执行。

特点

• 有状态：Actor 可以保存和修改内部状态。
• 单线程执行：Actor 的方法调用是串行执行的，保证了状态的一致性。
• 长期运行：Actor 可以长期运行，直到显式终止。

示例

import ray

ray.init()

@ray.remote
class Counter:
    def __init__(self):
        self.value = 0

    def increment(self):
        self.value += 1
        return self.value

# 创建 Actor
counter = Counter.remote()
# 调用 Actor 方法
future = counter.increment.remote()
# 获取结果
result = ray.get(future)
print(result)  # 输出 1

3. Objects

定义

• Object 是 Ray 中数据的抽象表示，可以是 Task 或 Actor 方法的返回值。
• Object 是分布式存储中的不可变数据。

特点

• 不可变：一旦创建，Object 的内容不能被修改。
• 分布式存储：Object 存储在 Ray 的分布式对象存储中，可以在集群中的任意节点访问。
• 引用计数：Ray 会自动管理 Object 的生命周期，当不再被引用时会被释放。

示例

import ray

ray.init()

@ray.remote
def my_task(x):
    return x * 2

# 提交 Task，返回一个 Object
future = my_task.remote(10)
# 获取 Object 的值
result = ray.get(future)
print(result)  # 输出 20

4. Placement Groups

定义

• Placement Group 是一种资源分配策略，用于控制 Task 或 Actor 在集群中的位置。
• 可以将一组资源绑定在一起，确保 Task 或 Actor 在指定的资源上运行。

特点

• 资源绑定：可以将 CPU、GPU 等资源绑定在一起，形成一个资源组。
• 调度控制：可以控制 Task 或 Actor 在资源组中的位置，优化性能。
• 弹性扩展：支持动态调整资源组的规模。

示例

import ray

ray.init()

# 创建一个 Placement Group，包含 2 个 CPU 和 1 个 GPU
pg = ray.util.placement_group([{"CPU": 2}, {"GPU": 1}])
ray.get(pg.ready())

# 在 Placement Group 中运行 Task
@ray.remote
def my_task():
    return "Task running on Placement Group"

# 指定 Placement Group
future = my_task.options(placement_group=pg).remote()
# 获取结果
result = ray.get(future)
print(result)

5. Environment Dependencies

定义

• Environment Dependencies 是指 Task 或 Actor 运行所需的依赖项，如 Python 包、环境变量、文件等。
• Ray 提供了机制来管理这些依赖项，确保 Task 或 Actor 在正确的环境中运行。

特点

• 依赖管理：可以指定 Python 包、环境变量、文件等依赖项。
• 环境隔离：确保 Task 或 Actor 在独立的环境中运行，避免冲突。
• 动态加载：支持动态加载依赖项，适合复杂的分布式应用。

示例

import ray

ray.init()

# 指定 Python 包依赖
@ray.remote(runtime_env={"pip": ["numpy"]})
def my_task():
    import numpy as np
    return np.array([1, 2, 3])

# 提交 Task
future = my_task.remote()
# 获取结果
result = ray.get(future)
print(result)  # 输出 [1 2 3]

概念	定义	特点	适用场景
Tasks	无状态的函数	并行执行、无状态、返回值是 Object	并行计算、无状态任务
Actors	有状态的计算单元	有状态、单线程执行、长期运行	有状态任务、状态管理
Objects	不可变的数据	分布式存储、引用计数	数据共享、任务间通信
Placement Groups	资源分配策略	资源绑定、调度控制、弹性扩展	优化资源分配、控制任务位置
Environment Dependencies	Task 或 Actor 运行所需的依赖项	依赖管理、环境隔离、动态加载	复杂分布式应用、环境管理

Ray-Data

1. Datasets

定义

• Dataset 是 Ray 中用于表示分布式数据的抽象。
• 它是一个分区的、不可变的、分布式数据集，类似于 Spark 的 RDD 或 Pandas 的 DataFrame。

特点

• 分布式存储：数据分布在集群的多个节点上。
• 不可变性：一旦创建，Dataset 的内容不能被修改。
• 分区：Dataset 被划分为多个 Blocks，每个 Block 是一个独立的数据单元。

示例

import ray

ray.init()

# 从列表创建 Dataset
dataset = ray.data.from_items([1, 2, 3, 4, 5])
# 显示数据
print(dataset.take(5))  # 输出 [1, 2, 3, 4, 5]

2. Blocks

定义

• Block 是 Dataset 的基本组成单元，表示一个分区的数据。
• 每个 Block 是一个独立的数据块，可以是一个列表、Pandas DataFrame 或其他数据结构。

特点

• 分区：Dataset 被划分为多个 Blocks，每个 Block 可以在不同的节点上处理。
• 并行处理：Ray 可以并行处理多个 Blocks，提高计算效率。

示例

# 获取 Dataset 的 Blocks
blocks = dataset.get_internal_block_refs()
# 处理每个 Block
for block in blocks:
    print(ray.get(block))

3. Operators

定义

• Operator 是对 Dataset 进行转换或操作的高阶函数。
• 类似于 Spark 的 Transformation 或 Pandas 的 DataFrame 操作。

常用 Operators

• map：对每个元素应用函数。
• filter：过滤满足条件的元素。
• flat_map：将每个元素映射为多个元素。
• groupby：按某个字段分组。
• join：连接两个 Dataset。

示例

# 对 Dataset 进行 map 操作
mapped_dataset = dataset.map(lambda x: x * 2)
# 显示结果
print(mapped_dataset.take(5))  # 输出 [2, 4, 6, 8, 10]

4. Plans

定义

• Plan 是 Ray Data 的执行计划，描述了如何对 Dataset 进行操作。
• 它是由多个 Operators 组成的逻辑执行图。

特点

• 惰性执行：Plan 是惰性执行的，只有在需要结果时才会触发计算。
• 优化：Ray 会自动优化 Plan，减少数据移动和计算开销。

示例

# 创建一个 Plan
plan = dataset.map(lambda x: x * 2).filter(lambda x: x > 5)
# 执行 Plan
result = plan.take(5)
print(result)  # 输出 [6, 8, 10]

5. Streaming Execution Model

定义

• Streaming Execution Model 是 Ray Data 的执行模型，支持流式处理大规模数据。
• 数据以流的形式逐步处理，而不是一次性加载到内存中。

特点

• 增量处理：数据可以分批次处理，适合大规模数据集。
• 低内存占用：不需要将整个数据集加载到内存中。
• 实时性：支持实时数据处理。

示例

# 创建流式 Dataset
streaming_dataset = ray.data.from_items(range(1000000), parallelism=10)
# 流式处理
result = streaming_dataset.map(lambda x: x * 2).take(10)
print(result)  # 输出 [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

总结

概念	定义	特点	适用场景
Datasets	分布式数据集	分区、不可变、分布式存储	大规模数据处理
Blocks	Dataset 的基本组成单元	分区、并行处理	数据分区和并行计算
Operators	对 Dataset 进行转换或操作的高阶函数	支持 map、filter、groupby 等操作	数据转换和操作
Plans	执行计划，描述如何对 Dataset 进行操作	惰性执行、自动优化	数据处理的逻辑描述
Streaming Execution	流式执行模型，支持增量处理大规模数据	增量处理、低内存占用、实时性	大规模数据流处理

Ray Tune

主要用途

• 超参数优化：
  • Tune 是一个超参数调优库，专注于自动化地搜索和优化模型的超参数。
  • 支持多种优化算法，如随机搜索、网格搜索、贝叶斯优化、HyperBand 等。
• 实验管理：
  • 可以并行运行多个实验，并自动管理资源分配。
  • 提供可视化工具（如 TensorBoard 集成）来监控实验结果。
• 适用场景：
  • 适用于需要调优超参数的机器学习或深度学习任务。
  • 例如：调优神经网络的超参数（学习率、层数、激活函数等）。

核心功能

• 支持多种优化算法。
• 支持分布式超参数搜索。
• 提供实验结果的保存和可视化。

示例代码

from ray import tune

def trainable(config):
    # 训练逻辑
    for i in range(10):
        score = config["lr"] * i
        tune.report(score=score)

analysis = tune.run(
    trainable,
    config={"lr": tune.grid_search([0.1, 0.01, 0.001])},
    num_samples=3
)

Ray Train

主要用途

• 分布式训练：
  • Train 是一个分布式训练库，专注于在集群上高效地训练机器学习或深度学习模型。
  • 支持数据并行和模型并行。
• 简化分布式训练：
  • 提供了高级 API，简化了分布式训练的复杂性。
  • 支持与 PyTorch、TensorFlow 等框架集成。
• 适用场景：
  • 适用于需要分布式训练的大规模机器学习或深度学习任务。
  • 例如：训练大规模神经网络或处理大数据集。

核心功能

• 支持数据并行和模型并行。
• 提供容错和弹性训练功能。
• 支持与 Tune 集成，用于超参数优化。

示例代码

from ray import train
from ray.train import Trainer

def train_func(config):
    # 训练逻辑
    for i in range(10):
        print(f"Epoch {i}")

trainer = Trainer(backend="torch", num_workers=2)
trainer.start()
trainer.run(train_func)
trainer.shutdown()

Ray Tune vs Ray Train

特性	Ray Tune	Ray Train
主要用途	超参数优化	分布式训练
核心功能	超参数搜索、实验管理	数据并行、模型并行
适用场景	调优模型超参数	大规模模型训练
与框架集成	支持多种框架（PyTorch、TensorFlow 等）	支持 PyTorch、TensorFlow 等
分布式支持	支持分布式超参数搜索	支持分布式训练
输出结果	最佳超参数组合	训练好的模型

协同使用

Tune 和 Train 可以结合使用：

• 使用 Train 进行分布式训练。
• 使用 Tune 优化训练过程中的超参数。
• 例如，在 Tune 中调用 Train 进行分布式训练，并同时优化超参数。

示例代码

from ray import tune
from ray.train import Trainer

def train_func(config):
    # 训练逻辑
    for i in range(10):
        score = config["lr"] * i
        tune.report(score=score)

def tune_train(config):
    trainer = Trainer(backend="torch", num_workers=2)
    trainer.start()
    trainer.run(train_func, config)
    trainer.shutdown()

analysis = tune.run(
    tune_train,
    config={"lr": tune.grid_search([0.1, 0.01, 0.001])},
    num_samples=3
)