首页 / AI System Performance / AI Infra / 训练框架 / DreamZero 训练流程
DreamZero WAM 训练流程

DreamZero WAM 训练流程

以 scripts/train/droid_training_lora.sh + data=dreamzero/droid_relative + model/dreamzero/action_head=wan_flow_matching_action_tf 为准:先看多机多卡总流程,再拆架构、方法与训练目标。

图为内嵌 SVG,用浏览器直接打开本 HTML(file://)即可显示,不依赖 Mermaid CDN。
一句话。当前配置微调的是以 Wan2.1-I2V-14B 因果分块 DiT(CausalWanModel) 为骨干的 世界–动作模型(WAM):冻结 VAE / CLIP / T5 / CausalHead, 可训 = DiT 上的 LoRA + action/state encoder + action_decoder; 一次 forward 同时做视频与动作 flow matching。下文图例按 train_architecture=lora 标注。
青绿 = 参数更新(可训) 灰色 = 冻结(不更新) 条纹 = 主干冻 + 仅 LoRA 可训 白框 = 无权重 / 调度器
可训 · LoRA + act/state enc + action_decoder 冻结 · VAE / CLIP / T5 / CausalHead / DiT 基座 L = L_video + L_action

1. 总体训练流程(多机多卡)

启动脚本用 torchrun --nproc_per_node …(多机再加 --nnodes / --node_rank / --rdzv_*),进程进 groot/vla/experiment/experiment.py;训练器基于 HuggingFace Trainer + DeepSpeed ZeRO-2。下图按「任务分配 → 权重写回」串起各环节; 示意 2 节点 × 每节点多卡,真实规模由 WORLD_SIZE 决定。

① 任务分配 / 进程启动 torchrun 拉起 world_size 个进程 · 注入 RANK / LOCAL_RANK / NODE_RANK / WORLD_SIZE · Hydra 解析同一份 cfg ② 集群拓扑 · 每卡一进程 Node 0 rank0 rank1 rank2 … Node 1 · … rankk rankk+1 … ③ 分布式初始化 + 模型装载 NCCL process group · DeepSpeed ZeRO-2 包装 · 各 rank 设 cuda:LOCAL_RANK 加载 Wan VAE / CLIP / T5 / DiT → 冻结基座 → 挂 LoRA + action/state enc + action_decoder ④ 数据任务划分(按 rank) LeRobot ShardedDataset:episode/shard 按 rank×worker 过滤 · 各卡独立 DataLoader 共享存储上的文件可共用;进程内 RAM shard cache 不跨 rank 共享(见 §3.2 B0) ⑤–⑨ 每个 training step(各 rank 同步推进) ⑤ 取样本 DataLoader → parquet/mp4 解码 → dreamzero_cotrain 变换 → batch 上 GPU ⑥ 前向 VLA → Identity → WANPolicyHead:VAE/CLIP/T5(无梯度)编码 → 加噪 → CausalWan → video/action pred ⑦ 损失 L = L_video + L_action(flow matching)· 本 rank 本地标量,随后在反传中参与归约 ⑧ 反传 + 跨卡通信 backward · ZeRO-2:梯度按参数分区归约/分片(NCCL)· 可训参数主要是 LoRA 与 enc/decoder ⑨ 优化器步进 · optimizer.step(ZeRO 分片优化器状态)· LR scheduler ⑩ 参数 / 权重写回 按 save_steps:常由 rank0(或 DeepSpeed 协调)写出 checkpoint → output_dir 本脚本 save_lora_only=true:落盘 LoRA + 可训头,不写整份 14B 基座 · 可选 upload_checkpoints 循环:⑤–⑨ 直至 max_steps / epoch 结束;⑩ 周期性穿插,非每步必写

图 0 · 多机多卡端到端:① 分配进程 → ② 拓扑 → ③ 初始化与装模 → ④ 按 rank 分数据 → ⑤–⑨ step 环(前向 / 损失 / ZeRO 反传 / 更新)→ ⑩ checkpoint 写回。

环节 谁做 本配置要点
① 启动 torchrun + Hydra droid_training_lora.sh;多机改 nnodes / rdzv
③ 并行策略 各 rank + DeepSpeed training_args.deepspeed=…/zero2.json
④ 数据 每 rank 独立 sharded filter;非全局共享内存 cache
⑧–⑨ 更新 集体通信 + 本地 step 只更新 LoRA / enc / decoder;基座冻
⑩ 写回 主进程协调落盘 save_lora_only → OUTPUT_DIR

2. 训练总览

先交代「训什么数据、算什么损失」,再看「模型长什么样」。 数据落盘与多卡读法见 §3;此处只给总览。

2.1 训练数据

数据源:DROID(LeRobot:parquet + 三路 mp4),配置 data=dreamzero/droid_relative。相对关节/夹爪动作在线算,不预写回磁盘。

输入(磁盘原始 → 进模型)

下表对比磁盘上长什么样与真正喂进训练步的张量; 「怎么转换」只写在线管线要点(不落盘)。末列小视频逐步高亮各处理环节(可循环播放)。 噪声项无磁盘来源,训练时现采样。

模态 磁盘原始格式 进模型的数据(类型 / 形状语义) 怎么转换 流程示意
多相机视频 每路相机一个 .mp4(H.264 等压缩); 解码后为逐帧 RGB,通常 uint8,分辨率因采集而定 Batch 字段 images:浮点视频张量 (拼图后约 [B, T=33, C=3, H=176, W=320],训练常用 bf16/fp32); Head 内再经冻结 VAE → latent 按时间窗抽帧 → resize 到 320×176(像素分辨率) → 增广 → 三路拼成 2×2 → 归一化/ToTensor → collate; num_views=3,num_frames=33。 2×2 布局见右侧视频「2×2 拼图」步骤放大图。
语言 parquet 里 task_index / 语言列,或 meta/tasks.jsonl 中的字符串指令 (纯文本,非 token) token id + attention mask(整型); 冻结 UMT5 编码为 prompt_embs(bf16 浮点),作 DiT context 选一条 instruction → Collator 包成带「三视角布局说明」的长 prompt (告诉模型顶/左下/右下各是哪路相机,见附录 B)→ umt5 tokenize(字符串→token id)→ batch → 冻结 T5 forward(无梯度)
当前 state parquet 数值列:绝对 joint_position、 gripper_position(浮点标量序列) state:浮点张量,当前帧、已 q99 归一化; 再进可训 state_encoder 按 delta=[0] 取当前步 → ToTensor → 用 stats / relative_stats 做 q99 归一化 → collate
动作(条件 + 监督) 同上 parquet:未来窗内绝对关节/夹爪轨迹 (浮点列,按 timestamp 对齐) action:浮点 chunk [B, action_horizon=24, action_dim], 相对关节 + 夹爪、已 q99; 另有 action_mask / has_real_action; Head 内再对 clean action 加噪 抽未来 horizon → 绝对→相对(在线,相对当前 state)→ q99 → concat 关节/夹爪 → collate; 加噪在 WANPolicyHead 内用 FlowMatchScheduler
噪声 t / 噪声样本 无(不来自数据集) 标量/向量时间步与同形状噪声张量(浮点),分别作用于 video latent 与 action 每个 training step 由 FlowMatchScheduler.add_noise(...) 采样生成

输出(监督目标 vs 模型预测)

两路监督都来自训练数据,不是模型自己生成的标签。 进 MSE 的不是原始 RGB / 原始动作数值,而是 flow matching 的 training_target = noise − clean (见 FlowMatchScheduler.training_target)。

干净信号(来自训练数据) 真正的 loss 目标 *_target 模型预测
世界 / 视频 同一时间窗的多相机拼图视频 → 冻结 VAE 得到 latents(不是直接对 RGB 做 MSE) video_target = noise − clean_latents (再按 w(t_video) 加权) CausalHead → video_pred (头冻结,梯度进 DiT LoRA)
动作 parquet 未来窗绝对轨迹 → 在线相对化 + q99 后的 clean action chunk(horizon=24) action_target = noise − clean_action (再 × action_mask / has_real_action / w(t_action)) action_decoder → action_pred

因此:问「action_target 是不是来自训练数据」→ 是(根上是数据里的动作); 「video_target 呢」→ 也是(根上是数据里的视频),只是先经 VAE 成 latent, 再和本 step 采样的噪声组成 noise − clean。 训练时模型一次 forward同时出两路预测;推理侧重动作(及可选视频想象)。

Loss 怎么算

对 video latent 与 action 分别加噪;共享 CausalWan 一次前向;两路加权 MSE(flow matching)相加。 下式中的 video_target / action_target 即上表的 noise − clean_*:

clean_latents ← VAE(训练视频窗)          # 来自数据
clean_action  ← 相对动作 chunk             # 来自数据
video_target  = noise_v − clean_latents
action_target = noise_a − clean_action

dynamics_loss = MSE(video_pred, video_target) × w(t_video)
action_loss   = MSE(action_pred, action_target) × action_mask
                × has_real_action × w(t_action)

L = dynamics_loss + action_loss

细节与示意图见 §3.3。反传只更新 LoRA 与 action/state enc、action_decoder。

输入 视频窗 · 语言 state · 噪声 t (+ clean 作目标) WAM / CausalWan 编码 → 加噪 → DiT video_pred · action_pred dynamics_loss action_loss L = L_v + L_a 反传可训参数

图 · §2.1 训练数据总览:多模态输入 → 双路预测 → 联合 flow-matching 损失。

2.2 训练模型

外壳是 VLA = Identity + WANPolicyHead;真正可训主体是 CausalWan DiT 上的 LoRA 与动作相关编解码器。图例同页首:青绿可训、灰冻结、条纹 = 基座冻 + LoRA 可训。

2.2.1 外壳:VLA = Identity + WANPolicyHead

Hydra model=dreamzero/vla 实例化 groot.vla.model.dreamzero.base_vla.VLA。形式上是 backbone + action_head,但 DROID LoRA 配置里 backbone 是 Identity——没有 VLM、没有可加载权重,只返回空的 backbone_features [B,1,0],用来满足接口,让 action head 自成一体。

VLA 容器 IdentityBackbone 无权重 · 不训 【冻结/占位】 WANPolicyHead 内含冻+可训子模块 见下图拆解 VAE · CLIP · UMT5 【冻结】 CausalWan DiT 基座冻 · LoRA 可训 enc/decoder 等 【可训】见图2 FlowMatchScheduler · 无训练参数

图 1 · VLA 外壳与可训/冻结总览(LoRA 配置)。

2.2.2 核心:CausalWanModel(Wan2.1-I2V-14B 改版)

扩散/流匹配主干来自 Wan I2V 14B,类名 CausalWanModel。配置:num_layers=40, dim=5120,num_heads=40, ffn_dim=13824,model_type=i2v。 骨干约 14B;action/state MLP 很小。

输入侧嵌入(LoRA 配置着色) patch_embedding latent → tokens 【冻结】 action_enc 动作嵌入 【可训】 state_enc 状态嵌入 【可训】 text / time emb 投影(T5 在外冻) 【冻结】 img_emb CLIP 特征投影 【冻结】 40 × CausalWanAttentionBlock · ~14B 基座权重【冻结】· 仅 q/k/v/o/ffn 上 LoRA【可训】 序列:[ video | action | state ] · 块因果注意力 CausalHead + unpatchify → video_noise_pred 【冻结】复用 Wan I2V 视频头 action_decoder MLP → action_noise_pred 【可训】机器人新任务头 代码:set_trainable_parameters 显式打开 state/action_encoder 与 action_decoder;未打开 head

图 2 · CausalWan 内部模块着色。青绿可训;灰冻结;条纹 = 14B 基座冻、LoRA 可训。 全量微调(非 LoRA)时 CausalHead 等也会一起更新,本页按 droid_training_lora.sh。

模块 作用 LoRA 配置下
IdentityBackbone 接口占位 无权重 · 不训
Wan VAE 像素 ↔ video latent 【冻结】只 encode
CLIP / WanImageEncoder 首帧语义条件 【冻结】
UMT5-XXL 语言条件 【冻结】
patch_embedding / text·time emb / img_emb DiT 侧嵌入投影 【冻结】(LoRA 未覆盖)
40 × AttentionBlock(~14B) 联合建模视频+动作 token 基座【冻结】· LoRA(q,k,v,o,ffn)【可训】
action_encoder / state_encoder 动作/状态 → DiT 维 【可训】全参
CausalHead 视频 token → video_noise_pred 【冻结】
action_decoder 动作 token → action_noise_pred 【可训】全参

2.2.3 时间块布局(本脚本)

超参 值 含义
num_views 3 两侧外置 + 腕部 → 2×2 拼图
num_frames 33 视频时间窗长度
action_horizon 24 动作 chunk 长度
num_frame_per_block 2 视频按 2 帧一块做因果块注意力
num_action_per_block 24 每块对齐的动作步数
num_state_per_block 1 每块 1 个 state 寄存器

3. 训练过程

3.1 哪些冻结、哪些更新

冻结(灰)

  • Wan VAE、CLIP、UMT5
  • Identity(无参数)
  • DiT 基座权重、patch / text·time / img_emb
  • CausalHead(视频读出头)

可训(青绿)

  • DiT 上 LoRA:q,k,v,o,ffn
  • action_encoder / state_encoder(全参)
  • action_decoder(全参)
  • save_lora_only 会把当前 requires_grad 参数一并存

3.2 数据怎么提取与组织(结合代码)

配置 data=dreamzero/droid_relative → 类 ShardedLeRobotSubLangSingleActionChunkDatasetDROID (lerobot_sharded.py)+ mixture。 磁盘仍是 LeRobot:每条 episode 一个 parquet + 三路 mp4; 相对动作 / 增广 / 拼图 / tokenize 全在线,不写回磁盘。

A. 磁盘布局 → 一次 sample 的键

dataset_root/
  meta/{info,tasks,episodes,modality,stats,relative_stats_*}
  data/chunk-***/episode_XXXXXX.parquet     # state / action / task_index / timestamp
  videos/chunk-***/{cam_key}/episode_XXXXXX.mp4

modality(DROID):
  video: exterior_1_left, exterior_2_left, wrist_left
  state: joint_position, gripper_position     # delta=[0] 只要当前帧
  action: joint_position, gripper_position    # delta=未来 horizon
  language: language_instruction{,_2,_3}

B0. 多机多卡:各 rank 如何读数据(总图)

假设 2 机 × 每机 2 卡 → world_size=4, dataloader_num_workers=1。 共享的是磁盘上的 LeRobot;不共享 RAM cache。 各 rank 同 seed 生成同一全局 shard 日程,再按 i % (world_size·workers) == rank·workers + worker_id 取模切开。

共享存储 · 同一份 DROID LeRobot(parquet + mp4) 各机挂载同一路径 / 对象存储;只有文件共享,没有跨机 decoded-frame 缓存 ① 每个 rank 本地用同一 seed 生成【相同】全局 shard 日程 schedule = [S0, S1, S2, S3, S4, S5, S6, S7, …] generate_shards_sample_schedule() · 尚未按卡切开 ② filter:保留 i,使 i % (W·Nw) == rank·Nw + worker_id 例 W=4, Nw=1 → rank0:[S0,S4,…] rank1:[S1,S5,…] rank2:[S2,S6,…] rank3:[S3,S7,…] 机器 / Pod A 机器 / Pod B Rank 0 GPU0 · worker0 分到 S0, S4, … ③ finish_cache(S0) 读盘→本进程 RAM cached_shard 仅 Rank0 可见 ④ 循环 get_step_data (traj,t)→transforms ⑤ 本地 micro-batch → forward / loss 后台 cache 下一 shard Rank 1 GPU1 · worker0 分到 S1, S5, … ③ finish_cache(S1) 读盘→本进程 RAM cached_shard 仅 Rank1 可见 ④ get_step_data… transforms ⑤ 另一份 batch → forward / loss Rank 2 GPU0 · worker0 分到 S2, S6, … ③ 独立 cache(S2) (机器 B 本地 RAM) cached_shard 与 A 机不互通 ④ get_step_data… ⑤ 本地 batch → forward / loss Rank 3 GPU1 · worker0 分到 S3, S7, … ③ 独立 cache(S3) cached_shard 本进程私有 ④ get_step_data… ⑤ 本地 batch → forward / loss ⑥ 各 rank 算完 loss 后:梯度 AllReduce / ZeRO(数据不汇合,只同步梯度)

图 3-multi · 多机多卡读数:同算法、不同 shard;cache 在各自 DataLoader 进程内存; 跨机只共享数据集文件。代码: filter_shards_sample_schedule、 start/finish_cache_shard、get_step_data。

B. 调度:Shard 缓存 + 抽 (traj, t)

episodes 列表 按长度切成 shards 当前 shard finish_cache_shard 后台预取下一 shard 枚举合法 step (traj_id, step_index) shuffle · 取 10% shard yield transforms IterableDataset

图 3a · Mixture __iter__(lerobot_sharded.py): 不是随机 __getitem__(i),而是按 shard 流式 yield。 dataset_shard_sampling_rate=0.1 表示每个 shard 只抽约 10% 的合法 step。

B′. 缓存预取:时机与粒度

图中「后台预取下一 shard」指的是: finish 当前 shard 后立刻 cache_next_shard() → start_cache_shard, 用 ThreadPoolExecutor(max_workers=1) 在后台线程里 get_shard(读 parquet + 解码视频进本进程 RAM)。 主线程同时枚举/抽 step、transform、经 DataLoader 喂给 GPU—— 因此常与训练 step 重叠,但不是按每个 CUDA forward 触发的预取,也不是 asyncio。

预取(cache) 训练抽样(yield)
粒度 整 shard(多 episode 的表 + 视频一次解码进 RAM) step:(traj_id, step_index);约 10% shard
时机 进入当前 shard 后立刻启动下一 shard; 与「扫当前 shard / 后续 GPU step」并行; 切 shard 时 finish_cache_shard().result(),未完成则阻塞 当前 shard 已 finish 后,在内存 cache 上循环抽 step
实现 concurrent.futures.ThreadPoolExecutor Mixture __iter__ 主路径 + DataLoader

视频 · shard 缓存预取讲解:粒度(整 shard vs step 抽样)、时机(finish→立刻 start 下一、与消费重叠)、 代码顺序与 ThreadPool(非 asyncio)。

C. 提取:delta_indices 扩成时间窗

调度只给出一个点 (trajectory_id, step_index);训练需要各模态对齐的时间窗。 扩窗发生在图 3a 的「枚举合法 step」与「yield transforms」之间 (不是 cache_next_shard):

indices[key] = delta_indices[key] + step_index
step_data = get_step_data(trajectory_id, indices)   # 原始 dict,未 transform
yield transforms(step_data)

视频 · delta 扩窗讲解:在 shard 流程中的位置、相对偏移 → 绝对下标、 state/action/video 示例,以及与 get_step_data / transforms / 预取的区别。

模态 delta(相对 step_index) 从哪读 组织结果
video ×3 基座 yaml 常为 0..24;脚本 num_frames 控制实际窗长 shard 缓存的帧 / 或按语言段重采样帧号 → 索引进 cached 视频数组 每相机 (T,H,W,C),键名 video.*
state [0] 只要当前 parquet 列(经 modality start/end 切片) state.joint_position 等
action 未来 horizon(如 0..23 / 24 步) parquet;可按语言一致区间扩采样 绝对动作 →(见下)相对化
language [0] annotation 列 / tasks 三条 instruction 候选

get_step_data 按 modality 调 get_data_by_modality: 视频走 get_video(可按同一句语言的区间均匀抽帧); action 在取完后若 relative_action=true 且 key∈relative_action_keys(DROID 为 joint_position),调用 _convert_to_relative_action:

# 每个 chunk(默认 24 步)用该 chunk 首帧的 state 作锚点
relative_action[chunk] = absolute_action[chunk] - state[anchor]
# gripper 通常不在 relative_action_keys 里,保持绝对

D. 组织:两级 transforms

① 数据侧 transform_oxe_droid(yaml 组合):

  1. 视频:ToTensor → crop → resize(如 320×176) → color jitter → numpy
  2. state/action:ToTensor → q99 归一化(相对动作用 relative_stats)
  3. ConcatTransform:多 key 拼成 video / state / action 大数组
  4. 挂上 dreamzero_cotrain(模型侧)

② 模型侧 DreamZeroCotrainTransform:

  • DROID 三相机 → 2×2 画幅:顶行腕部横向拉宽;底行左/右外置 (_prepare_video)
  • 训练时在多条 language 里随机选一句
  • state/action pad 到 max_state_dim / max_action_dim,写 mask、embodiment_id
  • 输出单样本 dict:images, text, state, action, action_mask, has_real_action, embodiment_id, …
RAW step_data 分 key 的 video/state/action 相对动作 + crop/resize + q99 + concat + 2×2 拼图 单样本 dict images / text / … DefaultDataCollator DROID 文案包装 + umt5 stack → Batch 进 VLA per_device_bs=1

图 3b · 从 RAW 到 Batch。Collator 里会把短指令扩成带「三视角布局说明」的长 prompt,再 umt5 tokenize。

E. 进 WANPolicyHead 之后(注入模型)

Batch 字段 模型怎么用
images 整段 → VAE latents(监督);第 1 帧 → CLIP + 首帧条件 y
text + mask 冻结 T5 → prompt_embs → DiT context
state 可训 state_encoder → 序列里的 state token
action 加噪 → 可训 action_encoder;target 来自 clean action
action_mask / has_real_action 挡无效维 / 无真实动作样本的 action_loss
embodiment_id CategorySpecific 编解码选 DROID 槽位
提取 vs 组织。 提取 = shard 上按 (traj,t) + delta_indices 取出对齐的多模态原始窗(含相对动作)。 组织 = 归一化、拼相机、选语言、collate/tokenize,变成 Head 认的 Batch。 代码主路径: Mixture.__iter__ → get_step_data → ComposedModalityTransform → DreamZeroCotrain → DefaultDataCollator → VLA.forward。

F. 一个 step 里:权重 / 梯度 / 优化器状态如何在多机多卡间传递

本配置:HuggingFace Trainer + DeepSpeed ZeRO-2 (groot/vla/configs/deepspeed/zero2.json,zero_optimization.stage: 2)。 数据各 rank 不同;要同步的是可训参数上的梯度信息与优化器分片,不是把 batch 或整份 14B 权重每步全量广播一遍。

F.1 ZeRO-2 下三类状态「谁持有什么」
状态 每张卡上有什么 跨卡怎么动
模型权重 W(含 LoRA / enc / decoder;冻结模块本地有、不更新) ZeRO-2:存储/前向仍是每卡一份完整可训 W (真正长期分片的是优化器状态与归约后的梯度,不是「每卡只有 1/N 权重」) 优化器步进时:每卡只负责改写自己那 1/N 参数 (因只有这部分的 Adam 状态与 g 分片);改完后 AllGather,让每卡本地的完整 W 都变成最新版
梯度 g = ∂L/∂W 反传先在本地算出与本卡 batch 对应的梯度 ReduceScatter(或等价归约): 全局平均/求和后,每卡只保留参数空间的 1/N 分片梯度
优化器状态(Adam 的 m、v 等) 每卡只存自己那 1/N 参数分片对应的状态 不整包传递;各卡用本地分片梯度更新本地分片状态与参数, 再靠参数 AllGather 对齐 W

对比:ZeRO-1 主要分片优化器;ZeRO-2 = 优化器 + 梯度分片;ZeRO-3 才会把参数存储也切成 1/N(本脚本不是 stage 3)。 可训集合主要是 LoRA 与 action/state enc、action_decoder——通信量远小于全量 14B。

「参数分片」别误解成「每卡只有部分权重」。 ZeRO-2 里更准确的说法是更新责任分片: 前向时每卡都有完整 W;步进时 Rank i 只更新第 i 份参数(因为它只持有这份的 opt_state / g), 其它 rank 负责的其余参数在本卡上会暂时偏旧,靠 AllGather 再对齐成完整新 W。 不是「每卡从头到尾只存 1/N 的 W、前向也拼起来才算」(那是 ZeRO-3)。
F.2 单个 training step 的时序

下图中紫色描边/底色 = 需要跨卡 NCCL 通信的步骤;灰蓝/橙/绿 = 纯本地计算。 令可训参数个数为 P(LoRA + action/state enc + action_decoder,≪ 14B),卡数为 N。

紫色 = 跨卡通信(本 step 热路径) 灰框 = 本地,无 NCCL Rank0 … RankN−1 · 同一 process group ① 前向(本地) 完整 W × 本地 batch 通信量:0 ② 反传(本地) 得到 g_local 通信量:0 ③ 梯度通信 ★NCCL 类型:可训参数梯度 g 原语:ReduceScatter 量级:≈ O(P) 元素(≈ 可训参数体量) ④ 优化器步进(本地 · 分片责任) 本卡 opt_state(m,v) 分片 + g 分片 → 只改写本卡负责的 W 分片 通信量:0(Adam 状态不跨卡传) ⑤ 参数对齐 ★NCCL 类型:更新后的可训权重分片 W_shard 原语:AllGather → 每卡完整最新 W 量级:≈ O(P) 元素(与可训参数同体量) 本 step 跨卡流量(紫色两步)· 类型与大小 ③ 梯度 ReduceScatter 数据类型:float(常 bf16/fp16 通信或按引擎配置)· 内容 = 可训参数的 ∂L/∂W 大小:张量总元素数 ≈ P;集合通信总交换量量级 O(P),每卡约处理 P/N 的归约结果分片 ⑤ 权重 AllGather 数据类型:与可训权重相同 · 内容 = 各卡刚更新完的 W 分片 大小:拼齐后仍是一份完整可训 W,元素数 ≈ P;同样 O(P) 量级,不是 14B 基座、不是 Adam m/v

图 · F.2:紫色步骤为跨卡通信;①②④ 本地。热路径载荷 ≈ 2×O(P)(梯度一次 + 权重一次),P = 可训参数量。

步骤 是否跨卡 传递数据类型 大小(量级)
① 前向 否 — 0
② 反传 否 — 0
③ 梯度通信 是(紫) 可训参数梯度 g ≈ P 个元素;ReduceScatter 后每卡持有 P/N
④ 优化器 否 Adam m,v 仅本卡分片读写 0 跨卡;本卡状态约 2×(P/N)(fp32 计)
⑤ 参数对齐 是(紫) 可训权重分片 W_shard ≈ P 个元素 AllGather 成完整 W
(可选)日志 是,但极小 loss 等标量 O(1)~很小

粗算单步卡间热流量:约 两次 O(P) 集合通信(③ 梯度 + ⑤ 权重), P 仅为 LoRA/头等可训量;不含 batch、不含整份 Adam、不含冻结 14B。 精确字节数还取决于通信 dtype(fp16/bf16/fp32)与 DeepSpeed bucket 实现,但类型与量级如上。

F.3 和「数据并行直觉」的对照
经典 DDP(简化):
  每卡完整 W、完整 opt_state
  backward 后 AllReduce(梯度) → 每卡用同一 g 更新完整 W
  通信对象:整份可训梯度

本配置 ZeRO-2:
  每卡完整 W(前向用),但 opt_state 与归约后的 g 按参数维切成 1/N
  通信对象:梯度归约/分片 + 更新后参数分片的 AllGather
  显存:优化器状态约降为 1/N(相对每卡存全量 Adam)

LoRA 配置下「参与上述通信的 W」≈ LoRA A/B + action/state enc + action_decoder
冻结的 VAE/CLIP/T5/DiT 基座:requires_grad=False,不进优化器,也不做梯度 AllReduce
F.4 多机时路径与落盘
  • 机内:同节点多 GPU 通常 NVLink/PCIe + NCCL; 跨机:同一 process group,走节点间网卡(常见 IB),集合通信原语不变。
  • 代码入口:Trainer / Accelerate 的 backward + DeepSpeed engine 封装通信; 业务侧 training_step 不必手写 AllReduce。
  • checkpoint:按 save_steps 协调保存; save_lora_only=true 时主要落盘可训增量,不是每步把分片优化器状态在节点间来回拷贝当「训练通信」。
一句话。 一个 step 里跨卡传递的核心是可训参数的梯度分片归约与更新后权重分片再聚合; 优化器动量等状态留在各自分片上就地更新;训练数据 batch 不在 rank 间传递。

视频 · ZeRO-2 单步:W / g / opt_state 归属、①–⑤ 时序、跨卡传与不传什么。

3.3 Loss 怎么设

WANPolicyHead.forward:对 video latent 与 action 分别加噪; DiT 一次前向出两路;scheduler 加权 MSE(flow matching)。

noisy_latents, noisy_actions  ←  FlowMatchScheduler.add_noise(...)
video_noise_pred, action_noise_pred  ←  CausalWanModel(...)

dynamics_loss = MSE(video_pred, video_target) × w(t_video)
action_loss    = MSE(action_pred, action_target) × action_mask
                 × has_real_action × w(t_action)

loss = dynamics_loss + action_loss
共享 DiT · 一次 forward token:[ video | action | state ] 40 × blocks → 按位置切开 CausalHead → video_pred action_decoder → action_pred dynamics_loss action_loss 相加 → 反传 LoRA

图 4 · 联合损失;不是两个对称 FFN 各训一套主干。

4. 训练目标

表示层(数学)

  • 最小化加权 flow-matching 误差
  • L = L_video + L_action
  • 同一主干、两路读出、联合反传

能力层(模型会什么)

  • 世界模型:预测视频演化
  • 策略:对齐的未来动作 chunk
  • DROID:相对关节 + 夹爪

4.1 相对「只做行为克隆」

常见 BC / 小 VLA 本配置 DreamZero WAM
监督 多只拟合 action action + 未来视频
骨干 ViT / 小 Transformer 14B 视频 DiT(LoRA)
归纳偏置 看见 → 动作 想象世界如何变 ↔ 该怎么动
训练目标浓缩。 学会在语言与多相机观测条件下,同时预测「接下来画面怎么走」和「手臂关节怎么动」; 前者是世界模型,后者是策略,二者共享 CausalWan 主干并通过块因果注意力对齐。

附录 A · 一个训练 step

1. DataLoader:shard 内抽 (episode, t)
2. 读 parquet + mp4 → 相对动作 / q99 / 增广 / 2×2 / umt5
3. VLA.forward → Identity 透传 → WANPolicyHead
4. VAE / CLIP / T5 编码(无梯度)
5. 对 latent、action 加噪
6. CausalWanModel → video_pred, action_pred
7. loss = dynamics_loss + action_loss
8. backward → 更新 LoRA(ZeRO-2)

附录 B · 名词解释

正文里反复出现、但不单独展开的术语,按本配置语境解释(非百科全文)。

Hydra
Meta 开源的 Python 配置框架。用 YAML 组合实验配置,命令行用 key=value / group=choice 覆盖。 DreamZero 入口 experiment.py 的 @hydra.main 解析 cfg,再 instantiate 出 Dataset / Model / Trainer。
torchrun
PyTorch 分布式启动器。按 --nproc_per_node(及多机的 --nnodes 等)拉起多个进程,并注入 RANK / LOCAL_RANK / WORLD_SIZE 等环境变量。
rank / LOCAL_RANK / WORLD_SIZE
rank:全局进程编号(0 … WORLD_SIZE−1)。 LOCAL_RANK:本机内 GPU 编号,常对应 cuda:LOCAL_RANK。 WORLD_SIZE:总进程数(≈ 总 GPU 数,本配置一卡一进程)。
NCCL
NVIDIA 集合通信库。多卡梯度归约、广播等走 NCCL;DeepSpeed / DDP 底层常用它。
DeepSpeed ZeRO-2
微软 DeepSpeed 的显存优化:把优化器状态和梯度 按参数分片到各 rank(ZeRO-2),减少每卡冗余。本脚本 training_args.deepspeed=…/zero2.json。
HuggingFace Trainer
Transformers 库的训练循环封装(取 batch、forward、backward、日志、存盘)。 DreamZero 的 BaseTrainer 继承它,再接 DeepSpeed。
WAM(世界–动作模型)
World–Action Model:同一骨干上同时学「未来视频怎么变」和「动作怎么走」。 本页指 Wan 因果 DiT + 动作头的联合 flow matching。
VLA
Vision-Language-Action。DreamZero 外壳类名也叫 VLA; 本 DROID LoRA 配置里视觉–语言骨干是 Identity(占位),真正干活的是 WANPolicyHead。
Identity(IdentityBackbone)
无参数透传骨干:不加载 VLM 权重,只返回空特征以满足 VLA 接口,让 action head 自成一体。
DiT / CausalWanModel
DiT:Diffusion Transformer,用 Transformer 做生成骨干。 CausalWanModel:基于 Wan2.1-I2V-14B 改的块因果视频 DiT, 按时间块做因果注意力,并接动作通路。
LoRA
Low-Rank Adaptation:在冻结大模型权重旁插入低秩可训矩阵。本配置在 DiT 的 q/k/v/o/ffn 上挂 LoRA,显存与存盘远小于全量微调; save_lora_only=true 只写回这些增量与可训头。
VAE / CLIP / UMT5(T5)
本配置中均冻结的编码器: VAE 把视频压成 latent; CLIP(WanImageEncoder)编码首帧/图像条件; UMT5-XXL 编码语言指令。梯度不回传到它们。
三视角布局说明(语言包装)
Collator 不会只把短句「pick up the cup」送进 T5,而会扩成一段英文, 说明拼图里各区域对应哪路相机。DROID 大意是: top = wrist,bottom-left = left exterior,bottom-right = right exterior (训练时底行某一外置偶发黑屏/dropped)。这样语言条件与 2×2 拼图约定对齐。
tokenize / umt5 tokenize
tokenize:把字符串切成词表整数 id + mask,是喂 Transformer 前的步骤。 这里的「umt5 tokenize」用的是 UMT5 配套的开源 tokenizer (Hugging Face google/umt5-xxl),与后面冻结的 UMT5 编码器同一词表。 注意:UMT5 不只是分词器——它首先是完整的多语 T5 模型;分词只是其输入侧工具。
UMT5(开源吗 / 有啥好处)
开源:Google 发布,权重与 tokenizer 可在 Hugging Face google/umt5-xxl 获取(Apache-2.0 一类开源许可,以卡片为准)。 UMT5 = multilingual T5 模型(编码器-解码器);本配置冻结其编码器当语言塔, 好处是多语指令友好,且与 Wan I2V 官方文本塔一致,可直接复用预训练。
Flow matching
一类生成训练目标:在噪声与数据之间学一条速度/流场,比经典扩散表述更直接。 本配置对视频 latent 与动作各算一路,再相加反传。
DROID / LeRobot / parquet
DROID:开源机器人操作数据集。 LeRobot:Hugging Face 机器人数据格式与工具;本训练读其 episode 组织方式。 parquet:列式表文件,存状态/动作等;视频多在旁路 mp4。
shard / ShardedDataset
把数据切成片(shard),各 rank(及 DataLoader worker)按规则只认自己的片, 实现数据并行。进程内可有 RAM cache,但不跨 rank 共享。
DataLoader
PyTorch 取数管道:多进程 worker 预取、拼 batch、可选 pin_memory。 训练 step 的入口数据来自它。
checkpoint / save_lora_only
checkpoint:某一 step 落盘的可恢复权重与训练状态。 save_lora_only:只保存 LoRA 与可训头,不写整份 14B 基座,减小体积。
BC(行为克隆)
Behavior Cloning:用专家轨迹直接拟合动作(常见模仿学习基线)。 相对而言,本 WAM 还额外监督未来视频。