数据湖解决了数据如何持久化、更新和共享的问题,但数据进入计算阶段后,还需要另一套系统:把预处理、模型训练、推理、环境交互和结果写回组织起来,让不同机器上的 CPU、GPU 与内存协同工作。特别是在大模型场景中,一次任务往往不再是一张固定的 SQL 执行图,而是持续创建任务、维护模型进程、交换中间结果,并根据运行结果决定下一步计算。

Ray 从强化学习等动态计算场景起步,用三种抽象描述这类应用:Task 表达一次计算,Actor 保存可跨调用复用的状态,ObjectRef 将上游结果连接到下游任务。本文将沿着一次远程调用,拆解 Ray 如何选择执行节点、传递对象、分配 GPU,以及失败后哪些状态能够恢复;再结合 Ray Data、Train、Serve 和强化学习系统的生产实践,讨论一个架构选型问题:什么时候值得引入 Ray 来组织计算,什么时候直接使用 Kubernetes 作业、训练框架或推理引擎就已足够。

Ray 为什么出现

从批处理作业到动态计算

传统分布式计算通常围绕相对稳定的执行计划展开:输入数据确定后,系统将计算拆成若干阶段,再通过数据分区、并行执行和 Shuffle 完成作业。这个模型非常适合关系查询、大规模 ETL 和聚合分析。

AI 工作负载却经常需要另一种执行方式。以强化学习为例,系统需要同时运行环境模拟、策略推理、奖励计算和模型训练;不同环境的交互轮数、样本长度和结束时间都可能不同,后续任务也可能只有在前一步完成后才能确定。这里的难点不只是数据规模,而是计算本身具有动态性和异构性。

这类应用通常有四个共同要求:

  • 任务动态生成:计算图可以在运行时扩展,而不是启动时全部确定。
  • 进程长期驻留:模型、连接池和环境状态需要复用,不能每次调用重新初始化。
  • 资源异构:CPU 负责解析、检索和环境交互,GPU 负责模型计算,不同阶段需要独立扩缩容。
  • 中间结果直接传递:上游结果应成为下游依赖,而不是每一步都先写入外部存储。

Ray 最初由 UC Berkeley 的研究团队提出,2017 年发布论文预印本(也参考 Paper 阅读: Real-Time Machine Learning: The Missing Pieces),2018 年在 OSDI 发表(Ray OSDI 论文)。原始设计便围绕强化学习等新兴 AI 应用,将无状态任务和有状态 Actor 放入同一个分布式执行框架,而不只是提供一个更大的 Python 进程池。

从通用运行时走向大模型基础设施

Ray 近几年的变化,可以理解为三个阶段:

阶段 主要问题 架构重心
早期 Ray Core 如何表达动态、异构、有状态的分布式计算 Task、Actor、ObjectRef、调度与对象管理
Ray 2.0 与 AI 库体系 如何降低机器学习系统的集成成本 数据处理、训练、调参、服务的统一运行基础
大模型与 Agent 阶段 如何组织 GPU 集群上的训练、生成、反馈与工具交互 模型常驻、异构流水线、RL 编排、分布式推理与资源复用

2022 年发布的 Ray 2.0,通过更完整的 AI 库体系推动了从“分布式编程工具”到“AI 应用运行基础”的转变。近年的社区演进则进一步集中在大模型强化学习、推理服务、GPU 通信和 Kubernetes 部署上。

需要注意,这不是 Ray 对训练框架和推理引擎的替代。PyTorch、JAX、DeepSpeed、Megatron 和 vLLM 仍然负责各自的张量计算与模型执行;Ray 更关注这些计算如何作为进程和任务被启动、放置、连接与恢复。

整体概念

理解 Ray,可以围绕四个问题展开:

问题 Ray 的主要抽象
计算如何表达 Task 表达一次执行,Actor 表达长期存活的有状态进程
依赖如何连接 ObjectRef 连接生产者和消费者,避免 Driver 搬运所有中间数据
资源如何分配 调度器选择执行位置,Placement Group 预留协作进程所需资源
AI 场景如何落地 Data、Train、Serve 及上层 RL 框架封装具体工作流

Ray 概念总览思维导图

Ray 的运行时架构

Task、Actor 与 ObjectRef

Ray 的编程模型只有少数几个核心概念,但它们分别解决不同的问题。

抽象 执行语义 典型用途 需要注意
Task 一次远程函数调用,通常不依赖跨调用的进程状态 数据清洗、批量计算、奖励打分 失败后可能重试,外部写入需要幂等
Actor 一个具有身份和内部状态的长期存活进程 常驻模型、环境实例、协调器 进程状态不等于持久化状态
ObjectRef 一个远程结果的引用,可以作为后续任务的依赖 连接流水线、传递大对象 它不是可永久保存的数据地址

普通同步 Actor 通常串行执行方法,因此适合封装需要顺序访问的状态;异步 Actor 和多线程 Actor 可以引入并发,但应用需要自己处理共享状态的一致性。

下面是一个省略函数定义的调用示意:

1
2
3
4
5
6
7
# preprocess、persist 是 Ray Task;model_actor 是已启动的 Actor
batch_ref = preprocess.remote(source_uri)
result_ref = model_actor.predict.remote(batch_ref)
write_ref = persist.remote(result_ref, output_uri)

# 只等待最终写入回执,不把所有中间数据拉回 Driver
receipt = ray.get(write_ref)

当 ObjectRef 作为顶层参数传入远程调用时,Ray 会将其识别为数据依赖。Driver 不必先执行 ray.get(batch_ref) 再把结果发送给模型进程,从而避免自己成为中间数据的汇聚点。

控制面与数据面

一个典型 Ray 集群包含 Head Node 和多个 Worker Node。这里的“节点”是 Ray 的逻辑运行节点;部署在 Kubernetes 上时,它通常对应一个 Pod,而不是一台 Kubernetes 宿主机。

组件 主要职责
Driver 执行应用入口,提交任务、创建 Actor、组织计算依赖
GCS Global Control Service,管理节点、Actor 等集群控制元数据
Raylet 每个 Ray 节点上的本地调度与资源管理组件,管理 Worker 和对象相关协调
Worker Process 执行 Task 或承载 Actor 的语言运行进程
Object Store 每个节点上的共享内存对象存储,保存需要共享的对象数据
Autoscaler 根据待满足的逻辑资源需求调整 Ray 节点规模

Head Node 通常承载 GCS 等控制组件(Ray 集群核心概念),但不是所有任务的执行入口,也不是所有数据的转发中心。普通任务的分派由调用方、Raylet 和执行 Worker 协同完成;对象数据则可以直接在相关节点之间传输。

Ray 集群控制面与数据面架构图

图中有两条路径:蓝色框是控制面,GCS 维护节点和 Actor 等集群元数据;提交普通任务时,调用方通过 Raylet 找到可用的 Worker,再把任务发给它,不必先到 GCS 排队。绿色框是数据面:例如 CPU 节点完成预处理后,如果 GPU 节点需要这一大批样本,数据就从 CPU 节点的对象存储传到 GPU 节点,不需要 Driver 或 GCS 中转。

一次远程调用如何执行

一次普通 Task 调用,可以简化为以下过程:

  1. 构建任务描述:调用 .remote() 后,提交方记录函数、参数、资源要求和依赖,并立即得到 ObjectRef;
  2. 选择执行位置:调用方与 Raylet 协作,根据资源可用性、调度策略和数据位置寻找可执行的 Worker;
  3. 准备输入:小参数可以随调用直接传输,大对象通常通过对象存储共享;跨节点依赖需要发生真实的数据传输;
  4. 执行任务:取得 Worker 后,普通任务可以由提交方直接分派给执行进程,而不是让 GCS 转发函数调用;
  5. 返回结果:小结果可能直接返回,大结果可以存入对象存储,通过引用连接下游任务。

这里有两个重要边界:

  • Object Store 不是所有参数和结果的必经路径,小对象可能直接随 RPC 传递;
  • ObjectRef 避免的是不必要的汇聚和复制,不是消除网络传输。生产者与消费者不在同一节点时,数据仍然需要跨网络移动。

对象共享与故障恢复

假设 Driver 调用 ref = preprocess.remote(),远端 Worker 生成一个大型 NumPy 数组。数组保存在执行节点的 Object Store 中,Driver 拿到的是 ObjectRef,不是数组本身。同一节点上的其他 Worker 可以直接读取共享内存中的数组,无需各自复制一份;需要修改时,先复制到进程自己的内存。其他节点若没有副本,则需要先传输数据。这里的零拷贝指支持的 NumPy 数组在同一节点上的读取,不是对任意 Python 对象或 GPU Tensor 的保证。

在这个例子里,执行任务的 Worker 生成数据,发起调用的 Driver 才是对象的 Owner。Owner 维护对象位置、引用计数等元数据;将 ref 传给其他 Worker,不会转移所有权。对于 ray.put(value) 创建的对象,Owner 则是调用 ray.put() 的进程(Ray 对象所有权)。

这一区别决定了故障后的行为:丢失数据副本时,只要 Owner 仍在,Ray 会先查找其他副本;如果没有副本,对于可重建的 Task 结果,还可以重新执行任务。ray.put() 没有对应的生产任务,无法靠重算恢复。丢失 Owner 时,即使其他节点暂时还保留数据,也无法接管原引用;后续通过该引用取值会得到 OwnerDiedError(Ray 对象故障恢复)。

Ray 的恢复能力需要按状态类型分别理解:

状态或故障 Ray 提供的机制 应用仍需负责
普通 Task 执行失败 Worker 崩溃等系统故障按 max_retries 重试;业务代码抛出的异常默认不重试 区分可重试与不可重试的错误,设置重试上限,保证外部写入幂等
普通 Task 结果丢失(batch_ref) 先查找其他副本;若全部丢失,且 Owner 存活、任务及其依赖可重建、仍有重试额度,Ray 可重新执行 preprocess() 保证输入可恢复,重复执行不会产生错误结果或重复写入
Actor 方法结果丢失(result_ref) 即使 Actor 仍在,所有副本丢失后也默认不会重放 predict();允许方法重试需配置 max_task_retries 确认方法可安全重放,且重放时使用正确的模型版本和状态
Actor 进程崩溃 按 max_restarts 配置重启并重新执行 __init__(),不会自动恢复崩溃前的内存状态 从 Checkpoint 或外部存储恢复模型、业务状态和处理进度
Object Store 内存不足 可将部分对象临时溢写到磁盘等介质,按需读回;溢写不等于持久化备份 控制在途数据量,分别监控对象存储、Worker 堆内存和 GPU 显存
对象的 Owner 进程退出 其他进程不能接管原 ObjectRef;后续通过原引用取值会收到 OwnerDiedError 从持久化数据恢复,或重新提交计算以获取新引用
Driver 进程退出 重新启动 Driver 不会从原 Python 执行位置继续;若 Driver 也是某个对象的 Owner,该对象的原引用随之失效 持久化作业进度和提交记录,重启后从最近的恢复点继续,避免重复提交

Actor 重启不等于状态恢复,也不等于方法重试。 max_restarts 控制 Actor 崩溃后是否重启。重启时,Ray 会重新执行 __init__(),不会还原原有的 Python 内存状态;要接着上次的训练步数或处理进度继续,应用必须事先保存 Checkpoint,并在重启后加载。max_task_retries 则控制方法调用在系统故障后是否重试。若 Actor 已写入数据库,却在返回成功前崩溃,重试可能再次写入,因此写入端应使用稳定的业务键保证幂等(Ray Actor 故障恢复)。

Object Spilling 缓解的是对象存储的内存压力,不是作业恢复问题。 当共享内存紧张时,Ray 可以把部分对象暂时写到磁盘,后续访问时再读回。即使对象已经落盘,也不能据此判断训练完成了哪一步、哪批结果已成功写入:前者需要 Checkpoint,后者需要业务提交记录(Ray Object Spilling)。

GPU 调度与 Placement Group

假设一个训练作业需要 16 个 Worker,每个占用 1 张 GPU。前 8 个 Worker 即使已经拿到卡,也得等其余 8 个就绪后才能开始集体通信。Ray 的 Placement Group 解决的就是这个问题:先为整组 Worker 预留资源,再把它们调度到约定的位置。

这里预留的是逻辑资源。num_cpus=2 表示调度时计入 2 个 CPU,并不限制进程只能创建两个线程;num_gpus=0.5 允许多个 Worker 共享一张 GPU,并不会为每个 Worker 划出一半显存。Ray 可以通过 CUDA_VISIBLE_DEVICES 指定 Worker 可见的 GPU(Ray 资源模型)。

如果要求这 16 个 Worker 按 8 + 8 放在两个不同的 Ray 节点上,可以把资源需求写成两个 Bundle:

1
2
3
4
5
6
from ray.util.placement_group import placement_group

pg = placement_group(
bundles=[{"CPU": 8, "GPU": 8}, {"CPU": 8, "GPU": 8}],
strategy="STRICT_SPREAD",
)

每个 Bundle 都必须完整放入一个节点,STRICT_SPREAD 则要求两个 Bundle 落在不同节点。因此,即使集群共有 16 张空闲 GPU,如果分布在 4 个节点上、每个节点只有 4 张,这个组也无法就绪。初始预留是原子的:Ray 不会先占住一个 Bundle,再等待另一个。组就绪后,应用或上层训练框架仍需将 Worker 调度到相应的 Bundle;创建 Placement Group 本身不会启动训练进程(Ray Placement Group)。

生产中还要区分两层保证:放置位置上,KubeRay 中的 Ray 节点通常对应 Pod,两个不同的 Pod 未必位于不同宿主机;如果必须跨宿主机或故障域,还需配置 Kubernetes 的 Pod 反亲和性或拓扑约束。执行语义上,成组预留不等于进程同时启动,更不等于失败时整组回滚;训练进程如何会合、建立通信组,以及从哪个 Checkpoint 恢复,仍由训练框架和应用负责(Kubernetes Pod 放置约束)。

大模型场景如何使用 Ray

数据处理与批量推理

一个常见场景是:读取数据湖中的文本或图片,执行解析、过滤和 Tokenization,再调用模型生成 Embedding、质量分数或合成数据,最后将结果写回数据湖。这类任务面临的问题通常不是某一个算子太慢,而是不同阶段的资源需求不一致:

  • 数据读取、解码和 Tokenization 主要消耗 CPU、内存与存储带宽。
  • 模型推理需要 GPU,且模型初始化成本高,适合长期驻留。
  • 输出序列化与写回又回到 CPU 和存储路径。

Ray Data 将数据拆分为 Block,通过流式执行在算子之间传递。CPU 处理可以使用 Task,模型推理可以使用 Actor Pool,让每个 Actor 初始化一次模型并连续处理多个 Batch。执行器通过资源预算与反压控制上下游速度,避免 CPU 生产的数据无限堆积在 GPU 前面(Ray Data 内部架构)。

大模型离线数据处理流水线

生产设计需要抓住四点:

  1. 模型只初始化一次:使用常驻 Actor 承载模型,而不是为每个 Batch 重新加载权重;
  2. 计算粒度足够大:一次任务处理一个 Batch 或数据分片,不要为每一行、每个 Token 创建远程任务;
  3. 控制在途数据:同时监控 Object Store、Worker Heap 和 GPU 显存,不能只看 GPU 利用率;
  4. 写回要保证原子提交和幂等重试:记录输入快照、模型版本和处理逻辑版本,便于追溯;通过湖表事务,让同一批结果一次性可见。以 Delta Lake 为例,数据处理可以并行,但写入同一张表时,每条独立写入流应使用各自稳定的 txnAppId,按 txnVersion 递增顺序提交批次,避免旧批次因晚到而被忽略。若提交成功但回执丢失,重试时复用原批次的两个标识,避免重复追加。

Pinterest 的公开实践展示了这一模式(Pinterest Ray 批量推理实践/Pinterest 多模态购物数据流水线):通过 Ray 将 CPU 数据处理与 GPU 模型推理组合起来,并在多模态购物场景中使用 CPU 预处理和 GPU 模型处理流水线。其价值来自异构阶段的组织与资源利用,而不是 Ray 自动加速了模型算子。

与其他系统相比,场景选型时主要取决于计算场景需求:

系统 更适合的工作负载 相对 Ray Data 的取舍
Spark SQL、Join、聚合、成熟数仓 ETL 关系执行与生态成熟;复杂模型 Actor 和异构应用编排需要额外集成
Daft 多模态 DataFrame、表达式计算、AI 数据处理 提供更高层的数据执行引擎;可以使用 Ray 作为分布式运行基础,并非与 Ray Core 二选一
Dask NumPy、Pandas 风格的科学计算与数据分析 易衔接 Python 科学计算生态;Ray 的 Actor 和 AI 库体系更适合另一类应用组织方式
Ray Data Python 模型处理、CPU/GPU 流水线、批量推理 与 Ray Actor、Train、Serve 衔接自然,但不能因此假定其 SQL 或 Shuffle 能力全面优于专用引擎

Dask 可以通过 Futures 动态提交任务,不限于静态 DAG。Daft 与 Ray Data 同属数据处理引擎;Ray Core 则是 Daft 可以使用的分布式运行时。

Ray Data 的流式执行指算子之间按批次流水处理:CPU 解码完一批图片,GPU 就能开始推理。它描述的是执行方式,并不等同于 Flink 对无界流的事件时间、Watermark 和 Checkpoint 一致性保证。

分布式训练

大模型训练至少有两个不同的调度层次:

  • 应用层:需要多少训练进程,放在哪些节点,如何启动、失败后如何恢复;
  • 张量层:梯度如何 AllReduce,参数如何分片,流水线阶段如何交换 Activation。

Ray Train 主要负责前者,并集成训练框架完成进程组初始化、指标汇报和 Checkpoint 管理。真正执行 DDP、FSDP、ZeRO、张量并行和流水线并行的,仍然是 PyTorch、DeepSpeed、Megatron 或 JAX 等框架。一个典型设计是:

1
2
3
4
5
6
训练协调器
→ 申请 Placement Group
→ 启动分布式训练 Worker
→ 初始化训练框架的通信组
→ 执行训练与指标上报
→ 将 Checkpoint 写入持久化存储

Ray Train 与分布式训练框架的分层架构图

图 4:Ray Train 与分布式训练框架的分层架构图

以两台机器、每台 4 张 NVIDIA GPU 的 PyTorch DDP 训练为例。读图时可以沿三条路径来看:Ray Train 负责把训练进程启动在哪里,PyTorch DDP 负责每一步如何计算和同步梯度,持久化 Checkpoint 决定故障后从哪里继续。

  1. 启动 Worker:先预留资源,再建立通信组。 Ray Train 通过 Placement Group 为 8 个训练 Worker 成组预留资源,每个 Worker 使用 1 张 GPU。资源就绪后,Ray Train 启动 Worker,并协助初始化 PyTorch 分布式进程组。此时解决的是“哪些进程参加训练、各自使用哪张卡”,还没有发生梯度交换;
  2. 执行训练:每张卡处理不同样本,Worker 之间同步梯度。 在这个 DDP 示例中,8 张卡各自保存一份完整的模型副本。每一步,各 Worker 用不同的样本计算本地梯度;反向传播时,DDP 通常通过 NCCL 的 AllReduce 汇总梯度,各 Worker 再用同步后的梯度更新自己的模型副本。梯度不经过 GCS、Ray Train 协调器或 Ray Object Store:Ray 管理训练进程,张量通信由训练框架完成(Ray Train:GPU 与通信后端);
  3. 故障恢复:重启的是进程,恢复的是训练状态。 训练代码定期保存模型参数、优化器状态和训练步数,将 Checkpoint 上报给 Ray Train,并持久化到 S3 或共享文件系统。启用故障重试后,Ray Train 可以重启 Worker 组;训练代码仍需加载最近一次成功保存的 Checkpoint,才能从对应步数继续。ObjectRef 引用的是运行时对象,不能替代跨作业重启使用的 Checkpoint(Ray Train:故障恢复)。

Cohere 在 Ray Summit 2022 分享的训练系统体现了同样的分工:Ray 在多个 TPU 主机上分发任务,每个 Worker 将自己的 Batch 分片交给 JAX,在 TPU v4 上执行分布式训练步骤。Cohere 的 Ray 与 JAX 实践 如果只有一个固定规模的 PyTorch 作业,Slurm 或 Kubernetes Job 配合 torchrun 往往更直接;当训练还要衔接数据预处理、评估或多模型协作时,Ray 的价值在于把这些阶段组织起来,而不是加速单个通信算子。

强化学习与 Agent Rollout

在大模型强化学习中,Rollout 是用当前策略生成训练样本的过程。普通问答可能只需生成一次回答;Agent 则可能多次调用工具,根据返回结果决定下一步。模型的动作与环境返回的观测,共同构成一条交互轨迹。

一次策略迭代可以分为三步:

  1. 生成轨迹:Rollout Worker 接收 Prompt,调用推理引擎生成回答或动作。例如,代码 Agent 可以运行测试,读取报错,再修改代码,直到任务结束;
  2. 评估轨迹:验证器可以根据测试是否通过给出奖励,也可以由 Reward Model 评分。是否还需要参考策略的对数概率或 Critic 的价值估计,取决于训练算法;
  3. 更新策略:Training Worker 用这批轨迹和奖励更新模型,再将新权重同步给推理引擎,供后续采样使用。

生成大模型强化学习系统架构图

Ray 的价值在于,让耗时和资源需求不同的阶段可以分别组织。工具执行可能主要等待 CPU 或网络,生成和训练则使用 GPU,但不必采用相同的并行策略。以 verl 的 HybridFlow 为例,上层控制器决定何时采样、评分和训练,底层 Worker 组执行模型计算;Ray Actor 让这些 Worker 可以常驻,不必每轮重新加载模型。

生产部署通常在 GPU 复用和流水线吞吐之间取舍:生成与训练可以分阶段共用一组 GPU,代价是两个阶段需要相互等待;也可以拆成独立资源池,在训练上一批样本时生成下一批。后一种方式减少了等待,但样本可能来自较旧的策略,因此需要跟踪采样时的策略版本,并限制队列深度,避免训练长期消费滞后样本。

在线推理与模型组合

一次检索问答请求,并不是把用户问题直接交给大模型。系统先要找到相关文档,从中选出最有用的片段,再把问题和证据一起交给模型生成答案。这里有两层分工:Ray Serve 负责把多个服务串成一条请求链路,vLLM 负责执行其中的模型生成。

具体来说,Serve Proxy 将请求路由到入口副本;入口副本先调用检索服务取得候选文档,再调用重排副本筛选片段、组装提示词,最后调用生成副本,流式返回答案。将这些阶段拆成独立部署的价值在于按瓶颈扩容:如果请求主要在重排阶段排队,就增加重排副本,不必同时复制占用更多 GPU 的生成模型。反过来,如果业务只需调用一个模型,也没有组合多个服务的需求,直接部署 vLLM 通常更简单(Ray Serve:模型组合)。

再放大链路中的最后一站:生成副本如何使用 GPU? Prefill 处理输入提示词并建立 KV Cache,Decode 复用这份缓存,逐个生成后续 Token。两者可以在同一推理实例中完成,也可以分到不同的 GPU 池独立扩容。分离部署能减少长输入对正在生成的请求的干扰,但也需要跨实例传输 KV Cache。是否值得拆分,应在真实负载下同时比较首个 Token 延迟(TTFT)和后续 Token 的输出间隔(ITL),而不是默认分离就更快(vLLM:Prefill 与 Decode 分离)。

基于 Ray Serve 与 vLLM 的在线推理架构图

总结

Ray 解决的是如何让一组相互依赖的计算,在集群上协同运行。Task 表达可调度的工作,Actor 保留跨调用的进程状态,ObjectRef 表达任务之间的数据依赖。借助这些抽象,应用可以把 CPU 数据处理、GPU 推理、奖励评估和模型训练组织成一条流水线,而具体的模型运算仍由训练或推理引擎完成。

设计这类系统时,先厘清三个问题,再选择 Ray API:谁负责调度、数据走哪条路径、故障后从哪里恢复? Ray 负责调度任务和放置 Worker,但不同类型的数据不必经过同一条路径:预处理任务可以用 ObjectRef 把中间结果交给下游;在前文的 NVIDIA GPU + PyTorch DDP 示例中,Worker 之间通常通过 NCCL 同步梯度,不经过 Ray Object Store。至于作业重启后仍需保留的模型参数和优化器状态,则应写入持久化 Checkpoint。重新启动 Worker 只能恢复计算进程,加载 Checkpoint 才能接着上次的进度训练。

从 AI 与数据基础设施的分工看,数据湖保存可共享、可追溯的数据,Ray 协调围绕数据展开的计算,训练和推理引擎负责高效执行模型。检验这套架构是否合理,可以看一次具体的故障:当某个节点退出时,系统是否知道哪些任务可以重算、哪些结果已经提交,以及应该从哪里继续执行。