From 68d695d81d3deb90f1e96b252ddb22ccac397ddf Mon Sep 17 00:00:00 2001
From: qhy <2728290997@qq.com>
Date: Thu, 19 Feb 2026 15:35:09 +0800
Subject: [PATCH] =?UTF-8?q?=E4=BF=9D=E5=AD=98=E7=9A=84=E4=BC=98=E5=8C=96?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 record.md | 208 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 208 insertions(+)
 create mode 100644 record.md

diff --git a/record.md b/record.md
new file mode 100644
index 0000000..ed453d0
--- /dev/null
+++ b/record.md
@@ -0,0 +1,208 @@
+ 好，下面是完整的 decode 优化讲解。                                                                                                    
+                                                                                                                                        
+  ---                                                                                                                                   
+  背景：原始 decode 流程的问题
+                                                                                                                                        
+  原始代码中，每轮迭代的 world model 交互会调用 image_guided_synthesis_sim_mode，内部对DDIM 采样得到的 latent 做全量 VAE decode：     
+
+  # ddpms.py decode_core, perframe_ae=True
+  for index in range(z.shape[0]):  # 逐帧循环，16帧就调16次
+      frame_z = 1. / self.scale_factor * z[index:index+1]
+      frame_result = self.first_stage_model.decode(frame_z)
+      results.append(frame_result)
+
+  假设 8 轮迭代、每轮 16 帧，WM 路径 decode 128 次，policy 路径再 decode 128 次，共 256 次 VAE decode。每次都是同步阻塞的。
+
+  decode 完的视频还会被逐轮写成 mp4 + tensorboard，产生大量磁盘 I/O。最后还要把所有轮的 decoded video 在内存中torch.cat
+  拼接，再写一次完整视频。
+
+  ---
+  优化1：decode_video 开关——按需跳过 decode
+
+  文件： world_model_interaction.py函数 image_guided_synthesis_sim_mode
+
+  改动： 给函数加decode_video 参数（默认 False），返回值增加 raw samples：
+
+  def image_guided_synthesis_sim_mode(...,
+          decode_video: bool = False,  # 新增
+          ...) -> tuple[Tensor | None, Tensor, Tensor, Tensor | None]:
+
+      samples = None
+      if ddim_sampler is not None:
+          samples, actions, states, intermedia = ddim_sampler.sample(...)if decode_video:  # 条件 decode
+              batch_images = model.decode_first_stage(samples)
+              batch_variants = batch_images
+
+      return batch_variants, actions, states, samples# 多返回 samples
+
+  调用侧：
+  - Policy 路径：由 CLI 参数 --fast_policy_no_decode 控制，只需要 action 时可跳过 decode
+  - WM 交互路径：传decode_video=False，只拿 raw latent
+
+  效果： WM 路径每轮省掉 16 帧全量 decode。
+
+  ---
+  优化2：只decode observation 需要的帧
+
+  问题： WM 跳过了全量 decode，但下一轮的CLIP embedding 需要 pixel-space 图像做 observation。
+
+  改动： 只decode exe_steps 帧（通常 1帧），而不是全部 16 帧：
+
+  # WM 调用，不做全量 decode
+  pred_videos_1, _, pred_states, wm_samples = image_guided_synthesis_sim_mode(
+      ..., decode_video=False)
+
+  # 只 decode exe_steps 帧给 observation
+  obs_pixels = model.decode_first_stage(
+      wm_samples[:, :, :args.exe_steps, :, :])
+
+  for idx in range(args.exe_steps):
+      observation = {
+          'observation.images.top':obs_pixels[0, :, idx:idx + 1].permute(1, 0, 2, 3),
+          ...
+      }
+      cond_obs_queues = populate_queues(cond_obs_queues, observation)
+
+  关键细节： 必须逐帧填充 observation queue（idx:idx+1），不能全用最后一帧，否则 CLIP embedding 输入变了会影响精度。
+
+  效果： 每轮从 decode 16 帧降到 decode exe_steps 帧（省15 帧/轮）。
+
+  ---
+  优化3：decode stream——GPU 上并行 decode 和 UNet
+
+  问题： 写入最终视频仍需要完整 segment 的 pixel，这部分 decode 还是要做。
+
+  思路： 用独立 CUDA stream 做 segment decode，和下一轮 UNet 推断在 GPU 上并行。
+
+  改动：
+
+  初始化：
+  decode_stream = torch.cuda.Stream(device=device)
+  pending_decode = None
+
+  循环尾部：
+  # 收集上一轮 decode 结果
+  if pending_decode is not None:
+      decode_stream.synchronize()
+      write_q.put(pending_decode.cpu())
+      pending_decode = None
+
+  # 在 decode stream 上启动当前轮 segment decode（不阻塞主线程）
+  latent_slice = wm_samples[:, :, :args.exe_steps]
+  decode_stream.wait_stream(torch.cuda.current_stream())  # 确保 latent 就绪
+  with torch.cuda.stream(decode_stream):
+      pending_decode = model.decode_first_stage(latent_slice)
+  # 主线程立即进入下一轮 UNet
+
+  循环结束后收集最后一轮：
+  if pending_decode is not None:
+      decode_stream.synchronize()
+      write_q.put(pending_decode.cpu())
+
+  原理： decode_stream.wait_stream() 建立 stream间依赖，确保 latent 产出后才开始 decode。两个 stream 的 kernel 可以被GPU
+  调度器交错执行。
+
+  效果： segment decode 时间被下一轮 UNet 推断掩盖。
+
+  ---
+  优化4：Writer 进程——CPU 工作跨进程并行
+
+  问题： decode 完的tensor 需要转numpy + cv2 编码写盘，这是 CPU 密集型操作，Python GIL 限制线程并行。
+
+  改动：
+
+  辅助函数（主进程和子进程都能调用）：
+  def _video_tensor_to_frames(video: Tensor) -> np.ndarray:
+      video = torch.clamp(video.float(), -1., 1.)
+      n = video.shape[0]
+      video = video.permute(2, 0, 1, 3, 4)
+      frame_grids = [
+          torchvision.utils.make_grid(f, nrow=int(n), padding=0) for f in video
+      ]
+      grid = torch.stack(frame_grids, dim=0)
+      grid = ((grid + 1.0) / 2.0 * 255).to(torch.uint8).permute(0, 2, 3, 1)
+      return grid.numpy()[:, :, :, ::-1]  # RGB → BGR
+
+  Writer 进程：
+  def _video_writer_process(q: mp.Queue, filename: str, fps: int):
+      vwriter = None
+      while True:
+          item = q.get()
+          if item is None:  # sentinel，退出
+              break
+          frames = _video_tensor_to_frames(item)
+          if vwriter is None:
+              h, w = frames.shape[1], frames.shape[2]
+              fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+              vwriter = cv2.VideoWriter(filename, fourcc, fps, (w, h))
+          for f in frames:
+              vwriter.write(f)
+      if vwriter is not None:
+          vwriter.release()
+
+  主进程启动 writer：
+  write_q = mp.Queue()
+  writer_proc = mp.Process(target=_video_writer_process,
+                           args=(write_q, sample_full_video_file, args.save_fps))
+  writer_proc.start()
+
+  主进程通过 write_q.put(tensor.cpu()) 发送数据，循环结束发None sentinel 并join()。
+
+  效果：
+  - tensor→numpy 转换和cv2 编码不占主进程 CPU 时间
+  - 不受 GIL 限制
+  - cv2.VideoWriter 增量写入，不攒内存，不做最终 torch.cat
+  - Queue 自带背压，writer 处理不过来时 put 自然阻塞，不会 OOM
+
+  ---
+  同时删除的冗余 I/O
+
+  - 每轮迭代的 WM 中间tensorboard log（log_to_tensorboard_async）
+  - 每轮迭代的 WM 中间 mp4（save_results_async）
+  - 每轮迭代的 policy 中间 mp4
+  - 最终的 torch.cat + 一次性 save_results_async 写完整视频
+
+  ---
+  总结：优化前后对比
+
+  ┌─────────────────────┬────────────────────────┬───────────────────────────┐
+  │                     │          原始          │          优化后           │
+  ├─────────────────────┼────────────────────────┼───────────────────────────┤
+  │ WM decode帧数/轮    │ 16                     │ exe_steps（通常1）        │
+  ├─────────────────────┼────────────────────────┼───────────────────────────┤
+  │ segment decode 阻塞 │ 同步阻塞主线程         │ decode stream，GPU并行    │
+  ├─────────────────────┼────────────────────────┼───────────────────────────┤
+  │ tensor→numpy+写盘   │ 主线程同步/线程池(GIL) │ 独立进程，无GIL           │
+  ├─────────────────────┼────────────────────────┼───────────────────────────┤
+  │ 视频写入方式        │ 攒内存→cat→一次写      │ cv2增量追加写             │
+  ├─────────────────────┼────────────────────────┼───────────────────────────┤
+  │ 中间I/O             │ 每轮2×mp4+2×tb         │ 无                        │
+  ├─────────────────────┼────────────────────────┼───────────────────────────┤
+  │ 内存占用            │ 随迭代数线性增长       │ 恒定（不攒decoded video） │
+  └─────────────────────┴────────────────────────┴───────────────────────────┘
+
+✻ Cooked for 1m 31s                                                                                                                     
+  
+❯ 目前哪些优化是默认开启的                                                                                                              
+                                                                                                                                      
+● 让我检查各个优化的开关状态。                                                                                                          
+                                                                                                                                        
+● Searched for 2 patterns (ctrl+o to expand)                                                                                            
+                                                                                                                                      
+● 当前各优化的默认状态：                                                                                                                
+                                                                                                                                        
+  ┌───────────────────────────────────┬────────────┬────────────────────────────────────────────────────────┐                           
+  │               优化                │ 默认开启？ │                        控制方式                        │                         
+  ├───────────────────────────────────┼────────────┼────────────────────────────────────────────────────────┤                           
+  │ WM路径跳过全量decode              │ ✅ 是      │ 硬编码 decode_video=False（789行）                     │                           
+  ├───────────────────────────────────┼────────────┼────────────────────────────────────────────────────────┤
+  │ 只decode exe_steps帧给observation │ ✅ 是      │ 无开关，直接生效（792行）                              │
+  ├───────────────────────────────────┼────────────┼────────────────────────────────────────────────────────┤
+  │ decode stream GPU并行             │ ✅ 是      │ 无开关，直接生效（824-827行）                          │
+  ├───────────────────────────────────┼────────────┼────────────────────────────────────────────────────────┤
+  │ Writer进程增量写盘                │ ✅ 是      │ 无开关，直接生效（672-675行）                          │
+  ├───────────────────────────────────┼────────────┼────────────────────────────────────────────────────────┤
+  │ 删除中间wm mp4/tb保存             │ ✅ 是      │ 代码已删除                                             │
+  ├───────────────────────────────────┼────────────┼────────────────────────────────────────────────────────┤
+  │ Policy路径跳过decode              │ ❌ 否      │ 需传--fast_policy_no_decode（默认False，即默认decode） │
+  └───────────────────────────────────┴────────────┴────────────────────────────────────────────────────────┘
\ No newline at end of file