Ray 简介 #
为什么需要分布式计算？ #
在了解 Ray 之前，我们需要先理解为什么分布式计算如此重要。
计算需求的增长 #
text
┌─────────────────────────────────────────────────────────────┐
│ 计算需求演进 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 数据规模： │
│ ├── 2010: GB 级别 │
│ ├── 2015: TB 级别 │
│ ├── 2020: PB 级别 │
│ └── 现在: EB 级别 │
│ │
│ 模型规模： │
│ ├── 2012: AlexNet (60M 参数) │
│ ├── 2018: BERT (340M 参数) │
│ ├── 2020: GPT-3 (175B 参数) │
│ └── 现在: 万亿参数模型 │
│ │
│ 计算需求： │
│ ├── 训练时间：从小时到周 │
│ ├── 数据处理：从批处理到实时 │
│ └── 服务延迟：从秒级到毫秒级 │
│ │
└─────────────────────────────────────────────────────────────┘
传统分布式计算的挑战 #
text
挑战 1：编程复杂
────────────────────────
- 需要处理进程间通信
- 需要管理分布式状态
- 需要处理故障恢复
- 需要考虑数据一致性
挑战 2：性能瓶颈
────────────────────────
- 通信开销大
- 负载不均衡
- 资源利用率低
- 扩展性差
挑战 3：运维困难
────────────────────────
- 集群管理复杂
- 监控调试困难
- 版本兼容问题
- 成本控制难
挑战 4：生态割裂
────────────────────────
- 不同框架 API 不统一
- 数据格式不兼容
- 工具链分散
- 学习成本高
什么是 Ray？ #
Ray 是由 UC Berkeley RISELab 开发的开源分布式计算框架，旨在简化分布式应用的开发。它提供了一个简单而强大的编程模型，让开发者能够轻松地将 Python 应用从单机扩展到集群。
核心定位 #
text
┌─────────────────────────────────────────────────────────────┐
│ Ray 定位 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ 简单易用 │ │ 高性能 │ │ 统一框架 │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ 弹性伸缩 │ │ 容错机制 │ │ 丰富生态 │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
Ray 的设计理念 #
text
1. 简洁性
├── 最小化 API：@ray.remote 装饰器
├── Python 原生体验
└── 渐进式学习曲线
2. 通用性
├── 支持任意 Python 函数
├── 支持有状态计算
└── 支持多种计算模式
3. 高性能
├── 底层 C++ 实现
├── 零拷贝序列化
└── 高效调度器
4. 可扩展性
├── 从单机到集群
├── 支持数千节点
└── 弹性伸缩
Ray 的历史 #
发展历程 #
text
2017年 ─── Ray 项目启动
│
│ UC Berkeley RISELab
│ 目标：简化分布式 AI 应用
│
2018年 ─── Ray 0.5 发布
│
│ 开源社区快速增长
│ 引入 Actors 概念
│
2019年 ─── Ray 1.0 发布
│
│ API 稳定
│ Ray Tune 成熟
│
2020年 ─── Ray AI Libraries
│
│ Ray Data 发布
│ Ray Train 发布
│ Ray Serve 发布
│
2021年 ─── Anyscale 成立
│
│ 商业化支持
│ 企业级功能
│
2022年 ─── Ray 2.0 发布
│
│ 架构优化
│ 性能大幅提升
│
至今 ─── 广泛应用
│
│ 数千家企业使用
│ 活跃的开源社区
版本演进 #
| 版本 | 发布时间 | 主要特性 |
|---|---|---|
| 0.1 | 2017 | 基础 Tasks 支持 |
| 0.5 | 2018 | Actors、对象存储 |
| 1.0 | 2019 | API 稳定、Ray Tune |
| 1.5 | 2020 | Ray Data、Ray Train |
| 2.0 | 2022 | 架构重构、性能优化 |
| 2.5 | 2023 | 增强的 AI 库 |
| 2.9 | 2024 | 更好的 GPU 支持 |
Ray 核心概念 #
1. Tasks（任务） #
Tasks 是 Ray 中最基本的分布式计算单元，是无状态的远程函数。
text
┌─────────────────────────────────────────────────────────────┐
│ Ray Tasks │
├─────────────────────────────────────────────────────────────┤
│ │
│ 特点： │
│ ├── 无状态：每次调用独立 │
│ ├── 并行执行：自动调度到可用节点 │
│ ├── 异步调用：立即返回 ObjectRef │
│ └── 自动容错：失败自动重试 │
│ │
│ 使用场景： │
│ ├── 数据预处理 │
│ ├── 模型推理 │
│ ├── 并行计算 │
│ └── 批处理任务 │
│ │
└─────────────────────────────────────────────────────────────┘
python
import ray
ray.init()
@ray.remote
def process_data(x):
return x ** 2
result_refs = [process_data.remote(i) for i in range(10)]
results = ray.get(result_refs)
2. Actors（角色） #
Actors 是有状态的分布式服务，可以跨调用保持状态。
text
┌─────────────────────────────────────────────────────────────┐
│ Ray Actors │
├─────────────────────────────────────────────────────────────┤
│ │
│ 特点： │
│ ├── 有状态：实例变量持久化 │
│ ├── 单线程：方法调用顺序执行 │
│ ├── 生命周期：可创建和销毁 │
│ └── 资源绑定：可指定资源需求 │
│ │
│ 使用场景： │
│ ├── 模型服务 │
│ ├── 数据库连接池 │
│ ├── 状态机 │
│ └── 资源管理器 │
│ │
└─────────────────────────────────────────────────────────────┘
python
@ray.remote
class Counter:
def __init__(self):
self.value = 0
def increment(self):
self.value += 1
return self.value
counter = Counter.remote()
ray.get(counter.increment.remote())
3. Objects（对象） #
Objects 是 Ray 中的分布式对象，存储在共享内存中。
text
┌─────────────────────────────────────────────────────────────┐
│ Ray Objects │
├─────────────────────────────────────────────────────────────┤
│ │
│ 特点： │
│ ├── 不可变：创建后不能修改 │
│ ├── 共享内存：节点内高效共享 │
│ ├── 自动序列化：支持多种格式 │
│ └── 引用计数：自动内存管理 │
│ │
│ ObjectRef： │
│ ├── 对象引用，类似 Future │
│ ├── 可传递给其他 Tasks/Actors │
│ └── ray.get() 获取实际值 │
│ │
└─────────────────────────────────────────────────────────────┘
python
@ray.remote
def compute():
return [1, 2, 3, 4, 5]
ref = compute.remote()
value = ray.get(ref)
Ray 架构 #
整体架构 #
text
┌─────────────────────────────────────────────────────────────┐
│ Ray 架构图 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 应用层 │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │Ray Data │ │Ray Train│ │Ray Serve│ │ │
│ │ └─────────┘ └─────────┘ └─────────┘ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Ray Core │ │
│ │ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ Driver │ │ Worker │ │ │
│ │ │ 进程 │ │ 进程 │ │ │
│ │ └─────────────┘ └─────────────┘ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Ray Runtime │ │
│ │ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ Scheduler │ │ Object Store│ │ │
│ │ │ 调度器 │ │ 对象存储 │ │ │
│ │ └─────────────┘ └─────────────┘ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ 集群层 │ │
│ │ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ Head Node │ │Worker Nodes │ │ │
│ │ └─────────────┘ └─────────────┘ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
核心组件 #
text
1. Driver（驱动进程）
├── 主程序入口
├── 提交 Tasks
└── 协调计算
2. Worker（工作进程）
├── 执行 Tasks
├── 运行 Actor 方法
└── 状态管理
3. Object Store（对象存储）
├── 共享内存存储
├── 自动序列化
└── 节点间传输
4. Scheduler（调度器）
├── 任务调度
├── 资源分配
└── 负载均衡
5. GCS（全局控制服务）
├── 集群元数据
├── Actor 注册
└── 故障检测
调度流程 #
text
┌─────────────────────────────────────────────────────────────┐
│ Ray 调度流程 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1. 任务提交 │
│ Driver ──► .remote() ──► 创建 Task │
│ │
│ 2. 依赖解析 │
│ 检查输入 ObjectRef 是否就绪 │
│ │
│ 3. 资源匹配 │
│ 查找满足资源需求的 Worker │
│ │
│ 4. 任务执行 │
│ Worker 执行函数，生成输出 │
│ │
│ 5. 结果存储 │
│ 输出存入 Object Store │
│ │
│ 6. 结果获取 │
│ ray.get() 获取结果 │
│ │
└─────────────────────────────────────────────────────────────┘
Ray AI Libraries #
Ray 提供了一套完整的 AI 库，覆盖机器学习全流程：
1. Ray Data #
text
功能：大规模数据处理
特点：
├── 统一的 Dataset API
├── 支持多种数据格式
├── 自动并行化
├── 内存优化
└── 与其他 Ray 库无缝集成
适用场景：
├── 数据预处理
├── 特征工程
├── 数据加载
└── ETL 流程
2. Ray Train #
text
功能：分布式模型训练
特点：
├── 简化分布式训练
├── 支持主流框架
├── 自动容错
├── 检查点管理
└── 与 Ray Tune 集成
适用场景：
├── 深度学习训练
├── 分布式训练
├── 超参数调优
└── 模型微调
3. Ray Serve #
text
功能：可扩展模型服务
特点：
├── 灵活的部署模型
├── 自动扩缩容
├── 版本管理
├── A/B 测试
└── 复杂推理图
适用场景：
├── 在线推理
├── 模型服务
├── 实时预测
└── API 服务
4. Ray Tune #
text
功能：超参数优化
特点：
├── 多种搜索算法
├── 智能早停
├── 分布式执行
├── 可视化
└── 与框架集成
适用场景：
├── 超参数搜索
├── 模型选择
├── AutoML
└── 实验管理
Ray 的优势 #
1. 简化分布式编程 #
text
传统方式：
├── 手动管理进程
├── 处理进程间通信
├── 实现容错机制
└── 复杂的调试
Ray 方式：
├── @ray.remote 装饰器
├── 自动调度和执行
├── 内置容错
└── 简单的调试
2. 高性能 #
text
性能优势：
├── 底层 C++ 实现
├── 零拷贝序列化
├── 共享内存
├── 高效调度
└── 低延迟通信
基准测试：
├── 任务调度：< 1ms
├── 对象传输：10+ GB/s
├── 可扩展：数千节点
└── 吞吐：百万任务/秒
3. 统一的生态系统 #
text
统一框架：
├── 数据处理：Ray Data
├── 模型训练：Ray Train
├── 模型服务：Ray Serve
├── 超参调优：Ray Tune
└── 一致的 API
好处：
├── 无缝集成
├── 减少学习成本
├── 简化运维
└── 提高效率
4. 弹性和容错 #
text
容错机制：
├── 自动重试失败任务
├── Actor 自动恢复
├── 对象重建
└── 检查点支持
弹性伸缩：
├── 动态添加节点
├── 自动负载均衡
├── 资源感知调度
└── 成本优化
Ray vs 其他框架 #
功能对比 #
| 特性 | Ray | Dask | Spark | Celery |
|---|---|---|---|---|
| 编程模型 | Tasks/Actors | DataFrame | RDD | Tasks |
| 状态管理 | ✅ Actors | 有限 | 有限 | ❌ |
| ML 支持 | 原生 | 有限 | MLlib | ❌ |
| 实时服务 | ✅ | ❌ | ✅ | ❌ |
| GPU 支持 | ✅ | 有限 | ✅ | 有限 |
| 容错 | ✅ | ✅ | ✅ | ✅ |
| 学习曲线 | 低 | 中 | 中 | 低 |
选择建议 #
text
选择 Ray 的场景：
├── 需要统一的 AI 平台
├── 需要有状态计算
├── 需要实时服务
├── 需要灵活的编程模型
└── 需要高性能分布式计算
选择 Dask 的场景：
├── 主要处理表格数据
├── 需要与 NumPy/Pandas 兼容
├── 数据分析为主
└── 已有 Dask 生态
选择 Spark 的场景：
├── 大规模批处理
├── SQL 查询为主
├── 已有 Spark 生态
└── 需要成熟的 SQL 支持
应用场景 #
1. 机器学习平台 #
text
场景：构建企业 ML 平台
Ray 解决方案：
├── Ray Data：数据预处理
├── Ray Train：模型训练
├── Ray Tune：超参调优
├── Ray Serve：模型服务
└── 统一平台，简化运维
2. 实时推理服务 #
text
场景：高并发在线推理
Ray 解决方案：
├── Ray Serve 部署模型
├── 自动扩缩容
├── 复杂推理图
├── A/B 测试
└── 低延迟响应
3. 大规模数据处理 #
text
场景：TB 级数据 ETL
Ray 解决方案：
├── Ray Data 并行处理
├── 自动分区
├── 内存优化
├── 支持多种格式
└── 与训练无缝集成
4. 强化学习 #
text
场景：大规模 RL 训练
Ray 解决方案：
├── RLlib 框架
├── 分布式环境模拟
├── 高效采样
├── 支持多种算法
└── 可扩展训练
学习路径 #
text
入门阶段
├── Ray 简介（本文）
├── 安装与配置
└── 快速开始
基础阶段
├── Tasks 任务
├── Actors 角色
├── Objects 对象
└── 资源管理
进阶阶段
├── Ray Data 数据处理
├── Ray Train 分布式训练
├── Ray Serve 模型服务
└── Ray Tune 超参数调优
高级阶段
├── 集群管理
├── 监控与调试
└── 性能优化
实战阶段
├── 机器学习流水线
├── 实时推理服务
└── 大规模数据处理
下一步 #
现在你已经了解了 Ray 的基本概念，接下来学习 安装与配置，开始搭建你的 Ray 环境！
最后更新：2026-04-05