Add files using upload-large-folder tool

Helios/.gitignore

@@ -0,0 +1,43 @@
+*.py[cod]
+*.gif
+*.bmp
+*.mov
+*.mkv
+*.log
+*.zip
+*.pt
+*.pth
+*.ckpt
+*.safetensors
+*.backup
+*.pt
+*.pth
+*.ckpt
+*.pkl
+*.html
+*.pdf
+*.whl
+*.txt.gz
+!.gitignore
+!requirements.txt
+.DS_Store
+*DS_Store
+poetry.lock
+__pycache__/
+*.cache*
+*temp_path*
+*_ckpt
+*_results
+*temp
+*.pem
+*profile
+.gradio
+ablation_*
+cache
+wandb
+output_helios
+AMT-S.yaml
+bpe_simple_vocab_16e6.txt
+Videoreward
+1_formal_ckpts
+demo_data

Helios/LICENSE.txt

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

Helios/README.md

@@ -0,0 +1,594 @@
+<div align=center>
+<img src="https://raw.githubusercontent.com/SHYuanBest/shyuanbest_media/main/Helios/logo_white.png" width="300px">
+</div>
+
+<h1 align="center">Helios: Real Real-Time Long Video Generation Model</h1>
+
+<h5 align="center">⭐ 14B Real-Time Long Video Generation Model can be Cheaper, Faster but Keep Stronger than 1.3B ones ⭐</h5>
+
+<h5 align="center">
+
+[![arXiv](https://img.shields.io/badge/arXiv-2603.04379-b31b1b.svg?logo=arxiv)](https://arxiv.org/abs/2603.04379)
+[![hf_paper](https://img.shields.io/badge/🤗-Paper%20In%20HF-red.svg)](https://huggingface.co/papers/2603.04379)
+[![Project Page](https://img.shields.io/badge/Project-Website-2ea44f)](https://pku-yuangroup.github.io/Helios-Page)
+[![hf_space](https://img.shields.io/badge/🤗-Gradio-00b4d8.svg)](https://huggingface.co/spaces/BestWishYsh/Helios-14B-RealTime)
+[![HuggingFace](https://img.shields.io/badge/🤗-HuggingFace-blue)](https://huggingface.co/collections/BestWishYsh/helios)
+[![ModelScope](https://img.shields.io/badge/🤖-ModelScope-purple)](https://modelscope.cn/collections/BestWishYSH/Helios)
+[![GitHub](https://img.shields.io/badge/GitHub-black?logo=github)](https://github.com/PKU-YuanGroup/Helios)
+[![GitCode](https://img.shields.io/badge/GitCodes-blue?logo=gitcode)](https://gitcode.com/weixin_47617277/Helios)
+
+[![Ascend](https://img.shields.io/badge/Inference-Ascend--NPU-red)](https://www.hiascend.com/)
+[![Diffusers](https://img.shields.io/badge/Inference-Diffusers-blueviolet)](https://github.com/huggingface/diffusers/pull/13208)
+[![SGLang Diffusion](https://img.shields.io/badge/Backend-SGLang--Diffusion-yellow)](https://github.com/sgl-project/sglang/pull/19782)
+[![vLLM-Omni](https://img.shields.io/badge/Backend-vLLM--Omni-orange)](https://github.com/vllm-project/vllm-omni/pull/1604)
+
+
+
+</h5>
+
+<div align="center">
+This repository is the official implementation of Helios, which is a breakthrough video generation model that achieves minute-scale, high-quality video synthesis at <strong>19.5 FPS on a single H100 GPU</strong> (about 10 FPS on a single Ascend NPU) —without relying on conventional long video anti-drifting strategies or standard video acceleration techniques.
+</div>
+
+<br>
+
+## ✨ Highlights
+
+
+1. **Without commonly used anti-drifting strategies** (e.g., self-forcing, error-banks, keyframe sampling, or inverted sampling), Helios generates minute-scale videos with high quality and strong coherence.
+
+2. **Without standard acceleration techniques** (e.g., KV-cache, causal masking, sparse/linear attention, TinyVAE, progressive noise schedules, hidden-state caching, or quantization), Helios achieves 19.5 FPS in end-to-end inference on a single H100 GPU.
+
+3. **We introduce optimizations that improve both training and inference throughput while reducing memory consumption,** enabling image-diffusion-scale batch sizes during training while fitting up to four 14B models within 80 GB of GPU memory.
+
+
+
+## 🎬 Video Demos
+
+[![Demo Video of Helios](https://github.com/user-attachments/assets/1d10da4a-aba9-4ac1-ab02-cd0dfce8d35b)](https://www.youtube.com/watch?v=vd_AgHtOUFQ)
+or you can click <a href="https://github.com/PKU-YuanGroup/Helios-Page/blob/main/videos/helios_features.mp4">here</a> to get the video. Some best prompts are [here](./example/prompt.txt).
+
+
+## 📣 Latest News!!
+
+* `[2026.03.26]` 🔥 Add summary of FAQ, Tips, and Tutorals: https://github.com/PKU-YuanGroup/Helios/issues/47.
+* `[2026.03.24]` 👋 A community-made, unofficial YouTube tutorial for Helios is available [here](https://www.youtube.com/watch?v=AvFniggt6qg). It covers installation on a **consumer-grade PC** and supports **4K video generation**.
+* `[2026.03.20]` 🚀 Helios now supports [Ahead-of-Time Compilation (AOTI)](https://huggingface.co/blog/zerogpu-aoti) on Spaces, with special thanks to the HuggingFace Team! Please refer to [this Space](https://huggingface.co/spaces/BestWishYsh/Helios-14B-RealTime-AOTI) for a usage example.
+* `[2026.03.20]` 🔧 Based on [issue #38](https://github.com/PKU-YuanGroup/Helios/issues/38), we've identified several ways to further improve Helios's performance, such as fixing the i2v train-inference inconsistency and fully enabling Easy Anti-Drifting. Please refer to [commits](https://github.com/PKU-YuanGroup/Helios/commits/main/) and [correct.yaml](./scripts/training/configs/correct.yaml) for details.
+* `[2026.03.12]` ⚡️ Please note that real-time generation performance depends not only on the GPU, but also on the CPU, memory, CUDA driver version, etc. As [tested by a user](https://github.com/PKU-YuanGroup/Helios/issues/3#issuecomment-4034710182) on better hardware with single H100, Helios can reach up to **20.89 FPS**!
+* `[2026.03.08]` 🚀 Helios now fully supports [Group Offloading](#-group-offloading-to-save-vram) and [Context Parallelism](#-context-parallelism-on-multiple-gpus)! These features significantly optimize VRAM (**only ~6GB**) usage and enable inference across multiple GPUs with *Ulysses Attention*, *Ring Attention*, *Unified Attention*, and *Ulysses Anything Attention*.
+* `[2026.03.06]` 👋 [Cache-DiT](https://github.com/vipshop/cache-dit/pull/834) now supports Helios, it offers Fully Cache Acceleration and Parallelism support for Helios! Special thanks to the Cache-DiT Team for their amazing work.
+* `[2026.03.06]` 🔧 We fix the Parallel Inference logits for Helios, and provide an example [here](#-context-parallelism-on-multiple-gpus).
+* `[2026.03.06]` 🚀 We official release the [Gradio Demo](https://huggingface.co/spaces/BestWishYsh/Helios-14B-RealTime), welcome to try it.
+* `[2026.03.05]` 🔥 We are excited to announce the release of the Helios [technical report](https://arxiv.org/abs/2603.04379) on arXiv. We welcome discussions and feedback!
+* `[2026.03.04]` 👋 Day-0 support for [Ascend-NPU](https://www.hiascend.com)，with sincere gratitude to the Ascend Team for their support.
+* `[2026.03.04]` 👋 Day-0 support for [Diffusers](https://github.com/huggingface/diffusers/pull/13208)，with special thanks to the HuggingFace Team for their support.
+* `[2026.03.04]` 👋 Day-0 support for [SGLang-Diffusion](https://github.com/sgl-project/sglang/pull/19782)，with huge thanks to the SGLang Team for their support.
+* `[2026.03.04]` 👋 Day-0 support for [vLLM-Omni](https://github.com/vllm-project/vllm-omni/pull/1604)，with heartfelt gratitude to the vLLM Team for their support.
+* `[2026.03.04]` 🔥 We've released the training/inference code and weights of **Helios-Base**, **Helios-Mid** and **Helios-Distilled**.
+
+
+## 🔥 Friendly Links
+
+If your work has improved **Helios** and you would like more people to see it, please inform us.
+
+* [Ascend-NPU](https://www.hiascend.com/): Developed by Huawei, this hardware is designed for efficient AI model training and inference, boosting performance in tasks like computer vision, natural language processing, and autonomous driving.
+* [Diffusers](https://github.com/huggingface/diffusers/pull/13208): A popular library designed for working with diffusion models and other generative models in deep learning. It supports easy integration and manipulation of a wide range of generative models.
+* [SGLang-Diffusion](https://github.com/sgl-project/sglang/pull/19782): An inference framework for accelerated image and video generation using diffusion models. It provides an end-to-end unified pipeline with optimized kernels and an efficient scheduler loop.
+* [vLLM-Omni](https://github.com/vllm-project/vllm-omni/pull/1604): A fully disaggregated serving system for any-to-any models. vLLM-Omni breaks complex architectures into a stage-based graph, using a decoupled backend to maximize resource efficiency and throughput.
+* [Cache-DiT](https://github.com/vipshop/cache-dit/pull/834): A PyTorch-native and Flexible Inference Engine with Hybrid Cache Acceleration and Parallelism for DiTs. It built on top of the Diffusers library and now supports nearly ALL DiTs from Diffusers.
+
+## ⚙️ Requirements and Installation
+
+### Video Tutorial
+
+If you prefer a step-by-step walkthrough, check out this **community-made** [YouTube Tutorial](https://www.youtube.com/watch?v=AvFniggt6qg). It covers local installation, 4K video generation, and how to run Helios on a **consumer-grade PC**, along with other practical usage tips.
+
+### Prepare Environment
+
+```bash
+# 0. Clone the repo
+git clone --depth=1 https://github.com/PKU-YuanGroup/Helios.git
+cd Helios
+
+# 1. Create conda environment
+conda create -n helios python=3.11.2
+conda activate helios
+
+# 2. Install PyTorch (adjust for your CUDA version)
+# CUDA 12.6
+pip install torch==2.10.0 torchvision==0.25.0 torchaudio==2.10.0 --index-url https://download.pytorch.org/whl/cu126
+# CUDA 12.8
+pip install torch==2.10.0 torchvision==0.25.0 torchaudio==2.10.0 --index-url https://download.pytorch.org/whl/cu128
+# CUDA 13.0
+pip install torch==2.10.0 torchvision==0.25.0 torchaudio==2.10.0 --index-url https://download.pytorch.org/whl/cu130
+
+# 3. Install dependencies
+bash install.sh
+```
+
+### Model Download
+
+| Models           | Download Link                                                                                                                                            | Supports                                      | Notes                                                                                       |
+|------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------|---------------------------------------------------------------------------------------------|
+| Helios-Base      | 🤗 [Huggingface](https://huggingface.co/BestWishYsh/Helios-Base) 🤖 [ModelScope](https://modelscope.cn/models/BestWishYSH/Helios-Base)                | T2V ✅ I2V ✅ V2V ✅ Interactive ✅           | Best Quality, with v-prediction, standard CFG and custom HeliosScheduler.                   |
+| Helios-Mid       | 🤗 [Huggingface](https://huggingface.co/BestWishYsh/Helios-Mid) 🤖 [ModelScope](https://modelscope.cn/models/BestWishYSH/Helios-Mid)                  | T2V ✅ I2V ✅ V2V ✅ Interactive ✅           | Intermediate Ckpt, with v-prediction, CFG-Zero* and custom HeliosScheduler.                 |
+| Helios-Distilled | 🤗 [Huggingface](https://huggingface.co/BestWishYsh/Helios-Distilled) 🤖 [ModelScope](https://modelscope.cn/models/BestWishYSH/Helios-Distilled)      | T2V ✅ I2V ✅ V2V ✅ Interactive ✅           | Best Efficiency, with x0-prediction and custom HeliosDMDScheduler.                          |
+
+
+
+> 💡Note: 
+> * All three models share the same architecture, but Helios-Mid and Helios-Distilled use a more aggressive multi-scale sampling pipeline to achieve better efficiency.
+> * Helios-Mid is an intermediate checkpoint generated in the process of distilling Helios-Base into Helios-Distilled, and may not meet expected quality.
+> * For Image-to-Video or Video-to-Video, since training is based on Text-to-Video, these two functions may be slightly inferior to Text-to-Video. You may enable `is_skip_first_chunk` if you find the first few chunks are static or imporve the value of `image_noise_sigma_min`, `image_noise_sigma_max`, `video_noise_sigma_min`, and `video_noise_sigma_max`.
+
+
+Download models using huggingface-cli:
+``` sh
+pip install "huggingface_hub[cli]"
+huggingface-cli download BestWishYSH/Helios-Base --local-dir BestWishYSH/Helios-Base
+huggingface-cli download BestWishYSH/Helios-Mid --local-dir BestWishYSH/Helios-Mid
+huggingface-cli download BestWishYSH/Helios-Distilled --local-dir BestWishYSH/Helios-Distilled
+```
+
+Download models using modelscope-cli:
+``` sh
+pip install modelscope
+modelscope download BestWishYSH/Helios-Base --local_dir BestWishYSH/Helios-Base
+modelscope download BestWishYSH/Helios-Mid --local_dir BestWishYSH/Helios-Mid
+modelscope download BestWishYSH/Helios-Distilled --local_dir BestWishYSH/Helios-Distilled
+```
+
+## 🚀 Inference
+
+
+Helios uses an autoregressive approach that generates **33 frames per chunk**. For optimal performance, `num_frames` should be set to a multiple of `33`. If a non-multiple value is provided, it will be automatically rounded up to the nearest multiple of 33.
+
+**Example frame counts for different video lengths:**
+
+| num_frames | Adjusted Frames | 24 FPS | 16 FPS |
+|------------|-----------------|--------|--------|
+| 1449       | 1452 (33×44)    | ~60s (1min) | ~90s (1min 30s) |
+| 720        | 726 (33×22)     | ~30s | ~45s |
+| 240        | 264 (33×8)      | ~11s | ~16s |
+| 129        | 132 (33×4)      | ~5.5s | ~8s |
+| 81         | 99  (33×3)      | ~4s | ~6s |
+
+### Run the model
+
+We provide inference scripts for all models covering text-to-video, image-to-video, and video-to-video in this [directory](./scripts/inference).
+
+```bash
+cd scripts/inference
+
+# For Helios-Base
+bash helios-base_t2v.sh
+bash helios-base_i2v.sh
+bash helios-base_v2v.sh
+
+# For Helios-Mid
+bash helios-mid_t2v.sh
+bash helios-mid_i2v.sh
+bash helios-mid_v2v.sh
+
+# For Helios-Distilled
+bash helios-distilled_t2v.sh
+bash helios-distilled_i2v.sh
+bash helios-distilled_v2v.sh
+
+# For Interactive
+# ⚠️ This feature is still under development — results may not always meet expectations
+cd scripts/inference/experiment_interactive
+```
+
+### Sanity Check
+
+Before trying your own inputs, we highly recommend going through the sanity check to find out if any hardware or software went wrong.
+
+| Task    | **Helios-Base**                                                                                                            | **Helios-Mid**                                                                                                             | **Helios-Distilled**                                                                                                       |
+| ------- | -------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
+| **T2V** | <video src="https://github.com/user-attachments/assets/14e10753-0366-4790-ad8f-7b66d821ed11" controls width="240"></video> | <video src="https://github.com/user-attachments/assets/c1778691-a80b-428c-8094-88bb1dd1d52b" controls width="240"></video> | <video src="https://github.com/user-attachments/assets/4ca28c79-9dfa-49de-9c3a-f4c7b6c766cd" controls width="240"></video> |
+| **V2V** | <video src="https://github.com/user-attachments/assets/420cb572-85c2-42d8-98d7-37b0bc24c844" controls width="240"></video> | <video src="https://github.com/user-attachments/assets/7d703fa6-dc1a-4138-a897-e58cfd9236d6" controls width="240"></video> | <video src="https://github.com/user-attachments/assets/45329c55-1a25-459c-bbf0-4e584ec5b23d" controls width="240"></video> |
+
+
+### ✨ Group Offloading to Save VRAM
+
+Helios supports group offloading to significantly reduce VRAM consumption, allowing you to run on GPU with limited memory footprint. For more details on the underlying mechanics, please refer to the [documentation](https://huggingface.co/docs/diffusers/main/en/optimization/memory#group-offloading).
+
+The Helios model below requires `~6GB of VRAM`.
+
+<details>
+  <summary>Click to expand the code</summary>
+
+  ```bash
+  CUDA_VISIBLE_DEVICES=0 python infer_helios.py \
+      --base_model_path "BestWishYsh/Helios-Distilled" \
+      --transformer_path "BestWishYsh/Helios-Distilled" \
+      --sample_type "t2v" \
+      --prompt "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement." \
+      --num_frames 240 \
+      --guidance_scale 1.0 \
+      --is_enable_stage2 \
+      --pyramid_num_inference_steps_list 2 2 2 \
+      --is_amplify_first_chunk \
+      --output_folder "./output_helios/helios-distilled" \
+      --enable_low_vram_mode \
+      --group_offloading_type "leaf_level"
+  ```
+  
+</details>
+
+### ✨ Context Parallelism on Multiple GPUs
+Helios supports various Context Parallelism mechanisms, including `Ulysses Attention`, `Ring Attention`, `Unified Attention`, and `Ulysses Anything Attention`. For more details, please refer to the [documentation](https://huggingface.co/docs/diffusers/main/en/training/distributed_inference#context-parallelism).
+
+For example, let's take Helios-Base with 4 GPUs.
+
+<details>
+  <summary>Click to expand the code</summary>
+
+  ```bash
+  CUDA_VISIBLE_DEVICES=0,1,2,3 torchrun --nproc_per_node 4 infer_helios.py \
+      --enable_parallelism \     #  remember to enable this config
+      --cp_backend "ulysses" \   #  ["ring", "ulysses", "unified", "ulysses_anything"]
+      --base_model_path "BestWishYsh/Helios-Base" \
+      --transformer_path "BestWishYsh/Helios-Base" \
+      --sample_type "t2v" \
+      --num_frames 99 \
+      --fps 24 \
+      --prompt "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement." \
+      --guidance_scale 5.0 \
+      --output_folder "./output_helios/helios-base"
+  ```
+  
+</details>
+
+### ✨ Diffusers Pipeline
+
+Install diffusers from source:
+```bash
+pip install git+https://github.com/huggingface/diffusers.git
+```
+
+For example, let's take Helios-Distilled (**Standard Pipeline**).
+
+<details>
+  <summary>Click to expand the code</summary>
+
+  ```bash
+  import torch
+  from diffusers import AutoModel, HeliosPyramidPipeline
+  from diffusers.utils import export_to_video, load_video, load_image
+
+  vae = AutoModel.from_pretrained("BestWishYsh/Helios-Distilled", subfolder="vae", torch_dtype=torch.float32)
+
+  pipeline = HeliosPyramidPipeline.from_pretrained(
+      "BestWishYsh/Helios-Distilled",
+      vae=vae,
+      torch_dtype=torch.bfloat16
+  )
+  pipeline.to("cuda")
+
+  negative_prompt = """
+  Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality,
+  low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured,
+  misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards
+  """
+
+  # --- T2V ---
+  prompt = """
+  A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue 
+  and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with 
+  a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, 
+  allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades 
+  of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and 
+  the vivid colors of its surroundings. A close-up shot with dynamic movement.
+  """
+
+  output = pipeline(
+      prompt=prompt,
+      negative_prompt=negative_prompt,
+      num_frames=240,
+      pyramid_num_inference_steps_list=[2, 2, 2],
+      guidance_scale=1.0,
+      is_amplify_first_chunk=True,
+      generator=torch.Generator("cuda").manual_seed(42),
+  ).frames[0]
+  export_to_video(output, "helios_distilled_t2v_output.mp4", fps=24)
+
+  # --- I2V ---
+  i2v_prompt = """
+  A towering emerald wave surges forward, its crest curling with raw power and energy. Sunlight glints off the translucent water, 
+  illuminating the intricate textures and deep green hues within the wave’s body. A thick spray erupts from the breaking crest, 
+  casting a misty veil that dances above the churning surface. As the perspective widens, the immense scale of the wave becomes 
+  apparent, revealing the restless expanse of the ocean stretching beyond. The scene captures the ocean’s untamed beauty and 
+  relentless force, with every droplet and ripple shimmering in the light. The dynamic motion and vivid colors evoke both awe and 
+  respect for nature’s might.
+  """
+  image_path = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/helios/wave.jpg"
+
+  output = pipeline(
+      prompt=i2v_prompt,
+      negative_prompt=negative_prompt,
+      image=load_image(image_path).resize((640, 384)),
+      num_frames=240,
+      pyramid_num_inference_steps_list=[2, 2, 2],
+      guidance_scale=1.0,
+      is_amplify_first_chunk=True,
+      generator=torch.Generator("cuda").manual_seed(42),
+  ).frames[0]
+  export_to_video(output, "helios_distilled_i2v_output.mp4", fps=24)
+
+  # --- V2V ---
+  v2v_prompt = """
+  A bright yellow Lamborghini Huracn Tecnica speeds along a curving mountain road, surrounded by lush green trees 
+  under a partly cloudy sky. The car's sleek design and vibrant color stand out against the natural backdrop, 
+  emphasizing its dynamic movement. The road curves gently, with a guardrail visible on one side, adding depth to 
+  the scene. The motion blur captures the sense of speed and energy, creating a thrilling and exhilarating atmosphere. 
+  A front-facing shot from a slightly elevated angle, highlighting the car's aggressive stance and the surrounding greenery.
+  """
+  video_path = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/helios/car.mp4"
+
+  output = pipeline(
+      prompt=v2v_prompt,
+      negative_prompt=negative_prompt,
+      video=load_video(video_path),
+      num_frames=240,
+      pyramid_num_inference_steps_list=[2, 2, 2],
+      guidance_scale=1.0,
+      is_amplify_first_chunk=True,
+      generator=torch.Generator("cuda").manual_seed(42),
+  ).frames[0]
+  export_to_video(output, "helios_distilled_v2v_output.mp4", fps=24)
+  ```
+
+</details>
+
+For example, let's take Helios-Distilled (**Modular Pipeline**).
+
+<details>
+  <summary>Click to expand the code</summary>
+
+  ```bash
+  import torch
+  from diffusers import ModularPipeline, ClassifierFreeGuidance
+  from diffusers.utils import export_to_video, load_image, load_video
+
+  mod_pipe = ModularPipeline.from_pretrained("BestWishYsh/Helios-Distilled")
+  mod_pipe.load_components(torch_dtype=torch.bfloat16)
+  mod_pipe.to("cuda")
+
+  # we need to upload guider to the model repo, so each checkpoint will be able to config their guidance differently
+  guider = ClassifierFreeGuidance(guidance_scale=1.0)
+  mod_pipe.update_components(guider=guider)
+
+  # --- T2V ---
+  print("=== T2V ===")
+  prompt = (
+      "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. "
+      "The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving "
+      "fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and "
+      "sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef "
+      "itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures "
+      "the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. "
+      "A close-up shot with dynamic movement."
+  )
+
+  output = mod_pipe(
+      prompt=prompt,
+      height=384,
+      width=640,
+      num_frames=240,
+      pyramid_num_inference_steps_list=[2, 2, 2],
+      is_amplify_first_chunk=True,
+      generator=torch.Generator("cuda").manual_seed(42),
+      output="videos",
+  )
+
+  export_to_video(output[0], "helios_distilled_modular_t2v_output.mp4", fps=24)
+  print(f"T2V max memory: {torch.cuda.max_memory_allocated() / 1024**3:.3f} GB")
+  torch.cuda.empty_cache()
+  torch.cuda.reset_peak_memory_stats()
+
+  # --- I2V ---
+  print("=== I2V ===")
+  image = load_image(
+      "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/helios/wave.jpg"
+  )
+  i2v_prompt = (
+      "A towering emerald wave surges forward, its crest curling with raw power and energy. "
+      "Sunlight glints off the translucent water, illuminating the intricate textures and deep green hues within the wave's body."
+  )
+
+  output = mod_pipe(
+      prompt=i2v_prompt,
+      image=image,
+      height=384,
+      width=640,
+      num_frames=240,
+      pyramid_num_inference_steps_list=[2, 2, 2],
+      is_amplify_first_chunk=True,
+      generator=torch.Generator("cuda").manual_seed(42),
+      output="videos",
+  )
+
+  export_to_video(output[0], "helios_distilled_modular_i2v_output.mp4", fps=24)
+  print(f"I2V max memory: {torch.cuda.max_memory_allocated() / 1024**3:.3f} GB")
+  torch.cuda.empty_cache()
+  torch.cuda.reset_peak_memory_stats()
+
+  # --- V2V ---
+  print("=== V2V ===")
+  video = load_video(
+      "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/helios/car.mp4"
+  )
+  v2v_prompt = (
+      "A dynamic time-lapse video showing the rapidly moving scenery from the window of a speeding train. "
+      "The camera captures various elements such as lush green fields, towering trees, quaint countryside houses, "
+      "and distant mountain ranges passing by quickly."
+  )
+
+  output = mod_pipe(
+      prompt=v2v_prompt,
+      video=video,
+      height=384,
+      width=640,
+      num_frames=240,
+      pyramid_num_inference_steps_list=[2, 2, 2],
+      is_amplify_first_chunk=True,
+      generator=torch.Generator("cuda").manual_seed(42),
+      output="videos",
+  )
+
+  export_to_video(output[0], "helios_distilled_modular_v2v_output.mp4", fps=24)
+  print(f"V2V max memory: {torch.cuda.max_memory_allocated() / 1024**3:.3f} GB")
+  ```
+
+</details>
+
+### ✨ vLLM-Omni Pipeline
+
+Install vllm-omni from source:
+```bash
+pip install git+https://github.com/vllm-project/vllm-omni.git
+```
+
+For example, let's take Text-to-Video.
+
+<details>
+  <summary>Click to expand the code</summary>
+
+  ```bash
+  cd vllm-omni
+
+  # Helios-Base
+  python3 examples/offline_inference/helios/end2end.py \
+    --sample-type t2v \
+    --model ./Helios-Base \
+    --prompt "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement." \
+    --num-frames 99 \
+    --seed 42 \
+    --output helios_t2v_base.mp4
+
+  # Helios-Mid
+  python examples/offline_inference/helios/end2end.py \
+    --model ./Helios-Mid --sample-type t2v \
+    --prompt "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement." \
+    --guidance-scale 5.0 --is-enable-stage2 \
+    --pyramid-num-inference-steps-list 20 20 20 \
+    --num-frames 99 \
+    --use-cfg-zero-star --use-zero-init --zero-steps 1 \
+    --output helios_t2v_mid.mp4
+
+  # Helios-Distilled
+  python examples/offline_inference/helios/end2end.py \
+    --model ./Helios-Distilled --sample-type t2v \
+    --prompt "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement." \
+    --num-frames 240 --guidance-scale 1.0 --is-enable-stage2 \
+    --pyramid-num-inference-steps-list 2 2 2 \
+    --is-amplify-first-chunk --output helios_t2v_distilled.mp4
+  ```
+</details>
+
+### ✨ SGLang-Diffusion Pipeline
+
+Install sglang-diffusion from source:
+```bash
+pip install git+https://github.com/sgl-project/sglang.git
+```
+
+For example, let's take Helios-Base. **(Native Support)**
+
+<details>
+  <summary>Click to expand the code</summary>
+
+  ```bash
+  sglang generate \
+    --model-path BestWishYsh/Helios-Base \
+    --prompt "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement." \
+    --negative-prompt "Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards" \
+    --height 384 \
+    --width 640 \
+    --num-frames 99 \
+    --num-inference-steps 50 \
+    --guidance-scale 5.0
+  ```
+</details>
+
+For example, let's take Helios-Base. **(Diffusers Backend)**
+
+<details>
+  <summary>Click to expand the code</summary>
+
+  ```bash
+  sglang generate \
+    --model-path BestWishYsh/Helios-Base \
+    --prompt "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement." \
+    --negative-prompt "Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards" \
+    --height 384 \
+    --width 640 \
+    --num-frames 99 \
+    --num-inference-steps 50 \
+    --guidance-scale 5.0 \
+    --backend diffusers
+  ```
+</details>
+
+## 🗝️ Training
+
+We use a three-stage progressive pipeline, all the setting can be found [here](./scripts/training/configs/). Stage-1 (Base) performs architectural adaptation: we apply Unified History Injection, Easy Anti-Drifting, and Multi-Term Memory Patchification to convert the bidirectional pretrained model into an autoregressive generator. Stage-2 (Mid) targets token compression by introducing Pyramid Unified Predictor Corrector, which aggressively reduces the number of noisy tokens and thus the overall computation. Stage-3 (Distilled) applies Adversarial Hierarchical Distillation, reducing the sampling steps from 50 to 3 and eliminating the need for classifier-free guidance (CFG). Throughout training, we apply dynamic shifting to all timestep-dependent operations to match the noise schedule to the latent size.
+
+### Data Preparation
+
+Please refer to [this guide](./tools/offload_data/README.md) for how to obtain the training data required by Helios. And we prepare a toy training data [here](https://huggingface.co/BestWishYsh/HeliosBench-Weights/tree/main/demo_data).
+
+### Run the model
+
+```bash
+# Use DDP
+bash scripts/training/train_ddp.sh
+
+# or
+
+# Use DeepSpeed
+bash scripts/training/train_deepspeed.sh
+```
+
+Training configuration can be adjusted in `scripts/training/configs`. You can use `scripts/training/compare_yaml.py` to check for configuration completeness or differences between stages.
+
+### Model Merging
+
+After training, you can use this [script](./tools/merge_lora_for_helios.py) to merge all the checkpoints and obtain the final safetensors file, similar to [this](https://huggingface.co/BestWishYsh/Helios-Distilled/tree/main/transformer).
+
+
+## 📊 HeliosBench
+
+HeliosBench is a specialized benchmark for real-time long-video generation, please refer to [this guide](./eval/README.md) for how to eval your own model.
+
+
+## 👍 Acknowledgement
+
+This project wouldn't be possible without the following open-sourced repositories: [Open-Sora Plan](https://github.com/PKU-YuanGroup/Open-Sora-Plan), [Ascend](https://www.hiascend.com), [Diffusers](https://github.com/huggingface/diffusers), [vLLM-Omni](https://github.com/vllm-project/vllm), [SGLang Diffusion](https://github.com/sgl-project/sglang), [Wan](https://github.com/Wan-Video/Wan2.1), [FramePack](https://github.com/lllyasviel/FramePack), [PyramidFlow](https://github.com/jy0205/Pyramid-Flow), [DMD](https://github.com/tianweiy/DMD2).
+
+
+## 🔒 License
+
+This project is released under the Apache 2.0 license as found in the [LICENSE](LICENSE) file.
+
+## ✏️ Citation
+
+If you find our paper and code useful in your research, please consider giving a star ⭐ and citation 📝:
+
+```BibTeX
+@article{helios,
+  title={Helios: Real Real-Time Long Video Generation Model},
+  author={Yuan, Shenghai and Yin, Yuanyang and Li, Zongjian and Huang, Xinwei and Yang, Xiao and Yuan, Li},
+  journal={arXiv preprint arXiv:2603.04379},
+  year={2026}
+}
+```
+
+## 🤝 Contact
+
+For questions and feedback, please contact us at: shyuan-cs@hotmail.com
+
+

Helios/_DEV/.gitignore

@@ -0,0 +1,43 @@
+*.py[cod]
+*.gif
+*.bmp
+*.mov
+*.mkv
+*.log
+*.zip
+*.pt
+*.pth
+*.ckpt
+*.safetensors
+*.backup
+*.pt
+*.pth
+*.ckpt
+*.pkl
+*.html
+*.pdf
+*.whl
+*.txt.gz
+!.gitignore
+!requirements.txt
+.DS_Store
+*DS_Store
+poetry.lock
+__pycache__/
+*.cache*
+*temp_path*
+*_ckpt
+*_results
+*temp
+*.pem
+*profile
+.gradio
+ablation_*
+cache
+wandb
+output_helios
+AMT-S.yaml
+bpe_simple_vocab_16e6.txt
+Videoreward
+1_formal_ckpts
+demo_data

Helios/_DEV/LICENSE.txt

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

Helios/_DEV/README.md

@@ -0,0 +1,594 @@
+<div align=center>
+<img src="https://raw.githubusercontent.com/SHYuanBest/shyuanbest_media/main/Helios/logo_white.png" width="300px">
+</div>
+
+<h1 align="center">Helios: Real Real-Time Long Video Generation Model</h1>
+
+<h5 align="center">⭐ 14B Real-Time Long Video Generation Model can be Cheaper, Faster but Keep Stronger than 1.3B ones ⭐</h5>
+
+<h5 align="center">
+
+[![arXiv](https://img.shields.io/badge/arXiv-2603.04379-b31b1b.svg?logo=arxiv)](https://arxiv.org/abs/2603.04379)
+[![hf_paper](https://img.shields.io/badge/🤗-Paper%20In%20HF-red.svg)](https://huggingface.co/papers/2603.04379)
+[![Project Page](https://img.shields.io/badge/Project-Website-2ea44f)](https://pku-yuangroup.github.io/Helios-Page)
+[![hf_space](https://img.shields.io/badge/🤗-Gradio-00b4d8.svg)](https://huggingface.co/spaces/BestWishYsh/Helios-14B-RealTime)
+[![HuggingFace](https://img.shields.io/badge/🤗-HuggingFace-blue)](https://huggingface.co/collections/BestWishYsh/helios)
+[![ModelScope](https://img.shields.io/badge/🤖-ModelScope-purple)](https://modelscope.cn/collections/BestWishYSH/Helios)
+[![GitHub](https://img.shields.io/badge/GitHub-black?logo=github)](https://github.com/PKU-YuanGroup/Helios)
+[![GitCode](https://img.shields.io/badge/GitCodes-blue?logo=gitcode)](https://gitcode.com/weixin_47617277/Helios)
+
+[![Ascend](https://img.shields.io/badge/Inference-Ascend--NPU-red)](https://www.hiascend.com/)
+[![Diffusers](https://img.shields.io/badge/Inference-Diffusers-blueviolet)](https://github.com/huggingface/diffusers/pull/13208)
+[![SGLang Diffusion](https://img.shields.io/badge/Backend-SGLang--Diffusion-yellow)](https://github.com/sgl-project/sglang/pull/19782)
+[![vLLM-Omni](https://img.shields.io/badge/Backend-vLLM--Omni-orange)](https://github.com/vllm-project/vllm-omni/pull/1604)
+
+
+
+</h5>
+
+<div align="center">
+This repository is the official implementation of Helios, which is a breakthrough video generation model that achieves minute-scale, high-quality video synthesis at <strong>19.5 FPS on a single H100 GPU</strong> (about 10 FPS on a single Ascend NPU) —without relying on conventional long video anti-drifting strategies or standard video acceleration techniques.
+</div>
+
+<br>
+
+## ✨ Highlights
+
+
+1. **Without commonly used anti-drifting strategies** (e.g., self-forcing, error-banks, keyframe sampling, or inverted sampling), Helios generates minute-scale videos with high quality and strong coherence.
+
+2. **Without standard acceleration techniques** (e.g., KV-cache, causal masking, sparse/linear attention, TinyVAE, progressive noise schedules, hidden-state caching, or quantization), Helios achieves 19.5 FPS in end-to-end inference on a single H100 GPU.
+
+3. **We introduce optimizations that improve both training and inference throughput while reducing memory consumption,** enabling image-diffusion-scale batch sizes during training while fitting up to four 14B models within 80 GB of GPU memory.
+
+
+
+## 🎬 Video Demos
+
+[![Demo Video of Helios](https://github.com/user-attachments/assets/1d10da4a-aba9-4ac1-ab02-cd0dfce8d35b)](https://www.youtube.com/watch?v=vd_AgHtOUFQ)
+or you can click <a href="https://github.com/PKU-YuanGroup/Helios-Page/blob/main/videos/helios_features.mp4">here</a> to get the video. Some best prompts are [here](./example/prompt.txt).
+
+
+## 📣 Latest News!!
+
+* `[2026.03.26]` 🔥 Add summary of FAQ, Tips, and Tutorals: https://github.com/PKU-YuanGroup/Helios/issues/47.
+* `[2026.03.24]` 👋 A community-made, unofficial YouTube tutorial for Helios is available [here](https://www.youtube.com/watch?v=AvFniggt6qg). It covers installation on a **consumer-grade PC** and supports **4K video generation**.
+* `[2026.03.20]` 🚀 Helios now supports [Ahead-of-Time Compilation (AOTI)](https://huggingface.co/blog/zerogpu-aoti) on Spaces, with special thanks to the HuggingFace Team! Please refer to [this Space](https://huggingface.co/spaces/BestWishYsh/Helios-14B-RealTime-AOTI) for a usage example.
+* `[2026.03.20]` 🔧 Based on [issue #38](https://github.com/PKU-YuanGroup/Helios/issues/38), we've identified several ways to further improve Helios's performance, such as fixing the i2v train-inference inconsistency and fully enabling Easy Anti-Drifting. Please refer to [commits](https://github.com/PKU-YuanGroup/Helios/commits/main/) and [correct.yaml](./scripts/training/configs/correct.yaml) for details.
+* `[2026.03.12]` ⚡️ Please note that real-time generation performance depends not only on the GPU, but also on the CPU, memory, CUDA driver version, etc. As [tested by a user](https://github.com/PKU-YuanGroup/Helios/issues/3#issuecomment-4034710182) on better hardware with single H100, Helios can reach up to **20.89 FPS**!
+* `[2026.03.08]` 🚀 Helios now fully supports [Group Offloading](#-group-offloading-to-save-vram) and [Context Parallelism](#-context-parallelism-on-multiple-gpus)! These features significantly optimize VRAM (**only ~6GB**) usage and enable inference across multiple GPUs with *Ulysses Attention*, *Ring Attention*, *Unified Attention*, and *Ulysses Anything Attention*.
+* `[2026.03.06]` 👋 [Cache-DiT](https://github.com/vipshop/cache-dit/pull/834) now supports Helios, it offers Fully Cache Acceleration and Parallelism support for Helios! Special thanks to the Cache-DiT Team for their amazing work.
+* `[2026.03.06]` 🔧 We fix the Parallel Inference logits for Helios, and provide an example [here](#-context-parallelism-on-multiple-gpus).
+* `[2026.03.06]` 🚀 We official release the [Gradio Demo](https://huggingface.co/spaces/BestWishYsh/Helios-14B-RealTime), welcome to try it.
+* `[2026.03.05]` 🔥 We are excited to announce the release of the Helios [technical report](https://arxiv.org/abs/2603.04379) on arXiv. We welcome discussions and feedback!
+* `[2026.03.04]` 👋 Day-0 support for [Ascend-NPU](https://www.hiascend.com)，with sincere gratitude to the Ascend Team for their support.
+* `[2026.03.04]` 👋 Day-0 support for [Diffusers](https://github.com/huggingface/diffusers/pull/13208)，with special thanks to the HuggingFace Team for their support.
+* `[2026.03.04]` 👋 Day-0 support for [SGLang-Diffusion](https://github.com/sgl-project/sglang/pull/19782)，with huge thanks to the SGLang Team for their support.
+* `[2026.03.04]` 👋 Day-0 support for [vLLM-Omni](https://github.com/vllm-project/vllm-omni/pull/1604)，with heartfelt gratitude to the vLLM Team for their support.
+* `[2026.03.04]` 🔥 We've released the training/inference code and weights of **Helios-Base**, **Helios-Mid** and **Helios-Distilled**.
+
+
+## 🔥 Friendly Links
+
+If your work has improved **Helios** and you would like more people to see it, please inform us.
+
+* [Ascend-NPU](https://www.hiascend.com/): Developed by Huawei, this hardware is designed for efficient AI model training and inference, boosting performance in tasks like computer vision, natural language processing, and autonomous driving.
+* [Diffusers](https://github.com/huggingface/diffusers/pull/13208): A popular library designed for working with diffusion models and other generative models in deep learning. It supports easy integration and manipulation of a wide range of generative models.
+* [SGLang-Diffusion](https://github.com/sgl-project/sglang/pull/19782): An inference framework for accelerated image and video generation using diffusion models. It provides an end-to-end unified pipeline with optimized kernels and an efficient scheduler loop.
+* [vLLM-Omni](https://github.com/vllm-project/vllm-omni/pull/1604): A fully disaggregated serving system for any-to-any models. vLLM-Omni breaks complex architectures into a stage-based graph, using a decoupled backend to maximize resource efficiency and throughput.
+* [Cache-DiT](https://github.com/vipshop/cache-dit/pull/834): A PyTorch-native and Flexible Inference Engine with Hybrid Cache Acceleration and Parallelism for DiTs. It built on top of the Diffusers library and now supports nearly ALL DiTs from Diffusers.
+
+## ⚙️ Requirements and Installation
+
+### Video Tutorial
+
+If you prefer a step-by-step walkthrough, check out this **community-made** [YouTube Tutorial](https://www.youtube.com/watch?v=AvFniggt6qg). It covers local installation, 4K video generation, and how to run Helios on a **consumer-grade PC**, along with other practical usage tips.
+
+### Prepare Environment
+
+```bash
+# 0. Clone the repo
+git clone --depth=1 https://github.com/PKU-YuanGroup/Helios.git
+cd Helios
+
+# 1. Create conda environment
+conda create -n helios python=3.11.2
+conda activate helios
+
+# 2. Install PyTorch (adjust for your CUDA version)
+# CUDA 12.6
+pip install torch==2.10.0 torchvision==0.25.0 torchaudio==2.10.0 --index-url https://download.pytorch.org/whl/cu126
+# CUDA 12.8
+pip install torch==2.10.0 torchvision==0.25.0 torchaudio==2.10.0 --index-url https://download.pytorch.org/whl/cu128
+# CUDA 13.0
+pip install torch==2.10.0 torchvision==0.25.0 torchaudio==2.10.0 --index-url https://download.pytorch.org/whl/cu130
+
+# 3. Install dependencies
+bash install.sh
+```
+
+### Model Download
+
+| Models           | Download Link                                                                                                                                            | Supports                                      | Notes                                                                                       |
+|------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------|---------------------------------------------------------------------------------------------|
+| Helios-Base      | 🤗 [Huggingface](https://huggingface.co/BestWishYsh/Helios-Base) 🤖 [ModelScope](https://modelscope.cn/models/BestWishYSH/Helios-Base)                | T2V ✅ I2V ✅ V2V ✅ Interactive ✅           | Best Quality, with v-prediction, standard CFG and custom HeliosScheduler.                   |
+| Helios-Mid       | 🤗 [Huggingface](https://huggingface.co/BestWishYsh/Helios-Mid) 🤖 [ModelScope](https://modelscope.cn/models/BestWishYSH/Helios-Mid)                  | T2V ✅ I2V ✅ V2V ✅ Interactive ✅           | Intermediate Ckpt, with v-prediction, CFG-Zero* and custom HeliosScheduler.                 |
+| Helios-Distilled | 🤗 [Huggingface](https://huggingface.co/BestWishYsh/Helios-Distilled) 🤖 [ModelScope](https://modelscope.cn/models/BestWishYSH/Helios-Distilled)      | T2V ✅ I2V ✅ V2V ✅ Interactive ✅           | Best Efficiency, with x0-prediction and custom HeliosDMDScheduler.                          |
+
+
+
+> 💡Note: 
+> * All three models share the same architecture, but Helios-Mid and Helios-Distilled use a more aggressive multi-scale sampling pipeline to achieve better efficiency.
+> * Helios-Mid is an intermediate checkpoint generated in the process of distilling Helios-Base into Helios-Distilled, and may not meet expected quality.
+> * For Image-to-Video or Video-to-Video, since training is based on Text-to-Video, these two functions may be slightly inferior to Text-to-Video. You may enable `is_skip_first_chunk` if you find the first few chunks are static or imporve the value of `image_noise_sigma_min`, `image_noise_sigma_max`, `video_noise_sigma_min`, and `video_noise_sigma_max`.
+
+
+Download models using huggingface-cli:
+``` sh
+pip install "huggingface_hub[cli]"
+huggingface-cli download BestWishYSH/Helios-Base --local-dir BestWishYSH/Helios-Base
+huggingface-cli download BestWishYSH/Helios-Mid --local-dir BestWishYSH/Helios-Mid
+huggingface-cli download BestWishYSH/Helios-Distilled --local-dir BestWishYSH/Helios-Distilled
+```
+
+Download models using modelscope-cli:
+``` sh
+pip install modelscope
+modelscope download BestWishYSH/Helios-Base --local_dir BestWishYSH/Helios-Base
+modelscope download BestWishYSH/Helios-Mid --local_dir BestWishYSH/Helios-Mid
+modelscope download BestWishYSH/Helios-Distilled --local_dir BestWishYSH/Helios-Distilled
+```
+
+## 🚀 Inference
+
+
+Helios uses an autoregressive approach that generates **33 frames per chunk**. For optimal performance, `num_frames` should be set to a multiple of `33`. If a non-multiple value is provided, it will be automatically rounded up to the nearest multiple of 33.
+
+**Example frame counts for different video lengths:**
+
+| num_frames | Adjusted Frames | 24 FPS | 16 FPS |
+|------------|-----------------|--------|--------|
+| 1449       | 1452 (33×44)    | ~60s (1min) | ~90s (1min 30s) |
+| 720        | 726 (33×22)     | ~30s | ~45s |
+| 240        | 264 (33×8)      | ~11s | ~16s |
+| 129        | 132 (33×4)      | ~5.5s | ~8s |
+| 81         | 99  (33×3)      | ~4s | ~6s |
+
+### Run the model
+
+We provide inference scripts for all models covering text-to-video, image-to-video, and video-to-video in this [directory](./scripts/inference).
+
+```bash
+cd scripts/inference
+
+# For Helios-Base
+bash helios-base_t2v.sh
+bash helios-base_i2v.sh
+bash helios-base_v2v.sh
+
+# For Helios-Mid
+bash helios-mid_t2v.sh
+bash helios-mid_i2v.sh
+bash helios-mid_v2v.sh
+
+# For Helios-Distilled
+bash helios-distilled_t2v.sh
+bash helios-distilled_i2v.sh
+bash helios-distilled_v2v.sh
+
+# For Interactive
+# ⚠️ This feature is still under development — results may not always meet expectations
+cd scripts/inference/experiment_interactive
+```
+
+### Sanity Check
+
+Before trying your own inputs, we highly recommend going through the sanity check to find out if any hardware or software went wrong.
+
+| Task    | **Helios-Base**                                                                                                            | **Helios-Mid**                                                                                                             | **Helios-Distilled**                                                                                                       |
+| ------- | -------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
+| **T2V** | <video src="https://github.com/user-attachments/assets/14e10753-0366-4790-ad8f-7b66d821ed11" controls width="240"></video> | <video src="https://github.com/user-attachments/assets/c1778691-a80b-428c-8094-88bb1dd1d52b" controls width="240"></video> | <video src="https://github.com/user-attachments/assets/4ca28c79-9dfa-49de-9c3a-f4c7b6c766cd" controls width="240"></video> |
+| **V2V** | <video src="https://github.com/user-attachments/assets/420cb572-85c2-42d8-98d7-37b0bc24c844" controls width="240"></video> | <video src="https://github.com/user-attachments/assets/7d703fa6-dc1a-4138-a897-e58cfd9236d6" controls width="240"></video> | <video src="https://github.com/user-attachments/assets/45329c55-1a25-459c-bbf0-4e584ec5b23d" controls width="240"></video> |
+
+
+### ✨ Group Offloading to Save VRAM
+
+Helios supports group offloading to significantly reduce VRAM consumption, allowing you to run on GPU with limited memory footprint. For more details on the underlying mechanics, please refer to the [documentation](https://huggingface.co/docs/diffusers/main/en/optimization/memory#group-offloading).
+
+The Helios model below requires `~6GB of VRAM`.
+
+<details>
+  <summary>Click to expand the code</summary>
+
+  ```bash
+  CUDA_VISIBLE_DEVICES=0 python infer_helios.py \
+      --base_model_path "BestWishYsh/Helios-Distilled" \
+      --transformer_path "BestWishYsh/Helios-Distilled" \
+      --sample_type "t2v" \
+      --prompt "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement." \
+      --num_frames 240 \
+      --guidance_scale 1.0 \
+      --is_enable_stage2 \
+      --pyramid_num_inference_steps_list 2 2 2 \
+      --is_amplify_first_chunk \
+      --output_folder "./output_helios/helios-distilled" \
+      --enable_low_vram_mode \
+      --group_offloading_type "leaf_level"
+  ```
+  
+</details>
+
+### ✨ Context Parallelism on Multiple GPUs
+Helios supports various Context Parallelism mechanisms, including `Ulysses Attention`, `Ring Attention`, `Unified Attention`, and `Ulysses Anything Attention`. For more details, please refer to the [documentation](https://huggingface.co/docs/diffusers/main/en/training/distributed_inference#context-parallelism).
+
+For example, let's take Helios-Base with 4 GPUs.
+
+<details>
+  <summary>Click to expand the code</summary>
+
+  ```bash
+  CUDA_VISIBLE_DEVICES=0,1,2,3 torchrun --nproc_per_node 4 infer_helios.py \
+      --enable_parallelism \     #  remember to enable this config
+      --cp_backend "ulysses" \   #  ["ring", "ulysses", "unified", "ulysses_anything"]
+      --base_model_path "BestWishYsh/Helios-Base" \
+      --transformer_path "BestWishYsh/Helios-Base" \
+      --sample_type "t2v" \
+      --num_frames 99 \
+      --fps 24 \
+      --prompt "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement." \
+      --guidance_scale 5.0 \
+      --output_folder "./output_helios/helios-base"
+  ```
+  
+</details>
+
+### ✨ Diffusers Pipeline
+
+Install diffusers from source:
+```bash
+pip install git+https://github.com/huggingface/diffusers.git
+```
+
+For example, let's take Helios-Distilled (**Standard Pipeline**).
+
+<details>
+  <summary>Click to expand the code</summary>
+
+  ```bash
+  import torch
+  from diffusers import AutoModel, HeliosPyramidPipeline
+  from diffusers.utils import export_to_video, load_video, load_image
+
+  vae = AutoModel.from_pretrained("BestWishYsh/Helios-Distilled", subfolder="vae", torch_dtype=torch.float32)
+
+  pipeline = HeliosPyramidPipeline.from_pretrained(
+      "BestWishYsh/Helios-Distilled",
+      vae=vae,
+      torch_dtype=torch.bfloat16
+  )
+  pipeline.to("cuda")
+
+  negative_prompt = """
+  Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality,
+  low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured,
+  misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards
+  """
+
+  # --- T2V ---
+  prompt = """
+  A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue 
+  and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with 
+  a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, 
+  allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades 
+  of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and 
+  the vivid colors of its surroundings. A close-up shot with dynamic movement.
+  """
+
+  output = pipeline(
+      prompt=prompt,
+      negative_prompt=negative_prompt,
+      num_frames=240,
+      pyramid_num_inference_steps_list=[2, 2, 2],
+      guidance_scale=1.0,
+      is_amplify_first_chunk=True,
+      generator=torch.Generator("cuda").manual_seed(42),
+  ).frames[0]
+  export_to_video(output, "helios_distilled_t2v_output.mp4", fps=24)
+
+  # --- I2V ---
+  i2v_prompt = """
+  A towering emerald wave surges forward, its crest curling with raw power and energy. Sunlight glints off the translucent water, 
+  illuminating the intricate textures and deep green hues within the wave’s body. A thick spray erupts from the breaking crest, 
+  casting a misty veil that dances above the churning surface. As the perspective widens, the immense scale of the wave becomes 
+  apparent, revealing the restless expanse of the ocean stretching beyond. The scene captures the ocean’s untamed beauty and 
+  relentless force, with every droplet and ripple shimmering in the light. The dynamic motion and vivid colors evoke both awe and 
+  respect for nature’s might.
+  """
+  image_path = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/helios/wave.jpg"
+
+  output = pipeline(
+      prompt=i2v_prompt,
+      negative_prompt=negative_prompt,
+      image=load_image(image_path).resize((640, 384)),
+      num_frames=240,
+      pyramid_num_inference_steps_list=[2, 2, 2],
+      guidance_scale=1.0,
+      is_amplify_first_chunk=True,
+      generator=torch.Generator("cuda").manual_seed(42),
+  ).frames[0]
+  export_to_video(output, "helios_distilled_i2v_output.mp4", fps=24)
+
+  # --- V2V ---
+  v2v_prompt = """
+  A bright yellow Lamborghini Huracn Tecnica speeds along a curving mountain road, surrounded by lush green trees 
+  under a partly cloudy sky. The car's sleek design and vibrant color stand out against the natural backdrop, 
+  emphasizing its dynamic movement. The road curves gently, with a guardrail visible on one side, adding depth to 
+  the scene. The motion blur captures the sense of speed and energy, creating a thrilling and exhilarating atmosphere. 
+  A front-facing shot from a slightly elevated angle, highlighting the car's aggressive stance and the surrounding greenery.
+  """
+  video_path = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/helios/car.mp4"
+
+  output = pipeline(
+      prompt=v2v_prompt,
+      negative_prompt=negative_prompt,
+      video=load_video(video_path),
+      num_frames=240,
+      pyramid_num_inference_steps_list=[2, 2, 2],
+      guidance_scale=1.0,
+      is_amplify_first_chunk=True,
+      generator=torch.Generator("cuda").manual_seed(42),
+  ).frames[0]
+  export_to_video(output, "helios_distilled_v2v_output.mp4", fps=24)
+  ```
+
+</details>
+
+For example, let's take Helios-Distilled (**Modular Pipeline**).
+
+<details>
+  <summary>Click to expand the code</summary>
+
+  ```bash
+  import torch
+  from diffusers import ModularPipeline, ClassifierFreeGuidance
+  from diffusers.utils import export_to_video, load_image, load_video
+
+  mod_pipe = ModularPipeline.from_pretrained("BestWishYsh/Helios-Distilled")
+  mod_pipe.load_components(torch_dtype=torch.bfloat16)
+  mod_pipe.to("cuda")
+
+  # we need to upload guider to the model repo, so each checkpoint will be able to config their guidance differently
+  guider = ClassifierFreeGuidance(guidance_scale=1.0)
+  mod_pipe.update_components(guider=guider)
+
+  # --- T2V ---
+  print("=== T2V ===")
+  prompt = (
+      "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. "
+      "The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving "
+      "fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and "
+      "sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef "
+      "itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures "
+      "the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. "
+      "A close-up shot with dynamic movement."
+  )
+
+  output = mod_pipe(
+      prompt=prompt,
+      height=384,
+      width=640,
+      num_frames=240,
+      pyramid_num_inference_steps_list=[2, 2, 2],
+      is_amplify_first_chunk=True,
+      generator=torch.Generator("cuda").manual_seed(42),
+      output="videos",
+  )
+
+  export_to_video(output[0], "helios_distilled_modular_t2v_output.mp4", fps=24)
+  print(f"T2V max memory: {torch.cuda.max_memory_allocated() / 1024**3:.3f} GB")
+  torch.cuda.empty_cache()
+  torch.cuda.reset_peak_memory_stats()
+
+  # --- I2V ---
+  print("=== I2V ===")
+  image = load_image(
+      "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/helios/wave.jpg"
+  )
+  i2v_prompt = (
+      "A towering emerald wave surges forward, its crest curling with raw power and energy. "
+      "Sunlight glints off the translucent water, illuminating the intricate textures and deep green hues within the wave's body."
+  )
+
+  output = mod_pipe(
+      prompt=i2v_prompt,
+      image=image,
+      height=384,
+      width=640,
+      num_frames=240,
+      pyramid_num_inference_steps_list=[2, 2, 2],
+      is_amplify_first_chunk=True,
+      generator=torch.Generator("cuda").manual_seed(42),
+      output="videos",
+  )
+
+  export_to_video(output[0], "helios_distilled_modular_i2v_output.mp4", fps=24)
+  print(f"I2V max memory: {torch.cuda.max_memory_allocated() / 1024**3:.3f} GB")
+  torch.cuda.empty_cache()
+  torch.cuda.reset_peak_memory_stats()
+
+  # --- V2V ---
+  print("=== V2V ===")
+  video = load_video(
+      "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/helios/car.mp4"
+  )
+  v2v_prompt = (
+      "A dynamic time-lapse video showing the rapidly moving scenery from the window of a speeding train. "
+      "The camera captures various elements such as lush green fields, towering trees, quaint countryside houses, "
+      "and distant mountain ranges passing by quickly."
+  )
+
+  output = mod_pipe(
+      prompt=v2v_prompt,
+      video=video,
+      height=384,
+      width=640,
+      num_frames=240,
+      pyramid_num_inference_steps_list=[2, 2, 2],
+      is_amplify_first_chunk=True,
+      generator=torch.Generator("cuda").manual_seed(42),
+      output="videos",
+  )
+
+  export_to_video(output[0], "helios_distilled_modular_v2v_output.mp4", fps=24)
+  print(f"V2V max memory: {torch.cuda.max_memory_allocated() / 1024**3:.3f} GB")
+  ```
+
+</details>
+
+### ✨ vLLM-Omni Pipeline
+
+Install vllm-omni from source:
+```bash
+pip install git+https://github.com/vllm-project/vllm-omni.git
+```
+
+For example, let's take Text-to-Video.
+
+<details>
+  <summary>Click to expand the code</summary>
+
+  ```bash
+  cd vllm-omni
+
+  # Helios-Base
+  python3 examples/offline_inference/helios/end2end.py \
+    --sample-type t2v \
+    --model ./Helios-Base \
+    --prompt "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement." \
+    --num-frames 99 \
+    --seed 42 \
+    --output helios_t2v_base.mp4
+
+  # Helios-Mid
+  python examples/offline_inference/helios/end2end.py \
+    --model ./Helios-Mid --sample-type t2v \
+    --prompt "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement." \
+    --guidance-scale 5.0 --is-enable-stage2 \
+    --pyramid-num-inference-steps-list 20 20 20 \
+    --num-frames 99 \
+    --use-cfg-zero-star --use-zero-init --zero-steps 1 \
+    --output helios_t2v_mid.mp4
+
+  # Helios-Distilled
+  python examples/offline_inference/helios/end2end.py \
+    --model ./Helios-Distilled --sample-type t2v \
+    --prompt "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement." \
+    --num-frames 240 --guidance-scale 1.0 --is-enable-stage2 \
+    --pyramid-num-inference-steps-list 2 2 2 \
+    --is-amplify-first-chunk --output helios_t2v_distilled.mp4
+  ```
+</details>
+
+### ✨ SGLang-Diffusion Pipeline
+
+Install sglang-diffusion from source:
+```bash
+pip install git+https://github.com/sgl-project/sglang.git
+```
+
+For example, let's take Helios-Base. **(Native Support)**
+
+<details>
+  <summary>Click to expand the code</summary>
+
+  ```bash
+  sglang generate \
+    --model-path BestWishYsh/Helios-Base \
+    --prompt "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement." \
+    --negative-prompt "Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards" \
+    --height 384 \
+    --width 640 \
+    --num-frames 99 \
+    --num-inference-steps 50 \
+    --guidance-scale 5.0
+  ```
+</details>
+
+For example, let's take Helios-Base. **(Diffusers Backend)**
+
+<details>
+  <summary>Click to expand the code</summary>
+
+  ```bash
+  sglang generate \
+    --model-path BestWishYsh/Helios-Base \
+    --prompt "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement." \
+    --negative-prompt "Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards" \
+    --height 384 \
+    --width 640 \
+    --num-frames 99 \
+    --num-inference-steps 50 \
+    --guidance-scale 5.0 \
+    --backend diffusers
+  ```
+</details>
+
+## 🗝️ Training
+
+We use a three-stage progressive pipeline, all the setting can be found [here](./scripts/training/configs/). Stage-1 (Base) performs architectural adaptation: we apply Unified History Injection, Easy Anti-Drifting, and Multi-Term Memory Patchification to convert the bidirectional pretrained model into an autoregressive generator. Stage-2 (Mid) targets token compression by introducing Pyramid Unified Predictor Corrector, which aggressively reduces the number of noisy tokens and thus the overall computation. Stage-3 (Distilled) applies Adversarial Hierarchical Distillation, reducing the sampling steps from 50 to 3 and eliminating the need for classifier-free guidance (CFG). Throughout training, we apply dynamic shifting to all timestep-dependent operations to match the noise schedule to the latent size.
+
+### Data Preparation
+
+Please refer to [this guide](./tools/offload_data/README.md) for how to obtain the training data required by Helios. And we prepare a toy training data [here](https://huggingface.co/BestWishYsh/HeliosBench-Weights/tree/main/demo_data).
+
+### Run the model
+
+```bash
+# Use DDP
+bash scripts/training/train_ddp.sh
+
+# or
+
+# Use DeepSpeed
+bash scripts/training/train_deepspeed.sh
+```
+
+Training configuration can be adjusted in `scripts/training/configs`. You can use `scripts/training/compare_yaml.py` to check for configuration completeness or differences between stages.
+
+### Model Merging
+
+After training, you can use this [script](./tools/merge_lora_for_helios.py) to merge all the checkpoints and obtain the final safetensors file, similar to [this](https://huggingface.co/BestWishYsh/Helios-Distilled/tree/main/transformer).
+
+
+## 📊 HeliosBench
+
+HeliosBench is a specialized benchmark for real-time long-video generation, please refer to [this guide](./eval/README.md) for how to eval your own model.
+
+
+## 👍 Acknowledgement
+
+This project wouldn't be possible without the following open-sourced repositories: [Open-Sora Plan](https://github.com/PKU-YuanGroup/Open-Sora-Plan), [Ascend](https://www.hiascend.com), [Diffusers](https://github.com/huggingface/diffusers), [vLLM-Omni](https://github.com/vllm-project/vllm), [SGLang Diffusion](https://github.com/sgl-project/sglang), [Wan](https://github.com/Wan-Video/Wan2.1), [FramePack](https://github.com/lllyasviel/FramePack), [PyramidFlow](https://github.com/jy0205/Pyramid-Flow), [DMD](https://github.com/tianweiy/DMD2).
+
+
+## 🔒 License
+
+This project is released under the Apache 2.0 license as found in the [LICENSE](LICENSE) file.
+
+## ✏️ Citation
+
+If you find our paper and code useful in your research, please consider giving a star ⭐ and citation 📝:
+
+```BibTeX
+@article{helios,
+  title={Helios: Real Real-Time Long Video Generation Model},
+  author={Yuan, Shenghai and Yin, Yuanyang and Li, Zongjian and Huang, Xinwei and Yang, Xiao and Yuan, Li},
+  journal={arXiv preprint arXiv:2603.04379},
+  year={2026}
+}
+```
+
+## 🤝 Contact
+
+For questions and feedback, please contact us at: shyuan-cs@hotmail.com
+
+

Helios/_DEV/app.py

@@ -0,0 +1,322 @@
+import tempfile
+import time
+from pathlib import Path
+
+import gradio as gr
+import spaces
+import torch
+
+from torch.utils._pytree import tree_map
+from diffusers import AutoencoderKLWan, HeliosDMDScheduler, HeliosPyramidPipeline
+from diffusers.utils import export_to_video, load_image, load_video
+
+
+# ---------------------------------------------------------------------------
+# Pre-load model
+# ---------------------------------------------------------------------------
+PROJECT_ROOT = Path(__file__).resolve().parent
+MODEL_ID = str(PROJECT_ROOT / "checkpoints" / "Helios-Distilled")
+
+vae = AutoencoderKLWan.from_pretrained(MODEL_ID, subfolder="vae", torch_dtype=torch.float32)
+scheduler = HeliosDMDScheduler.from_pretrained(MODEL_ID, subfolder="scheduler")
+pipe = HeliosPyramidPipeline.from_pretrained(
+    MODEL_ID, vae=vae, scheduler=scheduler, torch_dtype=torch.bfloat16, is_distilled=True
+)
+pipe.to("cuda")
+
+cuda_major = torch.cuda.get_device_capability()[0]
+if cuda_major >= 9:
+    # H100/H800 (SM90+) with FA3
+    try:
+        pipe.transformer.set_attention_backend("_flash_3_hub")
+    except Exception:
+        pipe.transformer.set_attention_backend("flash_hub")
+else:
+    # 4090/A100 etc (SM89+) with FA2
+    pipe.transformer.set_attention_backend("flash_hub")
+
+# ---------------------------------------------------------------------------
+# AoTI
+# ---------------------------------------------------------------------------
+
+# Dynamic shapes: within a generation, only hidden_states H/W change across
+# pyramid stages (history latents stay at full resolution). text_seq_length
+# varies between different prompts.
+_AUTO = torch.export.Dim.AUTO
+
+TRANSFORMER_DYNAMIC_SHAPES = {
+    "hidden_states": {
+        3: _AUTO,  # H — doubles each pyramid stage
+        4: _AUTO,  # W — doubles each pyramid stage
+    },
+    "encoder_hidden_states": {
+        1: _AUTO,  # text_seq_length — varies with prompt
+    },
+}
+
+INDUCTOR_CONFIGS = {
+    "conv_1x1_as_mm": True,
+    "epilogue_fusion": False,
+    "coordinate_descent_tuning": True,
+    "coordinate_descent_check_all_directions": True,
+    # "max_autotune": True,
+    "triton.cudagraphs": True,
+}
+
+@spaces.GPU(duration=1500) # maximum duration allowed during startup
+def compile_transformer():
+    with spaces.aoti_capture(pipe.transformer) as call:
+        pipe(
+            "arbitrary example prompt",
+            height=384,
+            width=640,
+            num_frames=33,
+            guidance_scale=1.0,
+            generator=torch.Generator(device="cuda").manual_seed(42),
+            pyramid_num_inference_steps_list=[2, 2, 2],
+            is_amplify_first_chunk=True,
+        )
+
+    dynamic_shapes = tree_map(lambda t: None, call.kwargs)
+    dynamic_shapes |= TRANSFORMER_DYNAMIC_SHAPES
+
+    with torch.no_grad():
+        exported = torch.export.export(
+            pipe.transformer,
+            args=call.args,
+            kwargs=call.kwargs,
+            dynamic_shapes=dynamic_shapes,
+        )
+
+    return spaces.aoti_compile(exported, INDUCTOR_CONFIGS)
+
+compiled_transformer = compile_transformer()
+spaces.aoti_apply(compiled_transformer, pipe.transformer)
+
+
+# ---------------------------------------------------------------------------
+# Generation
+# ---------------------------------------------------------------------------
+@spaces.GPU(duration=60)
+def generate_video(
+    mode: str,
+    prompt: str,
+    image_input,
+    video_input,
+    height: int,
+    width: int,
+    num_frames: int,
+    num_inference_steps: int,
+    seed: int,
+    is_amplify_first_chunk: bool,
+    progress=gr.Progress(track_tqdm=True),
+):
+    if not prompt:
+        raise gr.Error("Please provide a prompt.")
+
+    generator = torch.Generator(device="cuda").manual_seed(int(seed))
+
+    kwargs = {
+        "prompt": prompt,
+        "height": int(height),
+        "width": int(width),
+        "num_frames": int(num_frames),
+        "guidance_scale": 1.0,
+        "generator": generator,
+        "output_type": "np",
+        "pyramid_num_inference_steps_list": [
+            int(num_inference_steps),
+            int(num_inference_steps),
+            int(num_inference_steps),
+        ],
+        "is_amplify_first_chunk": is_amplify_first_chunk,
+    }
+
+    if mode == "Image-to-Video" and image_input is not None:
+        img = load_image(image_input).resize((int(width), int(height)))
+        kwargs["image"] = img
+    elif mode == "Video-to-Video" and video_input is not None:
+        kwargs["video"] = load_video(video_input)
+
+    t0 = time.time()
+    output = pipe(**kwargs).frames[0]
+    elapsed = time.time() - t0
+
+    tmp = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
+    export_to_video(output, tmp.name, fps=24)
+    info = f"Generated in {elapsed:.1f}s · {num_frames} frames · {height}×{width}"
+    return tmp.name, info
+
+
+# ---------------------------------------------------------------------------
+# UI Setup
+# ---------------------------------------------------------------------------
+def update_conditional_visibility(mode):
+    if mode == "Image-to-Video":
+        return gr.update(visible=True), gr.update(visible=False)
+    elif mode == "Video-to-Video":
+        return gr.update(visible=False), gr.update(visible=True)
+    else:
+        return gr.update(visible=False), gr.update(visible=False)
+
+
+CSS = """
+#header { text-align: center; margin-bottom: 1.5em; }
+#header h1 { font-size: 2.2em; margin-bottom: 0.2em; }
+.logo { max-height: 100px; margin: 0 auto 10px auto; display: block; }
+.link-buttons { display: flex; justify-content: center; gap: 15px; margin-top: 10px; }
+.link-buttons a {
+    background-color: #2b3137;
+    color: #ffffff !important;
+    padding: 8px 20px;
+    border-radius: 6px;
+    text-decoration: none;
+    font-weight: 600;
+    font-size: 1em;
+    transition: all 0.2s ease-in-out;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+}
+.link-buttons a:hover { background-color: #4a535c; transform: translateY(-1px); }
+.contain { max-width: 1350px; margin: 0 auto !important; }
+"""
+
+with gr.Blocks(title="Helios Video Generation") as demo:
+    gr.HTML(
+        """
+        <div style='display: flex; align-items: center; justify-content: center; width: 100%;'>
+            <img src="https://raw.githubusercontent.com/SHYuanBest/shyuanbest_media/main/Helios/logo_white.png" style='width: 400px; height: auto;' />
+        </div>
+        <div id="header">
+            <h1>🎬 Helios 14B Distilled: Real Real-Time Long Video Generation Model</h1>
+            <p style="font-size: 1.1em; color: #666; margin-top: 0.5em; margin-bottom: 1em;">
+                If you like our project, please give us a star ⭐ on GitHub for the latest update.
+            </p>
+            <div class="link-buttons">
+                <a href="https://github.com/PKU-YuanGroup/Helios" target="_blank">💻 Code</a>
+                <a href="https://pku-yuangroup.github.io/Helios-Page" target="_blank">📄 Page</a>
+                <a href="https://www.youtube.com/watch?v=vd_AgHtOUFQ" target="_blank">🎥 Main Feature</a>
+                <a href="https://www.youtube.com/watch?v=1GeIU2Dn7UY" target="_blank">⚡ Inference Speed</a>
+            </div>
+        </div>
+        """
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            mode = gr.Radio(
+                choices=["Text-to-Video", "Image-to-Video", "Video-to-Video"],
+                value="Text-to-Video",
+                label="Generation Mode",
+            )
+            image_input = gr.Image(label="Image (for I2V)", type="filepath", visible=False)
+            video_input = gr.Video(label="Video (for V2V)", visible=False)
+            prompt = gr.Textbox(
+                label="Prompt",
+                lines=4,
+                value=(
+                    "A vibrant tropical fish swimming gracefully among colorful coral reefs in "
+                    "a clear, turquoise ocean. The fish has bright blue and yellow scales with a "
+                    "small, distinctive orange spot on its side, its fins moving fluidly. The coral "
+                    "reefs are alive with a variety of marine life, including small schools of "
+                    "colorful fish and sea turtles gliding by. The water is crystal clear, allowing "
+                    "for a view of the sandy ocean floor below. The reef itself is adorned with a mix "
+                    "of hard and soft corals in shades of red, orange, and green. The photo captures "
+                    "the fish from a slightly elevated angle, emphasizing its lively movements and the "
+                    "vivid colors of its surroundings. A close-up shot with dynamic movement."
+                ),
+            )
+            with gr.Accordion("Advanced Settings", open=False):
+                with gr.Row():
+                    height = gr.Number(value=384, label="Height", precision=0, interactive=False)
+                    width = gr.Number(value=640, label="Width", precision=0, interactive=False)
+                with gr.Row():
+                    num_frames = gr.Slider(33, 231, value=231, step=33, label="Num Frames")
+                    num_inference_steps = gr.Slider(1, 10, value=2, step=1, label="Steps per stage")
+                with gr.Row():
+                    seed = gr.Number(value=42, label="Seed", precision=0)
+                    is_amplify_first_chunk = gr.Checkbox(label="Amplify First Chunk", value=True)
+
+            generate_btn = gr.Button("🚀 Generate Video", variant="primary", size="lg")
+
+        with gr.Column(scale=1):
+            video_output = gr.Video(label="Generated Video", autoplay=True)
+            info_output = gr.Textbox(label="Info", interactive=False)
+
+    mode.change(fn=update_conditional_visibility, inputs=[mode], outputs=[image_input, video_input])
+    generate_btn.click(
+        fn=generate_video,
+        inputs=[
+            mode,
+            prompt,
+            image_input,
+            video_input,
+            height,
+            width,
+            num_frames,
+            num_inference_steps,
+            seed,
+            is_amplify_first_chunk,
+        ],
+        outputs=[video_output, info_output],
+    )
+
+    gr.Examples(
+        examples=[
+            [
+                "Text-to-Video",
+                "A vibrant tropical fish swimming gracefully among colorful coral reefs in "
+                "a clear, turquoise ocean. The fish has bright blue and yellow scales with a "
+                "small, distinctive orange spot on its side, its fins moving fluidly. The coral "
+                "reefs are alive with a variety of marine life, including small schools of "
+                "colorful fish and sea turtles gliding by. The water is crystal clear, allowing "
+                "for a view of the sandy ocean floor below. The reef itself is adorned with a mix "
+                "of hard and soft corals in shades of red, orange, and green. The photo captures "
+                "the fish from a slightly elevated angle, emphasizing its lively movements and the "
+                "vivid colors of its surroundings. A close-up shot with dynamic movement.",
+                None,
+                None,
+            ],
+            [
+                "Text-to-Video",
+                "An extreme close-up of an gray-haired man with a beard in his 60s, he is deep in "
+                "thought pondering the history of the universe as he sits at a cafe in Paris, his eyes "
+                "focus on people offscreen as they walk as he sits mostly motionless, he is dressed in "
+                "a wool coat suit coat with a button-down shirt , he wears a brown beret and glasses "
+                "and has a very professorial appearance, and the end he offers a subtle closed-mouth "
+                "smile as if he found the answer to the mystery of life, the lighting is very cinematic "
+                "with the golden light and the Parisian streets and city in the background, depth of "
+                "field, cinematic 35mm film.",
+                None,
+                None,
+            ],
+            [
+                "Text-to-Video",
+                "A drone camera circles around a beautiful historic church built on a rocky outcropping "
+                "along the Amalfi Coast, the view showcases historic and magnificent architectural "
+                "details and tiered pathways and patios, waves are seen crashing against the rocks "
+                "below as the view overlooks the horizon of the coastal waters and hilly landscapes "
+                "of the Amalfi Coast Italy, several distant people are seen walking and enjoying vistas "
+                "on patios of the dramatic ocean views, the warm glow of the afternoon sun creates a "
+                "magical and romantic feeling to the scene, the view is stunning captured with beautiful photography.",
+                None,
+                None,
+            ],
+            [
+                "Image-to-Video",
+                "A towering emerald wave surges forward, its crest curling with raw power and energy. Sunlight glints off the translucent water, illuminating the intricate textures and deep green hues within the wave’s body. A thick spray erupts from the breaking crest, casting a misty veil that dances above the churning surface. As the perspective widens, the immense scale of the wave becomes apparent, revealing the restless expanse of the ocean stretching beyond. The scene captures the ocean’s untamed beauty and relentless force, with every droplet and ripple shimmering in the light. The dynamic motion and vivid colors evoke both awe and respect for nature’s might.",
+                "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/helios/wave.jpg",
+                None,
+            ],
+            [
+                "Video-to-Video",
+                "A bright yellow Lamborghini Huracn Tecnica speeds along a curving mountain road, surrounded by lush green trees under a partly cloudy sky. The car's sleek design and vibrant color stand out against the natural backdrop, emphasizing its dynamic movement. The road curves gently, with a guardrail visible on one side, adding depth to the scene. The motion blur captures the sense of speed and energy, creating a thrilling and exhilarating atmosphere. A front-facing shot from a slightly elevated angle, highlighting the car's aggressive stance and the surrounding greenery.",
+                None,
+                "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/helios/car.mp4",
+            ],
+        ],
+        inputs=[mode, prompt, image_input, video_input],
+        label="Example Prompts",
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=True, css=CSS, theme=gr.themes.Soft())

Helios/_DEV/bench_infer.py

@@ -0,0 +1,569 @@
+"""
+Helios Benchmark Inference Script
+- Runs T2V inference for a single model version on a single GPU
+- Uses the first N prompts from a txt file
+- Saves videos in two layouts:  by_prompt/<slug>/<version>.mp4
+                                 by_version/<version>/<slug>.mp4
+- Records per-video timing to timing_<version>.txt and computes summary stats
+"""
+
+import importlib
+import os
+import re
+import shutil
+import sys
+import time
+
+os.environ["HF_ENABLE_PARALLEL_LOADING"] = "yes"
+os.environ["HF_PARALLEL_LOADING_WORKERS"] = "8"
+
+import argparse
+import subprocess
+from pathlib import Path
+
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+DEFAULT_PROMPT_FILE = SCRIPT_DIR / "demo_data" / "MovieGenVideoBench_extended.txt"
+DEFAULT_MODEL_ROOT = SCRIPT_DIR / "checkpoints"
+DEFAULT_OUTPUT_ROOT = SCRIPT_DIR / "output_helios" / "bench"
+
+
+def pick_gpu_by_free_vram(min_free_mib=20000):
+    """Pick physical GPU index with the most free memory (via nvidia-smi). No torch import."""
+    try:
+        out = subprocess.check_output(
+            [
+                "nvidia-smi",
+                "--query-gpu=index,memory.free",
+                "--format=csv,noheader,nounits",
+            ],
+            text=True,
+            stderr=subprocess.DEVNULL,
+        )
+    except (subprocess.CalledProcessError, FileNotFoundError) as e:
+        raise RuntimeError("nvidia-smi failed; specify --gpu explicitly") from e
+
+    best_idx, best_free = None, -1
+    for line in out.strip().splitlines():
+        parts = [p.strip() for p in line.split(",")]
+        if len(parts) < 2:
+            continue
+        idx, free = int(parts[0]), int(parts[1])
+        if free > best_free:
+            best_free, best_idx = free, idx
+    if best_idx is None:
+        raise RuntimeError("Could not parse nvidia-smi GPU list")
+    if best_free < min_free_mib:
+        print(
+            f"[warn] Best GPU {best_idx} has only {best_free} MiB free "
+            f"(<{min_free_mib} MiB); OOM risk — consider --enable_low_vram_mode",
+            file=sys.stderr,
+        )
+    return best_idx, best_free
+
+
+def _apply_cuda_visible_devices_before_torch():
+    """CUDA_VISIBLE_DEVICES must be set before `import torch` (first CUDA init)."""
+    pre = argparse.ArgumentParser(add_help=False)
+    pre.add_argument("--gpu", type=str, default="auto")
+    known, _ = pre.parse_known_args()
+    g = known.gpu.strip().lower()
+    if g == "auto":
+        idx, free = pick_gpu_by_free_vram()
+        os.environ["CUDA_VISIBLE_DEVICES"] = str(idx)
+        os.environ["_BENCH_PHYSICAL_GPU"] = f"{idx} ({free} MiB free)"
+    else:
+        os.environ["CUDA_VISIBLE_DEVICES"] = known.gpu.strip()
+        os.environ["_BENCH_PHYSICAL_GPU"] = known.gpu.strip()
+    os.environ["_BENCH_GPU_ARG"] = known.gpu.strip()
+
+
+_apply_cuda_visible_devices_before_torch()
+
+import torch
+from tqdm import tqdm
+
+if importlib.util.find_spec("torch_npu") is not None:
+    import torch_npu  # noqa: F401
+
+from helios.diffusers_version.pipeline_helios_diffusers import HeliosPipeline
+from helios.diffusers_version.scheduling_helios_diffusers import HeliosScheduler
+from helios.diffusers_version.transformer_helios_diffusers import HeliosTransformer3DModel
+from helios.modules.helios_kernels import (
+    replace_all_norms_with_flash_norms,
+    replace_rmsnorm_with_fp32,
+    replace_rope_with_flash_rope,
+)
+from diffusers.models import AutoencoderKLWan
+from diffusers.utils import export_to_video
+
+# ── per-version inference presets (matching official scripts) ─────────────────
+
+MODEL_PRESETS = {
+    "base": dict(
+        model_dir="Helios-Base",
+        num_frames=99,
+        num_inference_steps=50,
+        guidance_scale=5.0,
+        is_enable_stage2=False,
+        pyramid_num_inference_steps_list=[20, 20, 20],
+        is_amplify_first_chunk=False,
+        use_zero_init=False,
+        zero_steps=1,
+    ),
+    "mid": dict(
+        model_dir="Helios-Mid",
+        num_frames=99,
+        num_inference_steps=50,
+        guidance_scale=5.0,
+        is_enable_stage2=True,
+        pyramid_num_inference_steps_list=[20, 20, 20],
+        is_amplify_first_chunk=False,
+        use_zero_init=True,
+        zero_steps=1,
+    ),
+    "distilled": dict(
+        model_dir="Helios-Distilled",
+        num_frames=240,
+        num_inference_steps=50,
+        guidance_scale=1.0,
+        is_enable_stage2=True,
+        pyramid_num_inference_steps_list=[2, 2, 2],
+        is_amplify_first_chunk=True,
+        use_zero_init=False,
+        zero_steps=1,
+    ),
+}
+
+NEGATIVE_PROMPT = (
+    "Bright tones, overexposed, static, blurred details, subtitles, style, "
+    "works, paintings, images, static, overall gray, worst quality, low quality, "
+    "JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, "
+    "poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, "
+    "still picture, messy background, three legs, many people in the background, "
+    "walking backwards"
+)
+
+
+def sanitize_filename(text, max_len=80):
+    """Turn a prompt into a filesystem-safe slug."""
+    text = text.strip().lower()
+    text = re.sub(r"[^a-z0-9]+", "_", text)
+    text = text.strip("_")
+    return text[:max_len]
+
+
+def load_prompt_indices(path):
+    indices = []
+    with open(path, "r", encoding="utf-8") as f:
+        for line_no, raw_line in enumerate(f, start=1):
+            line = raw_line.strip()
+            if not line or line.startswith("#"):
+                continue
+            try:
+                idx = int(line)
+            except ValueError as exc:
+                raise ValueError(
+                    f"Invalid prompt index at {path}:{line_no}: {line!r}"
+                ) from exc
+            if idx < 0:
+                raise ValueError(f"Prompt index must be >= 0 at {path}:{line_no}")
+            indices.append(idx)
+    return indices
+
+
+def load_prompts(path, prompt_start=0, prompt_end=None, prompt_indices=None):
+    with open(path, "r", encoding="utf-8") as f:
+        lines = [line.strip() for line in f if line.strip()]
+    if prompt_indices is not None:
+        selected = []
+        total = len(lines)
+        for idx in prompt_indices:
+            if idx >= total:
+                raise ValueError(
+                    f"Prompt index {idx} is out of range; prompt file has {total} prompts"
+                )
+            selected.append((idx, lines[idx]))
+        return selected
+
+    if prompt_start < 0:
+        raise ValueError("prompt_start must be >= 0")
+    if prompt_end is not None and prompt_end < prompt_start:
+        raise ValueError("prompt_end must be >= prompt_start")
+
+    selected = lines[prompt_start:prompt_end]
+    return [(prompt_start + offset, prompt) for offset, prompt in enumerate(selected)]
+
+
+def build_expected_outputs(prompts, version, by_version_dir):
+    version_dir = os.path.join(by_version_dir, version)
+    expected = []
+    for idx, prompt in prompts:
+        slug = sanitize_filename(prompt)
+        vid_name = f"{idx:04d}_{slug}"
+        expected.append((idx, slug, os.path.join(version_dir, f"{vid_name}.mp4")))
+    return version_dir, expected
+
+
+def output_exists(path):
+    return os.path.isfile(path) and os.path.getsize(path) > 0
+
+
+def find_missing_outputs(expected_outputs):
+    return [item for item in expected_outputs if not output_exists(item[2])]
+
+
+def make_timing_line(version, idx, elapsed, slug):
+    return (
+        f"  {version:10s}  #{idx:04d}  {elapsed:8.2f}s  "
+        f"({elapsed / 60:5.2f}min)  {slug[:50]}"
+    )
+
+
+def load_existing_timing_records(timing_file, version):
+    if not os.path.exists(timing_file):
+        return {}
+
+    pattern = re.compile(
+        rf"^\s*{re.escape(version)}\s+#(\d+)\s+([0-9.]+)s\s+\([^)]+\)\s+(.*)$"
+    )
+    records = {}
+    with open(timing_file, "r", encoding="utf-8") as f:
+        for raw_line in f:
+            line = raw_line.rstrip("\n")
+            match = pattern.match(line)
+            if not match:
+                continue
+            idx = int(match.group(1))
+            elapsed = float(match.group(2))
+            slug = match.group(3)
+            records[idx] = (elapsed, slug)
+    return records
+
+
+def build_pipeline(
+    model_path,
+    device,
+    weight_dtype,
+    enable_low_vram=False,
+    group_offloading_type="leaf_level",
+    num_blocks_per_group=4,
+):
+    transformer = HeliosTransformer3DModel.from_pretrained(
+        model_path, subfolder="transformer", torch_dtype=weight_dtype,
+    )
+    transformer = replace_rmsnorm_with_fp32(transformer)
+    transformer = replace_all_norms_with_flash_norms(transformer)
+    replace_rope_with_flash_rope()
+
+    cuda_major = torch.cuda.get_device_capability()[0]
+    if cuda_major >= 9:
+        try:
+            transformer.set_attention_backend("_flash_3_hub")
+        except Exception:
+            transformer.set_attention_backend("flash_hub")
+    else:
+        transformer.set_attention_backend("flash_hub")
+
+    vae = AutoencoderKLWan.from_pretrained(
+        model_path, subfolder="vae", torch_dtype=torch.float32,
+    )
+    scheduler = HeliosScheduler.from_pretrained(model_path, subfolder="scheduler")
+
+    pipe = HeliosPipeline.from_pretrained(
+        model_path,
+        transformer=transformer,
+        vae=vae,
+        scheduler=scheduler,
+        torch_dtype=weight_dtype,
+    )
+    if enable_low_vram:
+        nbg = int(num_blocks_per_group) if group_offloading_type == "block_level" else None
+        pipe.enable_group_offload(
+            onload_device=torch.device("cuda"),
+            offload_device=torch.device("cpu"),
+            offload_type=group_offloading_type,
+            num_blocks_per_group=nbg,
+            use_stream=True,
+            record_stream=True,
+        )
+    else:
+        pipe = pipe.to(device)
+    return pipe
+
+
+def run_single(pipe, prompt, preset, height, width, seed):
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+
+    t0 = time.time()
+    with torch.no_grad():
+        output = pipe(
+            prompt=prompt,
+            negative_prompt=NEGATIVE_PROMPT,
+            height=height,
+            width=width,
+            num_frames=preset["num_frames"],
+            num_inference_steps=preset["num_inference_steps"],
+            guidance_scale=preset["guidance_scale"],
+            generator=gen,
+            history_sizes=[16, 2, 1],
+            num_latent_frames_per_chunk=9,
+            keep_first_frame=True,
+            is_enable_stage2=preset["is_enable_stage2"],
+            pyramid_num_inference_steps_list=preset["pyramid_num_inference_steps_list"],
+            is_skip_first_chunk=False,
+            is_amplify_first_chunk=preset["is_amplify_first_chunk"],
+            use_zero_init=preset["use_zero_init"],
+            zero_steps=preset["zero_steps"],
+        ).frames[0]
+    elapsed = time.time() - t0
+    return output, elapsed
+
+
+def _parse_gpu(s):
+    if isinstance(s, str) and s.lower() == "auto":
+        return "auto"
+    return int(s)
+
+
+def parse_args():
+    p = argparse.ArgumentParser(description="Helios benchmark inference for one model version")
+    p.add_argument("--prompt_file", type=str,
+                    default=str(DEFAULT_PROMPT_FILE))
+    p.add_argument("--prompt_start", type=int, default=0)
+    p.add_argument("--prompt_end", type=int, default=100,
+                    help="Exclusive end index for prompts, e.g. 50 means up to #49")
+    p.add_argument("--prompt_indices_file", type=str, default=None,
+                    help="Optional file containing exact prompt indices to run, one per line")
+    p.add_argument("--model_root", type=str, default=str(DEFAULT_MODEL_ROOT),
+                    help="Parent dir containing Helios-Base / Helios-Mid / Helios-Distilled")
+    p.add_argument("--output_root", type=str, default=str(DEFAULT_OUTPUT_ROOT))
+    p.add_argument("--version", type=str, choices=sorted(MODEL_PRESETS.keys()), required=True,
+                    help="Which model version to run")
+    p.add_argument("--timing_file", type=str, default=None,
+                    help="Optional override for timing report path")
+    p.add_argument("--height", type=int, default=384)
+    p.add_argument("--width", type=int, default=640)
+    p.add_argument("--num_frames", type=int, default=None,
+                    help="Override preset frame count for all selected versions")
+    p.add_argument("--seed", type=int, default=42)
+    p.add_argument(
+        "--gpu",
+        type=_parse_gpu,
+        default="auto",
+        help='Physical GPU id or "auto" (pick most free VRAM via nvidia-smi)',
+    )
+    p.add_argument(
+        "--enable_low_vram_mode",
+        action="store_true",
+        help="CPU group-offload (slower, less VRAM); use if GPU is shared or OOM",
+    )
+    p.add_argument(
+        "--group_offloading_type",
+        type=str,
+        choices=["leaf_level", "block_level"],
+        default="leaf_level",
+    )
+    p.add_argument("--num_blocks_per_group", type=int, default=4)
+    return p.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    if not os.path.isfile(args.prompt_file):
+        raise FileNotFoundError(f"Prompt file not found: {args.prompt_file}")
+    if not os.path.isdir(args.model_root):
+        raise FileNotFoundError(f"Model root not found: {args.model_root}")
+
+    os.environ["CUDA_VISIBLE_DEVICES"] = str(args.gpu)
+    device = torch.device("cuda")
+    weight_dtype = torch.bfloat16
+
+    prompt_indices = None
+    if args.prompt_indices_file:
+        if not os.path.isfile(args.prompt_indices_file):
+            raise FileNotFoundError(f"Prompt indices file not found: {args.prompt_indices_file}")
+        prompt_indices = load_prompt_indices(args.prompt_indices_file)
+
+    prompts = load_prompts(
+        args.prompt_file,
+        args.prompt_start,
+        args.prompt_end,
+        prompt_indices=prompt_indices,
+    )
+    prompt_map = dict(prompts)
+    if args.prompt_indices_file:
+        print(
+            f"Loaded {len(prompts)} prompts from {args.prompt_file} "
+            f"(indices: {args.prompt_indices_file})"
+        )
+    else:
+        print(
+            f"Loaded {len(prompts)} prompts from {args.prompt_file} "
+            f"(range: {args.prompt_start}:{args.prompt_end})"
+        )
+
+    if args.num_frames is not None:
+        MODEL_PRESETS[args.version]["num_frames"] = args.num_frames
+
+    by_prompt_dir = os.path.join(args.output_root, "by_prompt")
+    by_version_dir = os.path.join(args.output_root, "by_version")
+    timing_file = args.timing_file or os.path.join(args.output_root, f"timing_{args.version}.txt")
+    os.makedirs(args.output_root, exist_ok=True)
+
+    preset = MODEL_PRESETS[args.version]
+    model_path = os.path.join(args.model_root, preset["model_dir"])
+    timing_records = load_existing_timing_records(timing_file, args.version)
+    selected_indices = set(prompt_map)
+    timing_records = {
+        idx: record for idx, record in timing_records.items() if idx in selected_indices
+    }
+    ver_dir, expected_outputs = build_expected_outputs(prompts, args.version, by_version_dir)
+    missing_outputs = find_missing_outputs(expected_outputs)
+    if not os.path.isdir(model_path):
+        raise FileNotFoundError(f"Model not found: {model_path}")
+
+    peak_mem = None
+    if not missing_outputs:
+        print(
+            f"[SKIP] All outputs already exist for version={args.version} under {ver_dir}"
+        )
+    else:
+        header = (
+            f"\n{'=' * 60}\n"
+            f"  Version: {args.version}  |  Model: {preset['model_dir']}\n"
+            f"  Frames: {preset['num_frames']}  |  guidance_scale: {preset['guidance_scale']}\n"
+            f"  stage2: {preset['is_enable_stage2']}  |  pyramid_steps: {preset['pyramid_num_inference_steps_list']}\n"
+            f"{'=' * 60}\n"
+        )
+        print(header)
+
+        pipe = build_pipeline(
+            model_path,
+            device,
+            weight_dtype,
+            enable_low_vram=args.enable_low_vram_mode,
+            group_offloading_type=args.group_offloading_type,
+            num_blocks_per_group=args.num_blocks_per_group,
+        )
+
+        os.makedirs(ver_dir, exist_ok=True)
+
+        print(
+            f"[resume] version={args.version} existing={len(expected_outputs) - len(missing_outputs)} "
+            f"missing={len(missing_outputs)} timed={len(timing_records)}"
+        )
+        for idx, slug, ver_out in tqdm(missing_outputs, desc=f"[{args.version}]"):
+            if os.path.exists(ver_out):
+                print(f"  [skip] {ver_out}")
+                continue
+
+            try:
+                frames, elapsed = run_single(
+                    pipe, prompt_map[idx], preset, args.height, args.width, args.seed,
+                )
+            except Exception as e:
+                msg = f"  [FAIL] {args.version} #{idx:04d}: {e}"
+                print(msg)
+                continue
+
+            export_to_video(frames, ver_out, fps=24)
+
+            vid_name = os.path.splitext(os.path.basename(ver_out))[0]
+            prompt_dir = os.path.join(by_prompt_dir, vid_name)
+            os.makedirs(prompt_dir, exist_ok=True)
+            shutil.copy2(ver_out, os.path.join(prompt_dir, f"{args.version}.mp4"))
+
+            timing_records[idx] = (elapsed, slug)
+            print(make_timing_line(args.version, idx, elapsed, slug))
+
+        peak_mem = torch.cuda.max_memory_allocated() / 1024 ** 3
+        print(f"  >> [{args.version}] peak GPU memory: {peak_mem:.2f} GB")
+
+        del pipe
+        torch.cuda.empty_cache()
+        torch.cuda.reset_peak_memory_stats()
+
+    sorted_records = [timing_records[idx] for idx in sorted(timing_records)]
+    all_timings = [elapsed for elapsed, _ in sorted_records]
+
+    with open(timing_file, "w", encoding="utf-8") as tf:
+        tf.write(f"{'=' * 80}\n")
+        tf.write(f"  Helios Benchmark Inference Timing Report\n")
+        tf.write(f"  {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
+        tf.write(
+            f"  Prompts: {len(prompts)}  |  Range: {args.prompt_start}:{args.prompt_end}  "
+            f"|  Version: {args.version}\n"
+        )
+        if args.prompt_indices_file:
+            tf.write(f"  Prompt indices file: {args.prompt_indices_file}\n")
+        tf.write(
+            f"  Resolution: {args.width}x{args.height}  |  Seed: {args.seed}  |  "
+            f"GPU: {args.gpu}  |  low_vram: {args.enable_low_vram_mode}\n"
+        )
+        tf.write(f"{'=' * 80}\n\n")
+
+        tf.write(
+            f"\n{'=' * 60}\n"
+            f"  Version: {args.version}  |  Model: {preset['model_dir']}\n"
+            f"  Frames: {preset['num_frames']}  |  guidance_scale: {preset['guidance_scale']}\n"
+            f"  stage2: {preset['is_enable_stage2']}  |  pyramid_steps: {preset['pyramid_num_inference_steps_list']}\n"
+            f"{'=' * 60}\n"
+        )
+        tf.write(
+            f"  Existing timing records: {len(timing_records)} / expected outputs: {len(expected_outputs)}\n"
+        )
+
+        for idx in sorted(timing_records):
+            elapsed, slug = timing_records[idx]
+            tf.write(make_timing_line(args.version, idx, elapsed, slug) + "\n")
+
+        if all_timings:
+            avg_t = sum(all_timings) / len(all_timings)
+            total_t = sum(all_timings)
+            summary = (
+                f"\n  >> [{args.version}] completed {len(all_timings)} videos  |  "
+                f"avg: {avg_t:.2f}s ({avg_t / 60:.2f}min)  |  "
+                f"total: {total_t:.1f}s ({total_t / 60:.1f}min)\n"
+            )
+        else:
+            summary = f"\n  >> [{args.version}] no timing records available\n"
+        print(summary)
+        tf.write(summary)
+
+        if peak_mem is not None:
+            mem_line = f"  >> [{args.version}] peak GPU memory: {peak_mem:.2f} GB\n"
+            tf.write(mem_line)
+
+        sep = f"\n{'=' * 80}\n"
+        tf.write(sep)
+        tf.write("  FINAL SUMMARY\n")
+        tf.write(f"{'=' * 80}\n")
+        print(sep)
+        print("  FINAL SUMMARY")
+        print(f"{'=' * 80}")
+
+        fmt = "  {ver:12s} | videos: {n:3d} | avg: {avg:8.2f}s ({avgm:5.2f}min) | min: {mn:8.2f}s | max: {mx:8.2f}s | total: {tot:8.1f}s ({totm:5.1f}min)"
+        if all_timings:
+            line = fmt.format(
+                ver=args.version, n=len(all_timings),
+                avg=sum(all_timings) / len(all_timings), avgm=sum(all_timings) / len(all_timings) / 60,
+                mn=min(all_timings), mx=max(all_timings),
+                tot=sum(all_timings), totm=sum(all_timings) / 60,
+            )
+        else:
+            line = f"  {args.version:12s} | N/A (no timing records)"
+        print(line)
+        tf.write(line + "\n")
+
+        tf.write(f"{'=' * 80}\n")
+
+    print(f"{'=' * 80}")
+    print(f"\nTiming report: {timing_file}")
+    print(f"Videos:        {by_prompt_dir}")
+    print(f"               {by_version_dir}")
+
+
+if __name__ == "__main__":
+    main()

Helios/_DEV/infer_helios.py

@@ -0,0 +1,673 @@
+import importlib
+import os
+
+
+os.environ["HF_ENABLE_PARALLEL_LOADING"] = "yes"
+os.environ["HF_PARALLEL_LOADING_WORKERS"] = "8"
+
+import argparse
+import time
+from pathlib import Path
+
+import pandas as pd
+import torch
+import torch.distributed as dist
+from tqdm import tqdm
+
+
+if importlib.util.find_spec("torch_npu") is not None:
+    import torch_npu
+else:
+    torch_npu = None
+
+from helios.diffusers_version.pipeline_helios_diffusers import HeliosPipeline
+from helios.diffusers_version.scheduling_helios_diffusers import HeliosScheduler
+from helios.diffusers_version.transformer_helios_diffusers import HeliosTransformer3DModel
+from helios.modules.helios_kernels import (
+    replace_all_norms_with_flash_norms,
+    replace_rmsnorm_with_fp32,
+    replace_rope_with_flash_rope,
+)
+from helios.utils.utils_base import load_extra_components
+
+from diffusers import ContextParallelConfig
+from diffusers.models import AutoencoderKLWan
+from diffusers.utils import export_to_video, load_image, load_video
+
+PROJECT_ROOT = Path(__file__).resolve().parent
+DEFAULT_BASE_MODEL_PATH = str(PROJECT_ROOT / "checkpoints" / "Helios-Base")
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Generate video with model")
+
+    # === Model paths ===
+    parser.add_argument("--base_model_path", type=str, default=DEFAULT_BASE_MODEL_PATH)
+    parser.add_argument(
+        "--transformer_path",
+        type=str,
+        default=DEFAULT_BASE_MODEL_PATH,
+    )
+    parser.add_argument(
+        "--lora_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--partial_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument("--output_folder", type=str, default="./output_helios")
+    parser.add_argument("--enable_compile", action="store_true")
+
+    # === Generation parameters ===
+    # environment
+    parser.add_argument(
+        "--sample_type",
+        type=str,
+        default="t2v",
+        choices=["t2v", "i2v", "v2v"],
+    )
+    parser.add_argument(
+        "--weight_dtype",
+        type=str,
+        default="bf16",
+        choices=["bf16", "fp16", "fp32"],
+        help="Data type for model weights.",
+    )
+    parser.add_argument("--seed", type=int, default=42, help="Seed for random number generator.")
+    # base
+    parser.add_argument("--height", type=int, default=384)
+    parser.add_argument("--width", type=int, default=640)
+    parser.add_argument("--num_frames", type=int, default=99)
+    parser.add_argument("--fps", type=int, default=24)
+    parser.add_argument("--num_inference_steps", type=int, default=50)
+    parser.add_argument("--guidance_scale", type=float, default=5.0)
+    # cfg zero
+    parser.add_argument("--use_zero_init", action="store_true")
+    parser.add_argument("--zero_steps", type=int, default=1)
+    # stage 1
+    parser.add_argument("--num_latent_frames_per_chunk", type=int, default=9)
+    # stage 2
+    parser.add_argument("--is_enable_stage2", action="store_true")
+    parser.add_argument("--pyramid_num_inference_steps_list", type=int, nargs="+", default=[20, 20, 20])
+    # stage 3
+    parser.add_argument("--is_skip_first_chunk", action="store_true")
+    parser.add_argument("--is_amplify_first_chunk", action="store_true")
+    parser.add_argument(
+        "--visualize_relative_l1",
+        action="store_true",
+        help="Save per-chunk denoising relative L1 records and a timestep plot.",
+    )
+    parser.add_argument(
+        "--relative_l1_output_folder",
+        type=str,
+        default=None,
+        help="Deprecated. Relative L1 files are saved next to the mp4 in each prompt timestamp folder.",
+    )
+
+    # === Prompts ===
+    parser.add_argument("--use_interpolate_prompt", action="store_true")
+    parser.add_argument("--interpolation_steps", type=int, default=3)
+    parser.add_argument("--interpolate_time", type=int, default=7)
+    parser.add_argument(
+        "--image_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--image_noise_sigma_min", type=float, default=0.111, help="Balance motion amplitude and visual consistency"
+    )
+    parser.add_argument(
+        "--image_noise_sigma_max", type=float, default=0.135, help="Balance motion amplitude and visual consistency"
+    )
+    parser.add_argument(
+        "--video_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--video_noise_sigma_min", type=float, default=0.111, help="Balance motion amplitude and visual consistency"
+    )
+    parser.add_argument(
+        "--video_noise_sigma_max", type=float, default=0.135, help="Balance motion amplitude and visual consistency"
+    )
+    parser.add_argument(
+        "--prompt",
+        type=str,
+        default="A dynamic time-lapse video showing the rapidly moving scenery from the window of a speeding train. The camera captures various elements such as lush green fields, towering trees, quaint countryside houses, and distant mountain ranges passing by quickly. The train window frames the view, adding a sense of speed and motion as the landscape rushes past. The camera remains static but emphasizes the fast-paced movement outside. The overall atmosphere is serene yet exhilarating, capturing the essence of travel and exploration. Medium shot focusing on the train window and the rushing scenery beyond.",
+    )
+    parser.add_argument(
+        "--negative_prompt",
+        type=str,
+        default="Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards",
+    )
+    parser.add_argument(
+        "--prompt_txt_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--base_image_prompt_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--image_prompt_csv_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--interactive_prompt_csv_path",
+        type=str,
+        default=None,
+    )
+
+    # === Context parallelism ===
+    # Please refer to https://huggingface.co/docs/diffusers/main/en/training/distributed_inference#context-parallelism
+    parser.add_argument("--enable_parallelism", action="store_true")
+    parser.add_argument(
+        "--cp_backend",
+        type=str,
+        choices=["ring", "ulysses", "unified", "ulysses_anything"],
+        default="ulysses",
+        help="Context parallel backend to use.",
+    )
+
+    # === Group-Offloading ===
+    # Please refer to https://huggingface.co/docs/diffusers/main/en/optimization/memory#group-offloading
+    parser.add_argument("--enable_low_vram_mode", action="store_true")
+    parser.add_argument(
+        "--group_offloading_type",
+        type=str,
+        choices=["leaf_level", "block_level"],
+        default="leaf_level",
+        help="Specifies the granularity for group CPU offloading. Choose between 'leaf_level' (individual modules) or 'block_level' (entire blocks).",
+    )
+    parser.add_argument(
+        "--num_blocks_per_group",
+        type=str,
+        default="4",
+        help="The number of blocks to bundle together in each offloading group. Only relevant when using block-level offloading.",
+    )
+
+    return parser.parse_args()
+
+
+def build_sample_output_dir(output_folder, prompt_or_prompts):
+    if isinstance(prompt_or_prompts, list):
+        prompt_text = prompt_or_prompts[0] if prompt_or_prompts else "prompt"
+    else:
+        prompt_text = prompt_or_prompts or "prompt"
+
+    prompt_text = str(prompt_text).strip()
+    safe_chars = []
+    previous_was_sep = False
+    for char in prompt_text:
+        if char.isalnum():
+            safe_chars.append(char)
+            previous_was_sep = False
+        elif not previous_was_sep:
+            safe_chars.append("_")
+            previous_was_sep = True
+
+    prompt_stem = "".join(safe_chars).strip("_")[:80] or "prompt"
+    sample_dir = Path(output_folder) / f"{prompt_stem}_{int(time.time())}"
+
+    suffix = 1
+    base_sample_dir = sample_dir
+    while sample_dir.exists():
+        sample_dir = Path(f"{base_sample_dir}_{suffix}")
+        suffix += 1
+
+    sample_dir.mkdir(parents=True, exist_ok=False)
+    return sample_dir
+
+
+def save_relative_l1_outputs(records, output_folder):
+    if not records:
+        print(f"No relative L1 records for {output_folder}.")
+        return
+
+    metrics_dir = Path(output_folder)
+    metrics_dir.mkdir(parents=True, exist_ok=True)
+    df = pd.DataFrame(records).sort_values(["chunk_index", "step_index", "stage_index"])
+
+    csv_path = metrics_dir / "relative_l1.csv"
+    df.to_csv(csv_path, index=False)
+
+    try:
+        import matplotlib
+
+        matplotlib.use("Agg")
+        import matplotlib.pyplot as plt
+
+        def save_metric_plot(metric_name, ylabel, title, plot_name):
+            fig, ax = plt.subplots(figsize=(9, 5))
+            for chunk_index, chunk_df in df.groupby("chunk_index"):
+                chunk_df = chunk_df.sort_values(["step_index", "stage_index"])
+                ax.plot(
+                    chunk_df["timestep"],
+                    chunk_df[metric_name],
+                    marker="o",
+                    linewidth=1.5,
+                    markersize=3,
+                    label=f"chunk {chunk_index}",
+                )
+
+            ax.set_xlabel("timestep")
+            ax.set_ylabel(ylabel)
+            ax.set_title(title)
+            ax.grid(True, alpha=0.3)
+            ax.invert_xaxis()
+            ax.legend()
+            fig.tight_layout()
+
+            plot_path = metrics_dir / plot_name
+            fig.savefig(plot_path, dpi=200)
+            plt.close(fig)
+            return plot_path
+
+        plot_path = save_metric_plot(
+            "relative_l1",
+            "mean relative L1",
+            "Denoising relative L1 per chunk",
+            "relative_l1.png",
+        )
+        ratio_plot_path = None
+        if "relative_l1_ratio" in df.columns:
+            ratio_plot_path = save_metric_plot(
+                "relative_l1_ratio",
+                "mean(delta L1) / mean(latent L1)",
+                "Denoising relative L1 ratio per chunk",
+                "relative_l1_ratio.png",
+            )
+
+        if ratio_plot_path is None:
+            print(f"Saved relative L1 CSV to {csv_path} and plot to {plot_path}")
+        else:
+            print(f"Saved relative L1 CSV to {csv_path} and plots to {plot_path}, {ratio_plot_path}")
+    except Exception as exc:
+        print(f"Saved relative L1 CSV to {csv_path}, but failed to save plot: {exc}")
+
+
+def main():
+    args = parse_args()
+
+    assert not (args.enable_low_vram_mode and args.enable_compile), (
+        "enable_low_vram_mode and enable_compile cannot be used together."
+    )
+
+    if args.weight_dtype == "fp32":
+        args.weight_dtype = torch.float32
+    elif args.weight_dtype == "fp16":
+        args.weight_dtype = torch.float16
+    else:
+        args.weight_dtype = torch.bfloat16
+
+    os.makedirs(args.output_folder, exist_ok=True)
+
+    if dist.is_available() and "RANK" in os.environ:
+        if args.cp_backend == "ulysses_anything":
+            dist.init_process_group(backend="cpu:gloo,cuda:nccl")
+        else:
+            dist.init_process_group(backend="nccl")
+        rank = dist.get_rank()
+        device = torch.device("cuda", rank % torch.cuda.device_count())
+        world_size = dist.get_world_size()
+        torch.cuda.set_device(device)
+        assert world_size == 1 or not args.enable_low_vram_mode, "enable_low_vram_mode is only for single GPU."
+    else:
+        rank = 0
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        world_size = 1
+
+    prompt = None
+    image_path = None
+    video_path = None
+    interpolate_time_list = None
+    if args.sample_type == "t2v" and args.prompt is None:
+        prompt = "An extreme close-up of an gray-haired man with a beard in his 60s, he is deep in thought pondering the history of the universe as he sits at a cafe in Paris, his eyes focus on people offscreen as they walk as he sits mostly motionless, he is dressed in a wool coat suit coat with a button-down shirt , he wears a brown beret and glasses and has a very professorial appearance, and the end he offers a subtle closed-mouth smile as if he found the answer to the mystery of life, the lighting is very cinematic with the golden light and the Parisian streets and city in the background, depth of field, cinematic 35mm film."
+    elif args.sample_type == "i2v" and (args.image_path is None and args.prompt is None):
+        image_path = (
+            "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg"
+        )
+        prompt = "An astronaut hatching from an egg, on the surface of the moon, the darkness and depth of space realised in the background. High quality, ultrarealistic detail and breath-taking movie-like camera shot."
+    elif args.sample_type == "v2v" and (args.video_path is None and args.prompt is None):
+        video_path = (
+            "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/hiker.mp4"
+        )
+        prompt = "A robot standing on a mountain top. The sun is setting in the background."
+    else:
+        image_path = args.image_path
+        video_path = args.video_path
+        prompt = args.prompt
+
+    transformer = HeliosTransformer3DModel.from_pretrained(
+        args.transformer_path,
+        subfolder="transformer",
+        torch_dtype=args.weight_dtype,
+    )
+    if not args.enable_compile:
+        transformer = replace_rmsnorm_with_fp32(transformer)
+        transformer = replace_all_norms_with_flash_norms(transformer)
+        replace_rope_with_flash_rope()
+    cuda_major = torch.cuda.get_device_capability()[0]
+    if cuda_major >= 9:
+        # H100/H800 (SM90+) with FA3
+        try:
+            transformer.set_attention_backend("_flash_3_hub")
+        except Exception:
+            transformer.set_attention_backend("flash_hub")
+    else:
+        # 4090/A100 etc (SM89+) with FA2
+        transformer.set_attention_backend("flash_hub")
+
+    vae = AutoencoderKLWan.from_pretrained(
+        args.base_model_path,
+        subfolder="vae",
+        torch_dtype=torch.float32,
+    )
+    scheduler = HeliosScheduler.from_pretrained(
+        args.base_model_path,
+        subfolder="scheduler",
+    )
+    pipe = HeliosPipeline.from_pretrained(
+        args.base_model_path,
+        transformer=transformer,
+        vae=vae,
+        scheduler=scheduler,
+        torch_dtype=args.weight_dtype,
+    )
+
+    if args.lora_path is not None:
+        pipe.load_lora_weights(args.lora_path, adapter_name="default")
+        pipe.set_adapters(["default"], adapter_weights=[1.0])
+
+        if args.partial_path is not None:
+            if not hasattr(args, "training_config"):
+                from argparse import Namespace
+
+                args.training_config = Namespace()
+            args.training_config.is_enable_stage1 = True
+            args.training_config.restrict_self_attn = True
+            args.training_config.is_amplify_history = True
+            args.training_config.is_use_gan = True
+            load_extra_components(args, transformer, args.partial_path)
+
+    if args.enable_compile:
+        torch.backends.cudnn.benchmark = True
+        pipe.text_encoder.compile(mode="max-autotune-no-cudagraphs", dynamic=False)
+        pipe.vae.compile(mode="max-autotune-no-cudagraphs", dynamic=False)
+        pipe.transformer.compile(mode="max-autotune-no-cudagraphs", dynamic=False)
+
+    if args.enable_low_vram_mode:
+        pipe.enable_group_offload(
+            onload_device=torch.device("cuda"),
+            offload_device=torch.device("cpu"),
+            offload_type=args.group_offloading_type,
+            num_blocks_per_group=args.num_blocks_per_group if args.group_offloading_type == "block_level" else None,
+            use_stream=True,
+            record_stream=True,
+        )
+    else:
+        pipe = pipe.to(device)
+
+    if world_size > 1 and args.enable_parallelism:
+        if args.cp_backend == "ring":
+            cp_config = ContextParallelConfig(ring_degree=world_size)
+        elif args.cp_backend == "unified":
+            cp_config = ContextParallelConfig(ring_degree=world_size // 2, ulysses_degree=world_size // 2)
+        elif args.cp_backend == "ulysses":
+            cp_config = ContextParallelConfig(ulysses_degree=world_size)
+        elif args.cp_backend == "ulysses_anything":
+            cp_config = ContextParallelConfig(ulysses_degree=world_size, ulysses_anything=True)
+        else:
+            raise ValueError(f"Unsupported cp_backend: {args.cp_backend}")
+
+        pipe.transformer.enable_parallelism(config=cp_config)
+
+    if args.prompt_txt_path is not None:
+        with open(args.prompt_txt_path, "r") as f:
+            prompt_list = [line.strip() for line in f.readlines() if line.strip()]
+        if not args.enable_parallelism:
+            prompt_list_with_idx = [(i, prompt) for i, prompt in enumerate(prompt_list)]
+            prompt_list_with_idx = prompt_list_with_idx[rank::world_size]
+        else:
+            prompt_list_with_idx = [(i, prompt) for i, prompt in enumerate(prompt_list)]
+
+        for idx, prompt in tqdm(prompt_list_with_idx, desc="Processing prompts"):
+            with torch.no_grad():
+                try:
+                    pipe_output = pipe(
+                        prompt=prompt,
+                        negative_prompt=args.negative_prompt,
+                        height=args.height,
+                        width=args.width,
+                        num_frames=args.num_frames,
+                        num_inference_steps=args.num_inference_steps,
+                        guidance_scale=args.guidance_scale,
+                        generator=torch.Generator(device="cuda").manual_seed(args.seed),
+                        # stage 1
+                        history_sizes=[16, 2, 1],
+                        num_latent_frames_per_chunk=args.num_latent_frames_per_chunk,
+                        keep_first_frame=True,
+                        # stage 2
+                        is_enable_stage2=args.is_enable_stage2,
+                        pyramid_num_inference_steps_list=args.pyramid_num_inference_steps_list,
+                        # stage 3
+                        is_skip_first_chunk=args.is_skip_first_chunk,
+                        is_amplify_first_chunk=args.is_amplify_first_chunk,
+                        # cfg zero
+                        use_zero_init=args.use_zero_init,
+                        zero_steps=args.zero_steps,
+                        # i2v
+                        image=load_image(image_path).resize((args.width, args.height))
+                        if image_path is not None
+                        else None,
+                        image_noise_sigma_min=args.image_noise_sigma_min,
+                        image_noise_sigma_max=args.image_noise_sigma_max,
+                        # v2v
+                        video=load_video(video_path) if video_path is not None else None,
+                        video_noise_sigma_min=args.video_noise_sigma_min,
+                        video_noise_sigma_max=args.video_noise_sigma_max,
+                        # interpolate_prompt
+                        use_interpolate_prompt=args.use_interpolate_prompt,
+                        interpolation_steps=args.interpolation_steps,
+                        interpolate_time_list=interpolate_time_list,
+                        output_relative_l1=args.visualize_relative_l1,
+                    )
+                    output = pipe_output.frames[0]
+                except Exception:
+                    continue
+            if not args.enable_parallelism or rank == 0:
+                sample_dir = build_sample_output_dir(args.output_folder, prompt)
+                output_path = sample_dir / "video.mp4"
+                export_to_video(output, str(output_path), fps=24)
+                if args.visualize_relative_l1:
+                    save_relative_l1_outputs(pipe_output.relative_l1, sample_dir)
+    elif args.image_prompt_csv_path is not None:
+        df = pd.read_csv(args.image_prompt_csv_path)
+        if not args.enable_parallelism:
+            df = df.iloc[rank::world_size]
+
+        for idx, row in tqdm(df.iterrows(), total=len(df), desc="Processing prompts"):
+            prompt = row.get("refined_prompt") or row["prompt"]
+            image_path = os.path.join(args.base_image_prompt_path, row["image_name"])
+
+            with torch.no_grad():
+                try:
+                    pipe_output = pipe(
+                        prompt=prompt,
+                        negative_prompt=args.negative_prompt,
+                        height=args.height,
+                        width=args.width,
+                        num_frames=args.num_frames,
+                        num_inference_steps=args.num_inference_steps,
+                        guidance_scale=args.guidance_scale,
+                        generator=torch.Generator(device="cuda").manual_seed(args.seed),
+                        # stage 1
+                        history_sizes=[16, 2, 1],
+                        num_latent_frames_per_chunk=args.num_latent_frames_per_chunk,
+                        keep_first_frame=True,
+                        # stage 2
+                        is_enable_stage2=args.is_enable_stage2,
+                        pyramid_num_inference_steps_list=args.pyramid_num_inference_steps_list,
+                        # stage 3
+                        is_skip_first_chunk=args.is_skip_first_chunk,
+                        is_amplify_first_chunk=args.is_amplify_first_chunk,
+                        # cfg zero
+                        use_zero_init=args.use_zero_init,
+                        zero_steps=args.zero_steps,
+                        # i2v
+                        image=load_image(image_path).resize((args.width, args.height))
+                        if image_path is not None
+                        else None,
+                        image_noise_sigma_min=args.image_noise_sigma_min,
+                        image_noise_sigma_max=args.image_noise_sigma_max,
+                        # v2v
+                        video=load_video(video_path) if video_path is not None else None,
+                        video_noise_sigma_min=args.video_noise_sigma_min,
+                        video_noise_sigma_max=args.video_noise_sigma_max,
+                        # interpolate_prompt
+                        use_interpolate_prompt=args.use_interpolate_prompt,
+                        interpolation_steps=args.interpolation_steps,
+                        interpolate_time_list=interpolate_time_list,
+                        output_relative_l1=args.visualize_relative_l1,
+                    )
+                    output = pipe_output.frames[0]
+                except Exception:
+                    continue
+            if not args.enable_parallelism or rank == 0:
+                sample_dir = build_sample_output_dir(args.output_folder, prompt)
+                output_path = sample_dir / "video.mp4"
+                export_to_video(output, str(output_path), fps=24)
+                if args.visualize_relative_l1:
+                    save_relative_l1_outputs(pipe_output.relative_l1, sample_dir)
+    elif args.interactive_prompt_csv_path is not None:
+        df = pd.read_csv(args.interactive_prompt_csv_path)
+
+        df = df.sort_values(by=["id", "prompt_index"])
+        all_video_ids = df["id"].unique()
+
+        if not args.enable_parallelism:
+            my_video_ids = all_video_ids[rank::world_size]
+        else:
+            my_video_ids = all_video_ids
+
+        for video_id in tqdm(my_video_ids, desc="Processing prompts"):
+            group_df = df[df["id"] == video_id]
+
+            if "refined_prompt" in df.columns:
+                prompt_list = group_df["refined_prompt"].fillna(group_df["prompt"]).tolist()
+            else:
+                prompt_list = group_df["prompt"].tolist()
+            interpolate_time_list = [args.interpolate_time] * len(prompt_list)
+
+            with torch.no_grad():
+                try:
+                    pipe_output = pipe(
+                        prompt=prompt_list,
+                        negative_prompt=args.negative_prompt,
+                        height=args.height,
+                        width=args.width,
+                        num_frames=args.num_frames,
+                        num_inference_steps=args.num_inference_steps,
+                        guidance_scale=args.guidance_scale,
+                        generator=torch.Generator(device="cuda").manual_seed(args.seed),
+                        # stage 1
+                        history_sizes=[16, 2, 1],
+                        num_latent_frames_per_chunk=args.num_latent_frames_per_chunk,
+                        keep_first_frame=True,
+                        # stage 2
+                        is_enable_stage2=args.is_enable_stage2,
+                        pyramid_num_inference_steps_list=args.pyramid_num_inference_steps_list,
+                        # stage 3
+                        is_skip_first_chunk=args.is_skip_first_chunk,
+                        is_amplify_first_chunk=args.is_amplify_first_chunk,
+                        # cfg zero
+                        use_zero_init=args.use_zero_init,
+                        zero_steps=args.zero_steps,
+                        # i2v
+                        image=load_image(image_path).resize((args.width, args.height))
+                        if image_path is not None
+                        else None,
+                        image_noise_sigma_min=args.image_noise_sigma_min,
+                        image_noise_sigma_max=args.image_noise_sigma_max,
+                        # v2v
+                        video=load_video(video_path) if video_path is not None else None,
+                        video_noise_sigma_min=args.video_noise_sigma_min,
+                        video_noise_sigma_max=args.video_noise_sigma_max,
+                        # interpolate_prompt
+                        use_interpolate_prompt=args.use_interpolate_prompt,
+                        interpolation_steps=args.interpolation_steps,
+                        interpolate_time_list=interpolate_time_list,
+                        output_relative_l1=args.visualize_relative_l1,
+                    )
+                    output = pipe_output.frames[0]
+                except Exception:
+                    continue
+            if not args.enable_parallelism or rank == 0:
+                sample_dir = build_sample_output_dir(args.output_folder, prompt_list)
+                output_path = sample_dir / "video.mp4"
+                export_to_video(output, str(output_path), fps=24)
+                if args.visualize_relative_l1:
+                    save_relative_l1_outputs(pipe_output.relative_l1, sample_dir)
+    else:
+        with torch.no_grad():
+            # import time
+            # for _ in range(20):
+            #     start_time = time.time()
+            pipe_output = pipe(
+                prompt=prompt,
+                negative_prompt=args.negative_prompt,
+                height=args.height,
+                width=args.width,
+                num_frames=args.num_frames,
+                num_inference_steps=args.num_inference_steps,
+                guidance_scale=args.guidance_scale,
+                generator=torch.Generator(device="cuda").manual_seed(args.seed),
+                # stage 1
+                history_sizes=[16, 2, 1],
+                num_latent_frames_per_chunk=args.num_latent_frames_per_chunk,
+                keep_first_frame=True,
+                # stage 2
+                is_enable_stage2=args.is_enable_stage2,
+                pyramid_num_inference_steps_list=args.pyramid_num_inference_steps_list,
+                # stage 3
+                is_skip_first_chunk=args.is_skip_first_chunk,
+                is_amplify_first_chunk=args.is_amplify_first_chunk,
+                # cfg zero
+                use_zero_init=args.use_zero_init,
+                zero_steps=args.zero_steps,
+                # i2v
+                image=load_image(image_path).resize((args.width, args.height)) if image_path is not None else None,
+                image_noise_sigma_min=args.image_noise_sigma_min,
+                image_noise_sigma_max=args.image_noise_sigma_max,
+                # v2v
+                video=load_video(video_path) if video_path is not None else None,
+                video_noise_sigma_min=args.video_noise_sigma_min,
+                video_noise_sigma_max=args.video_noise_sigma_max,
+                # interpolate_prompt
+                use_interpolate_prompt=args.use_interpolate_prompt,
+                interpolation_steps=args.interpolation_steps,
+                interpolate_time_list=interpolate_time_list,
+                output_relative_l1=args.visualize_relative_l1,
+            )
+            output = pipe_output.frames[0]
+            # elapsed_time = time.time() - start_time
+            # print(f"Inference time: {elapsed_time:.2f} seconds ({elapsed_time/60:.2f} minutes)")
+
+        if not args.enable_parallelism or rank == 0:
+            sample_dir = build_sample_output_dir(args.output_folder, prompt)
+            output_path = sample_dir / "video.mp4"
+            export_to_video(output, str(output_path), fps=24)
+            if args.visualize_relative_l1:
+                save_relative_l1_outputs(pipe_output.relative_l1, sample_dir)
+
+    print(f"Max memory: {torch.cuda.max_memory_allocated() / 1024**3:.3f} GB")
+
+
+if __name__ == "__main__":
+    main()

Helios/_DEV/install.sh

@@ -0,0 +1,10 @@
+pip install -r requirements.txt
+
+rm -rf ~/.triton/cache/
+rm -rf /tmp/torchinductor_*
+
+pip uninstall triton torchao xformers wandb tensorflow tensorflow-cpu -y
+pip install wandb==0.23.0 triton==3.6.0
+
+rm -rf ~/.triton/cache/
+rm -rf /tmp/torchinductor_*

Helios/_DEV/requirements.txt

@@ -0,0 +1,35 @@
+torch==2.10.0
+torchvision==0.25.0
+torchaudio==2.10.0
+triton==3.6.0
+kernels==0.13.0
+# diffusers==0.36.0
+# transformers==4.57.6
+git+https://github.com/huggingface/diffusers.git
+transformers==5.3.0
+sentence-transformers==5.2.3
+accelerate==1.12.0
+deepspeed==0.18.4
+peft==0.18.1
+huggingface-hub==1.4.1
+zstandard==0.25.0
+wandb==0.23.0
+video-reader-rs==0.4.1
+numpy<2.0.0
+opencv-python
+gradio
+spaces
+moviepy
+imageio-ffmpeg
+ftfy
+Jinja2
+einops
+nvitop
+packaging
+ninja
+omegaconf
+mpi4py
+hf-doc-builder
+torchdata
+loguru
+tf_keras

Helios/_DEV/requirements_npu.txt

@@ -0,0 +1,6 @@
+# Please refer to here for installation the latest version: https://github.com/Ascend/pytorch?tab=readme-ov-file#ascend-auxiliary-software
+torch==2.9.0
+torchvision==0.24.0
+torchaudio==2.9.0
+torch_npu==2.9.0
+triton==3.5.1

Helios/_DEV/run_bench.sh

@@ -0,0 +1,275 @@
+#!/bin/bash
+# =============================================================================
+#  Helios Benchmark Inference Runner
+#  用法: bash run_bench.sh [--gpus 5 6 7] [--prompt_range 0-50] [--num_frames 240]
+#                         [--version base] [--version mid distilled]
+#  默认使用所有可见 GPU；默认跑全部版本（base/mid/distilled），也可手动指定版本
+#  同一时刻只跑一个版本；若有多张卡，会先扫描输出目录，只把缺失 case 均分到多张卡并行
+#  低显存: LOW_VRAM=1 bash run_bench.sh
+# =============================================================================
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+if [[ -n "${PYTHON:-}" ]]; then
+    PYTHON_BIN="${PYTHON}"
+elif command -v python3 >/dev/null 2>&1; then
+    PYTHON_BIN="$(command -v python3)"
+elif command -v python >/dev/null 2>&1; then
+    PYTHON_BIN="$(command -v python)"
+else
+    echo "Python interpreter not found. Set PYTHON=/path/to/python." >&2
+    exit 1
+fi
+
+GPUS=()
+PROMPT_START="${PROMPT_START:-0}"
+PROMPT_END="${PROMPT_END:-100}"
+NUM_FRAMES="${NUM_FRAMES:-}"
+VERSIONS=(base mid distilled)
+OUTPUT_ROOT="${OUTPUT_ROOT:-}"
+PROMPT_FILE="${PROMPT_FILE:-${SCRIPT_DIR}/demo_data/MovieGenVideoBench_extended.txt}"
+LOW_VRAM="${LOW_VRAM:-0}"
+
+discover_gpus() {
+    if ! command -v nvidia-smi >/dev/null 2>&1; then
+        echo "nvidia-smi not found; use --gpus to specify GPU ids explicitly." >&2
+        exit 1
+    fi
+
+    mapfile -t GPUS < <(nvidia-smi --query-gpu=index --format=csv,noheader,nounits)
+    if [[ ${#GPUS[@]} -eq 0 ]]; then
+        echo "No GPUs found." >&2
+        exit 1
+    fi
+}
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --gpus)        shift; GPUS=(); while [[ $# -gt 0 && ! "$1" =~ ^-- ]]; do GPUS+=("$1"); shift; done ;;
+        --prompt_range)
+            if [[ ! "$2" =~ ^([0-9]+)-([0-9]+)$ ]]; then
+                echo "Invalid --prompt_range: $2 (expected START-END, e.g. 0-50)" >&2
+                exit 1
+            fi
+            PROMPT_START="${BASH_REMATCH[1]}"
+            PROMPT_END="${BASH_REMATCH[2]}"
+            shift 2
+            ;;
+        --prompt_start) PROMPT_START="$2"; shift 2 ;;
+        --prompt_end)   PROMPT_END="$2"; shift 2 ;;
+        --num_frames)  NUM_FRAMES="$2";  shift 2 ;;
+        --version)     shift; VERSIONS=(); while [[ $# -gt 0 && ! "$1" =~ ^-- ]]; do VERSIONS+=("$1"); shift; done ;;
+        --output_root) OUTPUT_ROOT="$2"; shift 2 ;;
+        --prompt_file) PROMPT_FILE="$2"; shift 2 ;;
+        *) echo "Unknown option: $1"; exit 1 ;;
+    esac
+done
+
+if [[ ${#GPUS[@]} -eq 0 ]]; then
+    discover_gpus
+fi
+
+if [[ ${#VERSIONS[@]} -eq 0 ]]; then
+    echo "No versions specified. Use --version base [mid distilled]." >&2
+    exit 1
+fi
+
+if [[ ! "${PROMPT_START}" =~ ^[0-9]+$ ]] || [[ ! "${PROMPT_END}" =~ ^[0-9]+$ ]]; then
+    echo "prompt_start and prompt_end must be non-negative integers." >&2
+    exit 1
+fi
+
+if (( PROMPT_END <= PROMPT_START )); then
+    echo "prompt_end must be greater than prompt_start." >&2
+    exit 1
+fi
+
+if [[ -z "${OUTPUT_ROOT}" ]]; then
+    if [[ -n "${NUM_FRAMES}" ]]; then
+        OUTPUT_ROOT="${SCRIPT_DIR}/outputs/num_frames_${NUM_FRAMES}"
+    else
+        OUTPUT_ROOT="${SCRIPT_DIR}/outputs/num_frames_default"
+    fi
+fi
+
+echo "============================================================"
+echo "  Helios Benchmark Inference"
+echo "  $(date '+%Y-%m-%d %H:%M:%S')"
+echo "  Python: ${PYTHON_BIN}"
+echo "  GPUs: ${GPUS[*]}  |  Prompt range: ${PROMPT_START}-${PROMPT_END}  |  Versions: ${VERSIONS[*]}"
+[[ -n "${NUM_FRAMES}" ]] && echo "  Frames: ${NUM_FRAMES}"
+echo "  Prompt file: ${PROMPT_FILE}"
+echo "  Output: ${OUTPUT_ROOT}"
+echo "============================================================"
+
+mkdir -p "${OUTPUT_ROOT}"
+
+if [[ ! -f "${PROMPT_FILE}" ]]; then
+    echo "Prompt file not found: ${PROMPT_FILE}" >&2
+    exit 1
+fi
+
+TOTAL_PROMPTS=$(awk 'NF {count++} END {print count + 0}' "${PROMPT_FILE}")
+if (( PROMPT_START >= TOTAL_PROMPTS )); then
+    echo "prompt_start (${PROMPT_START}) is out of range; prompt file has ${TOTAL_PROMPTS} non-empty prompts." >&2
+    exit 1
+fi
+
+if (( PROMPT_END > TOTAL_PROMPTS )); then
+    echo "prompt_end (${PROMPT_END}) exceeds total prompts (${TOTAL_PROMPTS}); clamping to ${TOTAL_PROMPTS}."
+    PROMPT_END="${TOTAL_PROMPTS}"
+fi
+
+EXTRA=()
+if [[ "${LOW_VRAM}" == "1" ]]; then
+    EXTRA+=(--enable_low_vram_mode)
+fi
+if [[ -n "${NUM_FRAMES}" ]]; then
+    EXTRA+=(--num_frames "${NUM_FRAMES}")
+fi
+
+EXIT_CODE=0
+WORKER_PIDS=()
+WORKER_GPUS=()
+WORKER_SHARDS=()
+
+prepare_missing_shards() {
+    local version="$1"
+    local shard_dir="${OUTPUT_ROOT}/shards/${version}_${PROMPT_START}_${PROMPT_END}_$$"
+    mkdir -p "${shard_dir}"
+
+    "${PYTHON_BIN}" - \
+        "${PROMPT_FILE}" \
+        "${OUTPUT_ROOT}" \
+        "${version}" \
+        "${PROMPT_START}" \
+        "${PROMPT_END}" \
+        "${#GPUS[@]}" \
+        "${shard_dir}" <<'PY'
+import os
+import re
+import sys
+from pathlib import Path
+
+prompt_file = Path(sys.argv[1])
+output_root = Path(sys.argv[2])
+version = sys.argv[3]
+prompt_start = int(sys.argv[4])
+prompt_end = int(sys.argv[5])
+gpu_count = int(sys.argv[6])
+shard_dir = Path(sys.argv[7])
+
+with prompt_file.open("r", encoding="utf-8") as f:
+    prompts = [line.strip() for line in f if line.strip()]
+
+def sanitize_filename(text, max_len=80):
+    text = text.strip().lower()
+    text = re.sub(r"[^a-z0-9]+", "_", text)
+    text = text.strip("_")
+    return text[:max_len]
+
+missing = []
+existing = 0
+version_dir = output_root / "by_version" / version
+for idx in range(prompt_start, prompt_end):
+    slug = sanitize_filename(prompts[idx])
+    video_path = version_dir / f"{idx:04d}_{slug}.mp4"
+    if video_path.is_file() and video_path.stat().st_size > 0:
+        existing += 1
+    else:
+        missing.append(idx)
+
+print(
+    f"[scan] version={version} range={prompt_start}-{prompt_end} "
+    f"existing={existing} missing={len(missing)} output={version_dir}",
+    file=sys.stderr,
+)
+
+if not missing:
+    sys.exit(0)
+
+active_workers = min(gpu_count, len(missing))
+base_chunk = len(missing) // active_workers
+remainder = len(missing) % active_workers
+offset = 0
+
+for shard_idx in range(active_workers):
+    shard_size = base_chunk + (1 if shard_idx < remainder else 0)
+    shard_indices = missing[offset:offset + shard_size]
+    offset += shard_size
+    shard_path = shard_dir / f"shard_{shard_idx:02d}.txt"
+    shard_path.write_text(
+        "".join(f"{idx}\n" for idx in shard_indices),
+        encoding="utf-8",
+    )
+    print(shard_path)
+    print(
+        f"[shard] version={version} shard={shard_idx} count={len(shard_indices)} "
+        f"indices={shard_indices[0]}-{shard_indices[-1]} file={shard_path}",
+        file=sys.stderr,
+    )
+PY
+}
+
+launch_job() {
+    local version="$1"
+    local gpu="$2"
+    local shard_file="$3"
+    local shard_id
+    shard_id="$(basename "${shard_file}" .txt)"
+    local timing_file="${OUTPUT_ROOT}/timing_${version}_${shard_id}.txt"
+
+    echo "[launch] version=${version} gpu=${gpu} shard=${shard_id} indices=${shard_file} output=${OUTPUT_ROOT}"
+    "${PYTHON_BIN}" "${SCRIPT_DIR}/bench_infer.py" \
+        --prompt_file  "${PROMPT_FILE}" \
+        --prompt_start "${PROMPT_START}" \
+        --prompt_end   "${PROMPT_END}" \
+        --prompt_indices_file "${shard_file}" \
+        --output_root  "${OUTPUT_ROOT}" \
+        --timing_file  "${timing_file}" \
+        --version      "${version}" \
+        --gpu          "${gpu}" \
+        "${EXTRA[@]}" &
+
+    WORKER_PIDS+=("$!")
+    WORKER_GPUS+=("${gpu}")
+    WORKER_SHARDS+=("${shard_id}")
+}
+
+wait_for_current_version() {
+    local version="$1"
+    for idx in "${!WORKER_PIDS[@]}"; do
+        local pid="${WORKER_PIDS[$idx]}"
+        local gpu="${WORKER_GPUS[$idx]}"
+        local shard_id="${WORKER_SHARDS[$idx]}"
+        if wait "${pid}"; then
+            echo "[done] ${version} finished on gpu=${gpu} shard=${shard_id}"
+        else
+            echo "[fail] ${version} failed on gpu=${gpu} shard=${shard_id}"
+            EXIT_CODE=1
+        fi
+    done
+    WORKER_PIDS=()
+    WORKER_GPUS=()
+    WORKER_SHARDS=()
+}
+
+for version in "${VERSIONS[@]}"; do
+    echo ""
+    echo "-------------------- version=${version} --------------------"
+    mapfile -t SHARD_FILES < <(prepare_missing_shards "${version}")
+    if (( ${#SHARD_FILES[@]} == 0 )); then
+        echo "[skip] version=${version} has no missing cases in ${PROMPT_START}-${PROMPT_END}"
+        continue
+    fi
+
+    for worker_idx in "${!SHARD_FILES[@]}"; do
+        launch_job "${version}" "${GPUS[$worker_idx]}" "${SHARD_FILES[$worker_idx]}"
+    done
+    wait_for_current_version "${version}"
+done
+
+echo ""
+echo "Done. Per-shard timing reports are under ${OUTPUT_ROOT}/timing_<version>_shard_<id>.txt"
+
+exit ${EXIT_CODE:-0}

Helios/_DEV2/.gitignore

@@ -0,0 +1,43 @@
+*.py[cod]
+*.gif
+*.bmp
+*.mov
+*.mkv
+*.log
+*.zip
+*.pt
+*.pth
+*.ckpt
+*.safetensors
+*.backup
+*.pt
+*.pth
+*.ckpt
+*.pkl
+*.html
+*.pdf
+*.whl
+*.txt.gz
+!.gitignore
+!requirements.txt
+.DS_Store
+*DS_Store
+poetry.lock
+__pycache__/
+*.cache*
+*temp_path*
+*_ckpt
+*_results
+*temp
+*.pem
+*profile
+.gradio
+ablation_*
+cache
+wandb
+output_helios
+AMT-S.yaml
+bpe_simple_vocab_16e6.txt
+Videoreward
+1_formal_ckpts
+demo_data

Helios/_DEV2/LICENSE.txt

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

Helios/_DEV2/README.md

@@ -0,0 +1,137 @@
+# Short History Attention Debug
+
+本次修改实现了一个默认关闭的 debug hook，用来分析 current token 到 short history 上一帧 token 的对应关系。
+
+## 背景结论
+
+默认设置下：
+
+- current chunk 是 33 个视频帧，对应 9 个 latent frames。
+- 默认视频分辨率是 384x640。
+- VAE latent 分辨率是 48x80。
+- transformer patch 是 `(1, 2, 2)`，所以 current token grid 是 `9 x 24 x 40`。
+- short history 经过 `patch_short` 后是 `2 x 24 x 40`。
+- 本次只在 short history 的上一帧里找对应 token，也就是每个 current latent frame 的 `24 x 40` tokens 对应 previous short frame 的 `24 x 40` tokens。
+
+## 已实现内容
+
+新增 `short_attn_debug` pipeline 参数。开启后，attention hook 会在指定 block、chunk、denoise step、current frame 上导出 current token 到 previous short token 的 top-k 匹配。
+
+实现位置：
+
+- `helios/diffusers_version/transformer_helios_diffusers.py`
+- `helios/diffusers_version/pipeline_helios_diffusers.py`
+- `helios/modules/transformer_helios.py`
+- `helios/pipelines/pipeline_helios.py`
+- `tools/visualize_short_attention_matches.py`
+
+导出的 artifact 默认包含：
+
+- `match_yx`: 每个 current token 匹配到的 previous short token 坐标
+- `query_yx`: current token 自身坐标
+- `displacement_yx`: token 位移
+- `topk_indices`: top-k 匹配 index
+- `topk_scores`: top-k raw attention scores
+- `top1_score`
+- `top2_score`
+- `margin`: `top1_score - top2_score`
+
+不会保存完整 `960 x 960` attention matrix，避免显存和磁盘开销过大。
+
+## 使用示例
+
+在 pipeline 调用里加：
+
+```python
+output = pipe(
+    prompt=prompt,
+    negative_prompt=negative_prompt,
+    height=384,
+    width=640,
+    num_frames=99,
+    short_attn_debug={
+        "output_dir": "short_attn_debug",
+        "blocks": [30],
+        "steps": ["last"],
+        "chunks": [0],
+        "current_frame": -1,
+        "prev_short_frame": 1,
+        "pass_names": ["cond"],
+        "topk": 2,
+        "query_chunk_size": 128,
+    },
+).frames[0]
+```
+
+默认推荐先看：
+
+- block `30`
+- denoise last step
+- chunk `0`
+- current latent frame `-1`
+- previous short frame `1`
+- cond pass
+
+## 可视化
+
+生成图：
+
+```bash
+python tools/visualize_short_attention_matches.py \
+  short_attn_debug/short_attn_chunk0_step49_block30_frame8_cond.pt \
+  --output-dir short_attn_debug \
+  --stride 4
+```
+
+输出：
+
+- `*_flow_quiver.png`: 稀疏 token flow 箭头图
+- `*_displacement_heatmap.png`: 位移大小热图
+- `*_confidence_heatmap.png`: `top1 - top2` margin 热图
+- `*_top1_score_heatmap.png`: top1 raw score 热图
+
+## 当前实现细节
+
+匹配计算使用 attn1 里已经 projection、norm、rotary 后的 Q/K：
+
+```text
+score = Q_current_frame @ K_previous_short_frame.T / sqrt(head_dim)
+```
+
+然后对 heads 做平均，再取 top-k。
+
+为了控制开销，计算按 query chunk 分块进行。默认每次处理 128 个 query tokens。
+
+## 未做但可继续扩展的方案
+
+1. full softmax attention heatmap
+
+   当前保存的是 top-k raw scores，不保存完整 softmax 分布。后续如果要做单点 token viewer，可以只对用户点击的 token 计算完整 `24 x 40` softmax heatmap。
+
+2. click-to-inspect viewer
+
+   可以做一个交互式界面：左边点 current token，右边显示它对 previous short frame 的 `24 x 40` score/attention heatmap，并框出 top-k。
+
+3. 多层对比
+
+   当前支持配置多个 blocks，例如 `[10, 20, 30, 39]`。后续可以把这些层的 flow 和 confidence 并排画出来，观察 correspondence 在不同深度的变化。
+
+4. 多 denoise step 对比
+
+   当前支持 `steps=["first", "last"]` 或具体 step index。后续可以把 first/mid/last step 的图并排，观察匹配是否从噪声期到收敛期变稳定。
+
+5. 多 current latent frame 可视化
+
+   当前推荐只看一个 current frame，例如 `-1`。后续可以对 `0..8` 全部导出，生成 grid 或小视频。
+
+6. warped previous frame
+
+   可以用 token correspondence 把 previous short frame 的 patch/grid warp 到 current frame，再与 current frame 做差分。这比 flow 图更接近视觉验证，但实现成本更高。
+
+7. mutual nearest neighbor 过滤
+
+   当前是 current -> previous short 的单向 top-k。后续可加 previous short -> current，再保留互为 top-1 的 matches，用来过滤不稳定对应。
+
+8. one-to-one matching
+
+   如果需要严格的一对一 token matching，可以在 score matrix 上做 Hungarian 或 optimal transport。但 `960 x 960` 会比当前 top-k 更重，而且未必符合 attention 本身的多对一行为。

Helios/_DEV2/app.py

@@ -0,0 +1,322 @@
+import tempfile
+import time
+from pathlib import Path
+
+import gradio as gr
+import spaces
+import torch
+
+from torch.utils._pytree import tree_map
+from diffusers import AutoencoderKLWan, HeliosDMDScheduler, HeliosPyramidPipeline
+from diffusers.utils import export_to_video, load_image, load_video
+
+
+# ---------------------------------------------------------------------------
+# Pre-load model
+# ---------------------------------------------------------------------------
+PROJECT_ROOT = Path(__file__).resolve().parent
+MODEL_ID = str(PROJECT_ROOT / "checkpoints" / "Helios-Distilled")
+
+vae = AutoencoderKLWan.from_pretrained(MODEL_ID, subfolder="vae", torch_dtype=torch.float32)
+scheduler = HeliosDMDScheduler.from_pretrained(MODEL_ID, subfolder="scheduler")
+pipe = HeliosPyramidPipeline.from_pretrained(
+    MODEL_ID, vae=vae, scheduler=scheduler, torch_dtype=torch.bfloat16, is_distilled=True
+)
+pipe.to("cuda")
+
+cuda_major = torch.cuda.get_device_capability()[0]
+if cuda_major >= 9:
+    # H100/H800 (SM90+) with FA3
+    try:
+        pipe.transformer.set_attention_backend("_flash_3_hub")
+    except Exception:
+        pipe.transformer.set_attention_backend("flash_hub")
+else:
+    # 4090/A100 etc (SM89+) with FA2
+    pipe.transformer.set_attention_backend("flash_hub")
+
+# ---------------------------------------------------------------------------
+# AoTI
+# ---------------------------------------------------------------------------
+
+# Dynamic shapes: within a generation, only hidden_states H/W change across
+# pyramid stages (history latents stay at full resolution). text_seq_length
+# varies between different prompts.
+_AUTO = torch.export.Dim.AUTO
+
+TRANSFORMER_DYNAMIC_SHAPES = {
+    "hidden_states": {
+        3: _AUTO,  # H — doubles each pyramid stage
+        4: _AUTO,  # W — doubles each pyramid stage
+    },
+    "encoder_hidden_states": {
+        1: _AUTO,  # text_seq_length — varies with prompt
+    },
+}
+
+INDUCTOR_CONFIGS = {
+    "conv_1x1_as_mm": True,
+    "epilogue_fusion": False,
+    "coordinate_descent_tuning": True,
+    "coordinate_descent_check_all_directions": True,
+    # "max_autotune": True,
+    "triton.cudagraphs": True,
+}
+
+@spaces.GPU(duration=1500) # maximum duration allowed during startup
+def compile_transformer():
+    with spaces.aoti_capture(pipe.transformer) as call:
+        pipe(
+            "arbitrary example prompt",
+            height=384,
+            width=640,
+            num_frames=33,
+            guidance_scale=1.0,
+            generator=torch.Generator(device="cuda").manual_seed(42),
+            pyramid_num_inference_steps_list=[2, 2, 2],
+            is_amplify_first_chunk=True,
+        )
+
+    dynamic_shapes = tree_map(lambda t: None, call.kwargs)
+    dynamic_shapes |= TRANSFORMER_DYNAMIC_SHAPES
+
+    with torch.no_grad():
+        exported = torch.export.export(
+            pipe.transformer,
+            args=call.args,
+            kwargs=call.kwargs,
+            dynamic_shapes=dynamic_shapes,
+        )
+
+    return spaces.aoti_compile(exported, INDUCTOR_CONFIGS)
+
+compiled_transformer = compile_transformer()
+spaces.aoti_apply(compiled_transformer, pipe.transformer)
+
+
+# ---------------------------------------------------------------------------
+# Generation
+# ---------------------------------------------------------------------------
+@spaces.GPU(duration=60)
+def generate_video(
+    mode: str,
+    prompt: str,
+    image_input,
+    video_input,
+    height: int,
+    width: int,
+    num_frames: int,
+    num_inference_steps: int,
+    seed: int,
+    is_amplify_first_chunk: bool,
+    progress=gr.Progress(track_tqdm=True),
+):
+    if not prompt:
+        raise gr.Error("Please provide a prompt.")
+
+    generator = torch.Generator(device="cuda").manual_seed(int(seed))
+
+    kwargs = {
+        "prompt": prompt,
+        "height": int(height),
+        "width": int(width),
+        "num_frames": int(num_frames),
+        "guidance_scale": 1.0,
+        "generator": generator,
+        "output_type": "np",
+        "pyramid_num_inference_steps_list": [
+            int(num_inference_steps),
+            int(num_inference_steps),
+            int(num_inference_steps),
+        ],
+        "is_amplify_first_chunk": is_amplify_first_chunk,
+    }
+
+    if mode == "Image-to-Video" and image_input is not None:
+        img = load_image(image_input).resize((int(width), int(height)))
+        kwargs["image"] = img
+    elif mode == "Video-to-Video" and video_input is not None:
+        kwargs["video"] = load_video(video_input)
+
+    t0 = time.time()
+    output = pipe(**kwargs).frames[0]
+    elapsed = time.time() - t0
+
+    tmp = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
+    export_to_video(output, tmp.name, fps=24)
+    info = f"Generated in {elapsed:.1f}s · {num_frames} frames · {height}×{width}"
+    return tmp.name, info
+
+
+# ---------------------------------------------------------------------------
+# UI Setup
+# ---------------------------------------------------------------------------
+def update_conditional_visibility(mode):
+    if mode == "Image-to-Video":
+        return gr.update(visible=True), gr.update(visible=False)
+    elif mode == "Video-to-Video":
+        return gr.update(visible=False), gr.update(visible=True)
+    else:
+        return gr.update(visible=False), gr.update(visible=False)
+
+
+CSS = """
+#header { text-align: center; margin-bottom: 1.5em; }
+#header h1 { font-size: 2.2em; margin-bottom: 0.2em; }
+.logo { max-height: 100px; margin: 0 auto 10px auto; display: block; }
+.link-buttons { display: flex; justify-content: center; gap: 15px; margin-top: 10px; }
+.link-buttons a {
+    background-color: #2b3137;
+    color: #ffffff !important;
+    padding: 8px 20px;
+    border-radius: 6px;
+    text-decoration: none;
+    font-weight: 600;
+    font-size: 1em;
+    transition: all 0.2s ease-in-out;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+}
+.link-buttons a:hover { background-color: #4a535c; transform: translateY(-1px); }
+.contain { max-width: 1350px; margin: 0 auto !important; }
+"""
+
+with gr.Blocks(title="Helios Video Generation") as demo:
+    gr.HTML(
+        """
+        <div style='display: flex; align-items: center; justify-content: center; width: 100%;'>
+            <img src="https://raw.githubusercontent.com/SHYuanBest/shyuanbest_media/main/Helios/logo_white.png" style='width: 400px; height: auto;' />
+        </div>
+        <div id="header">
+            <h1>🎬 Helios 14B Distilled: Real Real-Time Long Video Generation Model</h1>
+            <p style="font-size: 1.1em; color: #666; margin-top: 0.5em; margin-bottom: 1em;">
+                If you like our project, please give us a star ⭐ on GitHub for the latest update.
+            </p>
+            <div class="link-buttons">
+                <a href="https://github.com/PKU-YuanGroup/Helios" target="_blank">💻 Code</a>
+                <a href="https://pku-yuangroup.github.io/Helios-Page" target="_blank">📄 Page</a>
+                <a href="https://www.youtube.com/watch?v=vd_AgHtOUFQ" target="_blank">🎥 Main Feature</a>
+                <a href="https://www.youtube.com/watch?v=1GeIU2Dn7UY" target="_blank">⚡ Inference Speed</a>
+            </div>
+        </div>
+        """
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            mode = gr.Radio(
+                choices=["Text-to-Video", "Image-to-Video", "Video-to-Video"],
+                value="Text-to-Video",
+                label="Generation Mode",
+            )
+            image_input = gr.Image(label="Image (for I2V)", type="filepath", visible=False)
+            video_input = gr.Video(label="Video (for V2V)", visible=False)
+            prompt = gr.Textbox(
+                label="Prompt",
+                lines=4,
+                value=(
+                    "A vibrant tropical fish swimming gracefully among colorful coral reefs in "
+                    "a clear, turquoise ocean. The fish has bright blue and yellow scales with a "
+                    "small, distinctive orange spot on its side, its fins moving fluidly. The coral "
+                    "reefs are alive with a variety of marine life, including small schools of "
+                    "colorful fish and sea turtles gliding by. The water is crystal clear, allowing "
+                    "for a view of the sandy ocean floor below. The reef itself is adorned with a mix "
+                    "of hard and soft corals in shades of red, orange, and green. The photo captures "
+                    "the fish from a slightly elevated angle, emphasizing its lively movements and the "
+                    "vivid colors of its surroundings. A close-up shot with dynamic movement."
+                ),
+            )
+            with gr.Accordion("Advanced Settings", open=False):
+                with gr.Row():
+                    height = gr.Number(value=384, label="Height", precision=0, interactive=False)
+                    width = gr.Number(value=640, label="Width", precision=0, interactive=False)
+                with gr.Row():
+                    num_frames = gr.Slider(33, 231, value=231, step=33, label="Num Frames")
+                    num_inference_steps = gr.Slider(1, 10, value=2, step=1, label="Steps per stage")
+                with gr.Row():
+                    seed = gr.Number(value=42, label="Seed", precision=0)
+                    is_amplify_first_chunk = gr.Checkbox(label="Amplify First Chunk", value=True)
+
+            generate_btn = gr.Button("🚀 Generate Video", variant="primary", size="lg")
+
+        with gr.Column(scale=1):
+            video_output = gr.Video(label="Generated Video", autoplay=True)
+            info_output = gr.Textbox(label="Info", interactive=False)
+
+    mode.change(fn=update_conditional_visibility, inputs=[mode], outputs=[image_input, video_input])
+    generate_btn.click(
+        fn=generate_video,
+        inputs=[
+            mode,
+            prompt,
+            image_input,
+            video_input,
+            height,
+            width,
+            num_frames,
+            num_inference_steps,
+            seed,
+            is_amplify_first_chunk,
+        ],
+        outputs=[video_output, info_output],
+    )
+
+    gr.Examples(
+        examples=[
+            [
+                "Text-to-Video",
+                "A vibrant tropical fish swimming gracefully among colorful coral reefs in "
+                "a clear, turquoise ocean. The fish has bright blue and yellow scales with a "
+                "small, distinctive orange spot on its side, its fins moving fluidly. The coral "
+                "reefs are alive with a variety of marine life, including small schools of "
+                "colorful fish and sea turtles gliding by. The water is crystal clear, allowing "
+                "for a view of the sandy ocean floor below. The reef itself is adorned with a mix "
+                "of hard and soft corals in shades of red, orange, and green. The photo captures "
+                "the fish from a slightly elevated angle, emphasizing its lively movements and the "
+                "vivid colors of its surroundings. A close-up shot with dynamic movement.",
+                None,
+                None,
+            ],
+            [
+                "Text-to-Video",
+                "An extreme close-up of an gray-haired man with a beard in his 60s, he is deep in "
+                "thought pondering the history of the universe as he sits at a cafe in Paris, his eyes "
+                "focus on people offscreen as they walk as he sits mostly motionless, he is dressed in "
+                "a wool coat suit coat with a button-down shirt , he wears a brown beret and glasses "
+                "and has a very professorial appearance, and the end he offers a subtle closed-mouth "
+                "smile as if he found the answer to the mystery of life, the lighting is very cinematic "
+                "with the golden light and the Parisian streets and city in the background, depth of "
+                "field, cinematic 35mm film.",
+                None,
+                None,
+            ],
+            [
+                "Text-to-Video",
+                "A drone camera circles around a beautiful historic church built on a rocky outcropping "
+                "along the Amalfi Coast, the view showcases historic and magnificent architectural "
+                "details and tiered pathways and patios, waves are seen crashing against the rocks "
+                "below as the view overlooks the horizon of the coastal waters and hilly landscapes "
+                "of the Amalfi Coast Italy, several distant people are seen walking and enjoying vistas "
+                "on patios of the dramatic ocean views, the warm glow of the afternoon sun creates a "
+                "magical and romantic feeling to the scene, the view is stunning captured with beautiful photography.",
+                None,
+                None,
+            ],
+            [
+                "Image-to-Video",
+                "A towering emerald wave surges forward, its crest curling with raw power and energy. Sunlight glints off the translucent water, illuminating the intricate textures and deep green hues within the wave’s body. A thick spray erupts from the breaking crest, casting a misty veil that dances above the churning surface. As the perspective widens, the immense scale of the wave becomes apparent, revealing the restless expanse of the ocean stretching beyond. The scene captures the ocean’s untamed beauty and relentless force, with every droplet and ripple shimmering in the light. The dynamic motion and vivid colors evoke both awe and respect for nature’s might.",
+                "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/helios/wave.jpg",
+                None,
+            ],
+            [
+                "Video-to-Video",
+                "A bright yellow Lamborghini Huracn Tecnica speeds along a curving mountain road, surrounded by lush green trees under a partly cloudy sky. The car's sleek design and vibrant color stand out against the natural backdrop, emphasizing its dynamic movement. The road curves gently, with a guardrail visible on one side, adding depth to the scene. The motion blur captures the sense of speed and energy, creating a thrilling and exhilarating atmosphere. A front-facing shot from a slightly elevated angle, highlighting the car's aggressive stance and the surrounding greenery.",
+                None,
+                "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/helios/car.mp4",
+            ],
+        ],
+        inputs=[mode, prompt, image_input, video_input],
+        label="Example Prompts",
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=True, css=CSS, theme=gr.themes.Soft())

Helios/_DEV2/bench_infer.py

@@ -0,0 +1,569 @@
+"""
+Helios Benchmark Inference Script
+- Runs T2V inference for a single model version on a single GPU
+- Uses the first N prompts from a txt file
+- Saves videos in two layouts:  by_prompt/<slug>/<version>.mp4
+                                 by_version/<version>/<slug>.mp4
+- Records per-video timing to timing_<version>.txt and computes summary stats
+"""
+
+import importlib
+import os
+import re
+import shutil
+import sys
+import time
+
+os.environ["HF_ENABLE_PARALLEL_LOADING"] = "yes"
+os.environ["HF_PARALLEL_LOADING_WORKERS"] = "8"
+
+import argparse
+import subprocess
+from pathlib import Path
+
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+DEFAULT_PROMPT_FILE = SCRIPT_DIR / "demo_data" / "MovieGenVideoBench_extended.txt"
+DEFAULT_MODEL_ROOT = SCRIPT_DIR / "checkpoints"
+DEFAULT_OUTPUT_ROOT = SCRIPT_DIR / "output_helios" / "bench"
+
+
+def pick_gpu_by_free_vram(min_free_mib=20000):
+    """Pick physical GPU index with the most free memory (via nvidia-smi). No torch import."""
+    try:
+        out = subprocess.check_output(
+            [
+                "nvidia-smi",
+                "--query-gpu=index,memory.free",
+                "--format=csv,noheader,nounits",
+            ],
+            text=True,
+            stderr=subprocess.DEVNULL,
+        )
+    except (subprocess.CalledProcessError, FileNotFoundError) as e:
+        raise RuntimeError("nvidia-smi failed; specify --gpu explicitly") from e
+
+    best_idx, best_free = None, -1
+    for line in out.strip().splitlines():
+        parts = [p.strip() for p in line.split(",")]
+        if len(parts) < 2:
+            continue
+        idx, free = int(parts[0]), int(parts[1])
+        if free > best_free:
+            best_free, best_idx = free, idx
+    if best_idx is None:
+        raise RuntimeError("Could not parse nvidia-smi GPU list")
+    if best_free < min_free_mib:
+        print(
+            f"[warn] Best GPU {best_idx} has only {best_free} MiB free "
+            f"(<{min_free_mib} MiB); OOM risk — consider --enable_low_vram_mode",
+            file=sys.stderr,
+        )
+    return best_idx, best_free
+
+
+def _apply_cuda_visible_devices_before_torch():
+    """CUDA_VISIBLE_DEVICES must be set before `import torch` (first CUDA init)."""
+    pre = argparse.ArgumentParser(add_help=False)
+    pre.add_argument("--gpu", type=str, default="auto")
+    known, _ = pre.parse_known_args()
+    g = known.gpu.strip().lower()
+    if g == "auto":
+        idx, free = pick_gpu_by_free_vram()
+        os.environ["CUDA_VISIBLE_DEVICES"] = str(idx)
+        os.environ["_BENCH_PHYSICAL_GPU"] = f"{idx} ({free} MiB free)"
+    else:
+        os.environ["CUDA_VISIBLE_DEVICES"] = known.gpu.strip()
+        os.environ["_BENCH_PHYSICAL_GPU"] = known.gpu.strip()
+    os.environ["_BENCH_GPU_ARG"] = known.gpu.strip()
+
+
+_apply_cuda_visible_devices_before_torch()
+
+import torch
+from tqdm import tqdm
+
+if importlib.util.find_spec("torch_npu") is not None:
+    import torch_npu  # noqa: F401
+
+from helios.diffusers_version.pipeline_helios_diffusers import HeliosPipeline
+from helios.diffusers_version.scheduling_helios_diffusers import HeliosScheduler
+from helios.diffusers_version.transformer_helios_diffusers import HeliosTransformer3DModel
+from helios.modules.helios_kernels import (
+    replace_all_norms_with_flash_norms,
+    replace_rmsnorm_with_fp32,
+    replace_rope_with_flash_rope,
+)
+from diffusers.models import AutoencoderKLWan
+from diffusers.utils import export_to_video
+
+# ── per-version inference presets (matching official scripts) ─────────────────
+
+MODEL_PRESETS = {
+    "base": dict(
+        model_dir="Helios-Base",
+        num_frames=99,
+        num_inference_steps=50,
+        guidance_scale=5.0,
+        is_enable_stage2=False,
+        pyramid_num_inference_steps_list=[20, 20, 20],
+        is_amplify_first_chunk=False,
+        use_zero_init=False,
+        zero_steps=1,
+    ),
+    "mid": dict(
+        model_dir="Helios-Mid",
+        num_frames=99,
+        num_inference_steps=50,
+        guidance_scale=5.0,
+        is_enable_stage2=True,
+        pyramid_num_inference_steps_list=[20, 20, 20],
+        is_amplify_first_chunk=False,
+        use_zero_init=True,
+        zero_steps=1,
+    ),
+    "distilled": dict(
+        model_dir="Helios-Distilled",
+        num_frames=240,
+        num_inference_steps=50,
+        guidance_scale=1.0,
+        is_enable_stage2=True,
+        pyramid_num_inference_steps_list=[2, 2, 2],
+        is_amplify_first_chunk=True,
+        use_zero_init=False,
+        zero_steps=1,
+    ),
+}
+
+NEGATIVE_PROMPT = (
+    "Bright tones, overexposed, static, blurred details, subtitles, style, "
+    "works, paintings, images, static, overall gray, worst quality, low quality, "
+    "JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, "
+    "poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, "
+    "still picture, messy background, three legs, many people in the background, "
+    "walking backwards"
+)
+
+
+def sanitize_filename(text, max_len=80):
+    """Turn a prompt into a filesystem-safe slug."""
+    text = text.strip().lower()
+    text = re.sub(r"[^a-z0-9]+", "_", text)
+    text = text.strip("_")
+    return text[:max_len]
+
+
+def load_prompt_indices(path):
+    indices = []
+    with open(path, "r", encoding="utf-8") as f:
+        for line_no, raw_line in enumerate(f, start=1):
+            line = raw_line.strip()
+            if not line or line.startswith("#"):
+                continue
+            try:
+                idx = int(line)
+            except ValueError as exc:
+                raise ValueError(
+                    f"Invalid prompt index at {path}:{line_no}: {line!r}"
+                ) from exc
+            if idx < 0:
+                raise ValueError(f"Prompt index must be >= 0 at {path}:{line_no}")
+            indices.append(idx)
+    return indices
+
+
+def load_prompts(path, prompt_start=0, prompt_end=None, prompt_indices=None):
+    with open(path, "r", encoding="utf-8") as f:
+        lines = [line.strip() for line in f if line.strip()]
+    if prompt_indices is not None:
+        selected = []
+        total = len(lines)
+        for idx in prompt_indices:
+            if idx >= total:
+                raise ValueError(
+                    f"Prompt index {idx} is out of range; prompt file has {total} prompts"
+                )
+            selected.append((idx, lines[idx]))
+        return selected
+
+    if prompt_start < 0:
+        raise ValueError("prompt_start must be >= 0")
+    if prompt_end is not None and prompt_end < prompt_start:
+        raise ValueError("prompt_end must be >= prompt_start")
+
+    selected = lines[prompt_start:prompt_end]
+    return [(prompt_start + offset, prompt) for offset, prompt in enumerate(selected)]
+
+
+def build_expected_outputs(prompts, version, by_version_dir):
+    version_dir = os.path.join(by_version_dir, version)
+    expected = []
+    for idx, prompt in prompts:
+        slug = sanitize_filename(prompt)
+        vid_name = f"{idx:04d}_{slug}"
+        expected.append((idx, slug, os.path.join(version_dir, f"{vid_name}.mp4")))
+    return version_dir, expected
+
+
+def output_exists(path):
+    return os.path.isfile(path) and os.path.getsize(path) > 0
+
+
+def find_missing_outputs(expected_outputs):
+    return [item for item in expected_outputs if not output_exists(item[2])]
+
+
+def make_timing_line(version, idx, elapsed, slug):
+    return (
+        f"  {version:10s}  #{idx:04d}  {elapsed:8.2f}s  "
+        f"({elapsed / 60:5.2f}min)  {slug[:50]}"
+    )
+
+
+def load_existing_timing_records(timing_file, version):
+    if not os.path.exists(timing_file):
+        return {}
+
+    pattern = re.compile(
+        rf"^\s*{re.escape(version)}\s+#(\d+)\s+([0-9.]+)s\s+\([^)]+\)\s+(.*)$"
+    )
+    records = {}
+    with open(timing_file, "r", encoding="utf-8") as f:
+        for raw_line in f:
+            line = raw_line.rstrip("\n")
+            match = pattern.match(line)
+            if not match:
+                continue
+            idx = int(match.group(1))
+            elapsed = float(match.group(2))
+            slug = match.group(3)
+            records[idx] = (elapsed, slug)
+    return records
+
+
+def build_pipeline(
+    model_path,
+    device,
+    weight_dtype,
+    enable_low_vram=False,
+    group_offloading_type="leaf_level",
+    num_blocks_per_group=4,
+):
+    transformer = HeliosTransformer3DModel.from_pretrained(
+        model_path, subfolder="transformer", torch_dtype=weight_dtype,
+    )
+    transformer = replace_rmsnorm_with_fp32(transformer)
+    transformer = replace_all_norms_with_flash_norms(transformer)
+    replace_rope_with_flash_rope()
+
+    cuda_major = torch.cuda.get_device_capability()[0]
+    if cuda_major >= 9:
+        try:
+            transformer.set_attention_backend("_flash_3_hub")
+        except Exception:
+            transformer.set_attention_backend("flash_hub")
+    else:
+        transformer.set_attention_backend("flash_hub")
+
+    vae = AutoencoderKLWan.from_pretrained(
+        model_path, subfolder="vae", torch_dtype=torch.float32,
+    )
+    scheduler = HeliosScheduler.from_pretrained(model_path, subfolder="scheduler")
+
+    pipe = HeliosPipeline.from_pretrained(
+        model_path,
+        transformer=transformer,
+        vae=vae,
+        scheduler=scheduler,
+        torch_dtype=weight_dtype,
+    )
+    if enable_low_vram:
+        nbg = int(num_blocks_per_group) if group_offloading_type == "block_level" else None
+        pipe.enable_group_offload(
+            onload_device=torch.device("cuda"),
+            offload_device=torch.device("cpu"),
+            offload_type=group_offloading_type,
+            num_blocks_per_group=nbg,
+            use_stream=True,
+            record_stream=True,
+        )
+    else:
+        pipe = pipe.to(device)
+    return pipe
+
+
+def run_single(pipe, prompt, preset, height, width, seed):
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+
+    t0 = time.time()
+    with torch.no_grad():
+        output = pipe(
+            prompt=prompt,
+            negative_prompt=NEGATIVE_PROMPT,
+            height=height,
+            width=width,
+            num_frames=preset["num_frames"],
+            num_inference_steps=preset["num_inference_steps"],
+            guidance_scale=preset["guidance_scale"],
+            generator=gen,
+            history_sizes=[16, 2, 1],
+            num_latent_frames_per_chunk=9,
+            keep_first_frame=True,
+            is_enable_stage2=preset["is_enable_stage2"],
+            pyramid_num_inference_steps_list=preset["pyramid_num_inference_steps_list"],
+            is_skip_first_chunk=False,
+            is_amplify_first_chunk=preset["is_amplify_first_chunk"],
+            use_zero_init=preset["use_zero_init"],
+            zero_steps=preset["zero_steps"],
+        ).frames[0]
+    elapsed = time.time() - t0
+    return output, elapsed
+
+
+def _parse_gpu(s):
+    if isinstance(s, str) and s.lower() == "auto":
+        return "auto"
+    return int(s)
+
+
+def parse_args():
+    p = argparse.ArgumentParser(description="Helios benchmark inference for one model version")
+    p.add_argument("--prompt_file", type=str,
+                    default=str(DEFAULT_PROMPT_FILE))
+    p.add_argument("--prompt_start", type=int, default=0)
+    p.add_argument("--prompt_end", type=int, default=100,
+                    help="Exclusive end index for prompts, e.g. 50 means up to #49")
+    p.add_argument("--prompt_indices_file", type=str, default=None,
+                    help="Optional file containing exact prompt indices to run, one per line")
+    p.add_argument("--model_root", type=str, default=str(DEFAULT_MODEL_ROOT),
+                    help="Parent dir containing Helios-Base / Helios-Mid / Helios-Distilled")
+    p.add_argument("--output_root", type=str, default=str(DEFAULT_OUTPUT_ROOT))
+    p.add_argument("--version", type=str, choices=sorted(MODEL_PRESETS.keys()), required=True,
+                    help="Which model version to run")
+    p.add_argument("--timing_file", type=str, default=None,
+                    help="Optional override for timing report path")
+    p.add_argument("--height", type=int, default=384)
+    p.add_argument("--width", type=int, default=640)
+    p.add_argument("--num_frames", type=int, default=None,
+                    help="Override preset frame count for all selected versions")
+    p.add_argument("--seed", type=int, default=42)
+    p.add_argument(
+        "--gpu",
+        type=_parse_gpu,
+        default="auto",
+        help='Physical GPU id or "auto" (pick most free VRAM via nvidia-smi)',
+    )
+    p.add_argument(
+        "--enable_low_vram_mode",
+        action="store_true",
+        help="CPU group-offload (slower, less VRAM); use if GPU is shared or OOM",
+    )
+    p.add_argument(
+        "--group_offloading_type",
+        type=str,
+        choices=["leaf_level", "block_level"],
+        default="leaf_level",
+    )
+    p.add_argument("--num_blocks_per_group", type=int, default=4)
+    return p.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    if not os.path.isfile(args.prompt_file):
+        raise FileNotFoundError(f"Prompt file not found: {args.prompt_file}")
+    if not os.path.isdir(args.model_root):
+        raise FileNotFoundError(f"Model root not found: {args.model_root}")
+
+    os.environ["CUDA_VISIBLE_DEVICES"] = str(args.gpu)
+    device = torch.device("cuda")
+    weight_dtype = torch.bfloat16
+
+    prompt_indices = None
+    if args.prompt_indices_file:
+        if not os.path.isfile(args.prompt_indices_file):
+            raise FileNotFoundError(f"Prompt indices file not found: {args.prompt_indices_file}")
+        prompt_indices = load_prompt_indices(args.prompt_indices_file)
+
+    prompts = load_prompts(
+        args.prompt_file,
+        args.prompt_start,
+        args.prompt_end,
+        prompt_indices=prompt_indices,
+    )
+    prompt_map = dict(prompts)
+    if args.prompt_indices_file:
+        print(
+            f"Loaded {len(prompts)} prompts from {args.prompt_file} "
+            f"(indices: {args.prompt_indices_file})"
+        )
+    else:
+        print(
+            f"Loaded {len(prompts)} prompts from {args.prompt_file} "
+            f"(range: {args.prompt_start}:{args.prompt_end})"
+        )
+
+    if args.num_frames is not None:
+        MODEL_PRESETS[args.version]["num_frames"] = args.num_frames
+
+    by_prompt_dir = os.path.join(args.output_root, "by_prompt")
+    by_version_dir = os.path.join(args.output_root, "by_version")
+    timing_file = args.timing_file or os.path.join(args.output_root, f"timing_{args.version}.txt")
+    os.makedirs(args.output_root, exist_ok=True)
+
+    preset = MODEL_PRESETS[args.version]
+    model_path = os.path.join(args.model_root, preset["model_dir"])
+    timing_records = load_existing_timing_records(timing_file, args.version)
+    selected_indices = set(prompt_map)
+    timing_records = {
+        idx: record for idx, record in timing_records.items() if idx in selected_indices
+    }
+    ver_dir, expected_outputs = build_expected_outputs(prompts, args.version, by_version_dir)
+    missing_outputs = find_missing_outputs(expected_outputs)
+    if not os.path.isdir(model_path):
+        raise FileNotFoundError(f"Model not found: {model_path}")
+
+    peak_mem = None
+    if not missing_outputs:
+        print(
+            f"[SKIP] All outputs already exist for version={args.version} under {ver_dir}"
+        )
+    else:
+        header = (
+            f"\n{'=' * 60}\n"
+            f"  Version: {args.version}  |  Model: {preset['model_dir']}\n"
+            f"  Frames: {preset['num_frames']}  |  guidance_scale: {preset['guidance_scale']}\n"
+            f"  stage2: {preset['is_enable_stage2']}  |  pyramid_steps: {preset['pyramid_num_inference_steps_list']}\n"
+            f"{'=' * 60}\n"
+        )
+        print(header)
+
+        pipe = build_pipeline(
+            model_path,
+            device,
+            weight_dtype,
+            enable_low_vram=args.enable_low_vram_mode,
+            group_offloading_type=args.group_offloading_type,
+            num_blocks_per_group=args.num_blocks_per_group,
+        )
+
+        os.makedirs(ver_dir, exist_ok=True)
+
+        print(
+            f"[resume] version={args.version} existing={len(expected_outputs) - len(missing_outputs)} "
+            f"missing={len(missing_outputs)} timed={len(timing_records)}"
+        )
+        for idx, slug, ver_out in tqdm(missing_outputs, desc=f"[{args.version}]"):
+            if os.path.exists(ver_out):
+                print(f"  [skip] {ver_out}")
+                continue
+
+            try:
+                frames, elapsed = run_single(
+                    pipe, prompt_map[idx], preset, args.height, args.width, args.seed,
+                )
+            except Exception as e:
+                msg = f"  [FAIL] {args.version} #{idx:04d}: {e}"
+                print(msg)
+                continue
+
+            export_to_video(frames, ver_out, fps=24)
+
+            vid_name = os.path.splitext(os.path.basename(ver_out))[0]
+            prompt_dir = os.path.join(by_prompt_dir, vid_name)
+            os.makedirs(prompt_dir, exist_ok=True)
+            shutil.copy2(ver_out, os.path.join(prompt_dir, f"{args.version}.mp4"))
+
+            timing_records[idx] = (elapsed, slug)
+            print(make_timing_line(args.version, idx, elapsed, slug))
+
+        peak_mem = torch.cuda.max_memory_allocated() / 1024 ** 3
+        print(f"  >> [{args.version}] peak GPU memory: {peak_mem:.2f} GB")
+
+        del pipe
+        torch.cuda.empty_cache()
+        torch.cuda.reset_peak_memory_stats()
+
+    sorted_records = [timing_records[idx] for idx in sorted(timing_records)]
+    all_timings = [elapsed for elapsed, _ in sorted_records]
+
+    with open(timing_file, "w", encoding="utf-8") as tf:
+        tf.write(f"{'=' * 80}\n")
+        tf.write(f"  Helios Benchmark Inference Timing Report\n")
+        tf.write(f"  {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
+        tf.write(
+            f"  Prompts: {len(prompts)}  |  Range: {args.prompt_start}:{args.prompt_end}  "
+            f"|  Version: {args.version}\n"
+        )
+        if args.prompt_indices_file:
+            tf.write(f"  Prompt indices file: {args.prompt_indices_file}\n")
+        tf.write(
+            f"  Resolution: {args.width}x{args.height}  |  Seed: {args.seed}  |  "
+            f"GPU: {args.gpu}  |  low_vram: {args.enable_low_vram_mode}\n"
+        )
+        tf.write(f"{'=' * 80}\n\n")
+
+        tf.write(
+            f"\n{'=' * 60}\n"
+            f"  Version: {args.version}  |  Model: {preset['model_dir']}\n"
+            f"  Frames: {preset['num_frames']}  |  guidance_scale: {preset['guidance_scale']}\n"
+            f"  stage2: {preset['is_enable_stage2']}  |  pyramid_steps: {preset['pyramid_num_inference_steps_list']}\n"
+            f"{'=' * 60}\n"
+        )
+        tf.write(
+            f"  Existing timing records: {len(timing_records)} / expected outputs: {len(expected_outputs)}\n"
+        )
+
+        for idx in sorted(timing_records):
+            elapsed, slug = timing_records[idx]
+            tf.write(make_timing_line(args.version, idx, elapsed, slug) + "\n")
+
+        if all_timings:
+            avg_t = sum(all_timings) / len(all_timings)
+            total_t = sum(all_timings)
+            summary = (
+                f"\n  >> [{args.version}] completed {len(all_timings)} videos  |  "
+                f"avg: {avg_t:.2f}s ({avg_t / 60:.2f}min)  |  "
+                f"total: {total_t:.1f}s ({total_t / 60:.1f}min)\n"
+            )
+        else:
+            summary = f"\n  >> [{args.version}] no timing records available\n"
+        print(summary)
+        tf.write(summary)
+
+        if peak_mem is not None:
+            mem_line = f"  >> [{args.version}] peak GPU memory: {peak_mem:.2f} GB\n"
+            tf.write(mem_line)
+
+        sep = f"\n{'=' * 80}\n"
+        tf.write(sep)
+        tf.write("  FINAL SUMMARY\n")
+        tf.write(f"{'=' * 80}\n")
+        print(sep)
+        print("  FINAL SUMMARY")
+        print(f"{'=' * 80}")
+
+        fmt = "  {ver:12s} | videos: {n:3d} | avg: {avg:8.2f}s ({avgm:5.2f}min) | min: {mn:8.2f}s | max: {mx:8.2f}s | total: {tot:8.1f}s ({totm:5.1f}min)"
+        if all_timings:
+            line = fmt.format(
+                ver=args.version, n=len(all_timings),
+                avg=sum(all_timings) / len(all_timings), avgm=sum(all_timings) / len(all_timings) / 60,
+                mn=min(all_timings), mx=max(all_timings),
+                tot=sum(all_timings), totm=sum(all_timings) / 60,
+            )
+        else:
+            line = f"  {args.version:12s} | N/A (no timing records)"
+        print(line)
+        tf.write(line + "\n")
+
+        tf.write(f"{'=' * 80}\n")
+
+    print(f"{'=' * 80}")
+    print(f"\nTiming report: {timing_file}")
+    print(f"Videos:        {by_prompt_dir}")
+    print(f"               {by_version_dir}")
+
+
+if __name__ == "__main__":
+    main()

Helios/_DEV2/infer_helios.py

@@ -0,0 +1,673 @@
+import importlib
+import os
+
+
+os.environ["HF_ENABLE_PARALLEL_LOADING"] = "yes"
+os.environ["HF_PARALLEL_LOADING_WORKERS"] = "8"
+
+import argparse
+import time
+from pathlib import Path
+
+import pandas as pd
+import torch
+import torch.distributed as dist
+from tqdm import tqdm
+
+
+if importlib.util.find_spec("torch_npu") is not None:
+    import torch_npu
+else:
+    torch_npu = None
+
+from helios.diffusers_version.pipeline_helios_diffusers import HeliosPipeline
+from helios.diffusers_version.scheduling_helios_diffusers import HeliosScheduler
+from helios.diffusers_version.transformer_helios_diffusers import HeliosTransformer3DModel
+from helios.modules.helios_kernels import (
+    replace_all_norms_with_flash_norms,
+    replace_rmsnorm_with_fp32,
+    replace_rope_with_flash_rope,
+)
+from helios.utils.utils_base import load_extra_components
+
+from diffusers import ContextParallelConfig
+from diffusers.models import AutoencoderKLWan
+from diffusers.utils import export_to_video, load_image, load_video
+
+PROJECT_ROOT = Path(__file__).resolve().parent
+DEFAULT_BASE_MODEL_PATH = str(PROJECT_ROOT / "checkpoints" / "Helios-Base")
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Generate video with model")
+
+    # === Model paths ===
+    parser.add_argument("--base_model_path", type=str, default=DEFAULT_BASE_MODEL_PATH)
+    parser.add_argument(
+        "--transformer_path",
+        type=str,
+        default=DEFAULT_BASE_MODEL_PATH,
+    )
+    parser.add_argument(
+        "--lora_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--partial_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument("--output_folder", type=str, default="./output_helios")
+    parser.add_argument("--enable_compile", action="store_true")
+
+    # === Generation parameters ===
+    # environment
+    parser.add_argument(
+        "--sample_type",
+        type=str,
+        default="t2v",
+        choices=["t2v", "i2v", "v2v"],
+    )
+    parser.add_argument(
+        "--weight_dtype",
+        type=str,
+        default="bf16",
+        choices=["bf16", "fp16", "fp32"],
+        help="Data type for model weights.",
+    )
+    parser.add_argument("--seed", type=int, default=42, help="Seed for random number generator.")
+    # base
+    parser.add_argument("--height", type=int, default=384)
+    parser.add_argument("--width", type=int, default=640)
+    parser.add_argument("--num_frames", type=int, default=99)
+    parser.add_argument("--fps", type=int, default=24)
+    parser.add_argument("--num_inference_steps", type=int, default=50)
+    parser.add_argument("--guidance_scale", type=float, default=5.0)
+    # cfg zero
+    parser.add_argument("--use_zero_init", action="store_true")
+    parser.add_argument("--zero_steps", type=int, default=1)
+    # stage 1
+    parser.add_argument("--num_latent_frames_per_chunk", type=int, default=9)
+    # stage 2
+    parser.add_argument("--is_enable_stage2", action="store_true")
+    parser.add_argument("--pyramid_num_inference_steps_list", type=int, nargs="+", default=[20, 20, 20])
+    # stage 3
+    parser.add_argument("--is_skip_first_chunk", action="store_true")
+    parser.add_argument("--is_amplify_first_chunk", action="store_true")
+    parser.add_argument(
+        "--visualize_relative_l1",
+        action="store_true",
+        help="Save per-chunk denoising relative L1 records and a timestep plot.",
+    )
+    parser.add_argument(
+        "--relative_l1_output_folder",
+        type=str,
+        default=None,
+        help="Deprecated. Relative L1 files are saved next to the mp4 in each prompt timestamp folder.",
+    )
+
+    # === Prompts ===
+    parser.add_argument("--use_interpolate_prompt", action="store_true")
+    parser.add_argument("--interpolation_steps", type=int, default=3)
+    parser.add_argument("--interpolate_time", type=int, default=7)
+    parser.add_argument(
+        "--image_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--image_noise_sigma_min", type=float, default=0.111, help="Balance motion amplitude and visual consistency"
+    )
+    parser.add_argument(
+        "--image_noise_sigma_max", type=float, default=0.135, help="Balance motion amplitude and visual consistency"
+    )
+    parser.add_argument(
+        "--video_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--video_noise_sigma_min", type=float, default=0.111, help="Balance motion amplitude and visual consistency"
+    )
+    parser.add_argument(
+        "--video_noise_sigma_max", type=float, default=0.135, help="Balance motion amplitude and visual consistency"
+    )
+    parser.add_argument(
+        "--prompt",
+        type=str,
+        default="A dynamic time-lapse video showing the rapidly moving scenery from the window of a speeding train. The camera captures various elements such as lush green fields, towering trees, quaint countryside houses, and distant mountain ranges passing by quickly. The train window frames the view, adding a sense of speed and motion as the landscape rushes past. The camera remains static but emphasizes the fast-paced movement outside. The overall atmosphere is serene yet exhilarating, capturing the essence of travel and exploration. Medium shot focusing on the train window and the rushing scenery beyond.",
+    )
+    parser.add_argument(
+        "--negative_prompt",
+        type=str,
+        default="Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards",
+    )
+    parser.add_argument(
+        "--prompt_txt_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--base_image_prompt_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--image_prompt_csv_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--interactive_prompt_csv_path",
+        type=str,
+        default=None,
+    )
+
+    # === Context parallelism ===
+    # Please refer to https://huggingface.co/docs/diffusers/main/en/training/distributed_inference#context-parallelism
+    parser.add_argument("--enable_parallelism", action="store_true")
+    parser.add_argument(
+        "--cp_backend",
+        type=str,
+        choices=["ring", "ulysses", "unified", "ulysses_anything"],
+        default="ulysses",
+        help="Context parallel backend to use.",
+    )
+
+    # === Group-Offloading ===
+    # Please refer to https://huggingface.co/docs/diffusers/main/en/optimization/memory#group-offloading
+    parser.add_argument("--enable_low_vram_mode", action="store_true")
+    parser.add_argument(
+        "--group_offloading_type",
+        type=str,
+        choices=["leaf_level", "block_level"],
+        default="leaf_level",
+        help="Specifies the granularity for group CPU offloading. Choose between 'leaf_level' (individual modules) or 'block_level' (entire blocks).",
+    )
+    parser.add_argument(
+        "--num_blocks_per_group",
+        type=str,
+        default="4",
+        help="The number of blocks to bundle together in each offloading group. Only relevant when using block-level offloading.",
+    )
+
+    return parser.parse_args()
+
+
+def build_sample_output_dir(output_folder, prompt_or_prompts):
+    if isinstance(prompt_or_prompts, list):
+        prompt_text = prompt_or_prompts[0] if prompt_or_prompts else "prompt"
+    else:
+        prompt_text = prompt_or_prompts or "prompt"
+
+    prompt_text = str(prompt_text).strip()
+    safe_chars = []
+    previous_was_sep = False
+    for char in prompt_text:
+        if char.isalnum():
+            safe_chars.append(char)
+            previous_was_sep = False
+        elif not previous_was_sep:
+            safe_chars.append("_")
+            previous_was_sep = True
+
+    prompt_stem = "".join(safe_chars).strip("_")[:80] or "prompt"
+    sample_dir = Path(output_folder) / f"{prompt_stem}_{int(time.time())}"
+
+    suffix = 1
+    base_sample_dir = sample_dir
+    while sample_dir.exists():
+        sample_dir = Path(f"{base_sample_dir}_{suffix}")
+        suffix += 1
+
+    sample_dir.mkdir(parents=True, exist_ok=False)
+    return sample_dir
+
+
+def save_relative_l1_outputs(records, output_folder):
+    if not records:
+        print(f"No relative L1 records for {output_folder}.")
+        return
+
+    metrics_dir = Path(output_folder)
+    metrics_dir.mkdir(parents=True, exist_ok=True)
+    df = pd.DataFrame(records).sort_values(["chunk_index", "step_index", "stage_index"])
+
+    csv_path = metrics_dir / "relative_l1.csv"
+    df.to_csv(csv_path, index=False)
+
+    try:
+        import matplotlib
+
+        matplotlib.use("Agg")
+        import matplotlib.pyplot as plt
+
+        def save_metric_plot(metric_name, ylabel, title, plot_name):
+            fig, ax = plt.subplots(figsize=(9, 5))
+            for chunk_index, chunk_df in df.groupby("chunk_index"):
+                chunk_df = chunk_df.sort_values(["step_index", "stage_index"])
+                ax.plot(
+                    chunk_df["timestep"],
+                    chunk_df[metric_name],
+                    marker="o",
+                    linewidth=1.5,
+                    markersize=3,
+                    label=f"chunk {chunk_index}",
+                )
+
+            ax.set_xlabel("timestep")
+            ax.set_ylabel(ylabel)
+            ax.set_title(title)
+            ax.grid(True, alpha=0.3)
+            ax.invert_xaxis()
+            ax.legend()
+            fig.tight_layout()
+
+            plot_path = metrics_dir / plot_name
+            fig.savefig(plot_path, dpi=200)
+            plt.close(fig)
+            return plot_path
+
+        plot_path = save_metric_plot(
+            "relative_l1",
+            "mean relative L1",
+            "Denoising relative L1 per chunk",
+            "relative_l1.png",
+        )
+        ratio_plot_path = None
+        if "relative_l1_ratio" in df.columns:
+            ratio_plot_path = save_metric_plot(
+                "relative_l1_ratio",
+                "mean(delta L1) / mean(latent L1)",
+                "Denoising relative L1 ratio per chunk",
+                "relative_l1_ratio.png",
+            )
+
+        if ratio_plot_path is None:
+            print(f"Saved relative L1 CSV to {csv_path} and plot to {plot_path}")
+        else:
+            print(f"Saved relative L1 CSV to {csv_path} and plots to {plot_path}, {ratio_plot_path}")
+    except Exception as exc:
+        print(f"Saved relative L1 CSV to {csv_path}, but failed to save plot: {exc}")
+
+
+def main():
+    args = parse_args()
+
+    assert not (args.enable_low_vram_mode and args.enable_compile), (
+        "enable_low_vram_mode and enable_compile cannot be used together."
+    )
+
+    if args.weight_dtype == "fp32":
+        args.weight_dtype = torch.float32
+    elif args.weight_dtype == "fp16":
+        args.weight_dtype = torch.float16
+    else:
+        args.weight_dtype = torch.bfloat16
+
+    os.makedirs(args.output_folder, exist_ok=True)
+
+    if dist.is_available() and "RANK" in os.environ:
+        if args.cp_backend == "ulysses_anything":
+            dist.init_process_group(backend="cpu:gloo,cuda:nccl")
+        else:
+            dist.init_process_group(backend="nccl")
+        rank = dist.get_rank()
+        device = torch.device("cuda", rank % torch.cuda.device_count())
+        world_size = dist.get_world_size()
+        torch.cuda.set_device(device)
+        assert world_size == 1 or not args.enable_low_vram_mode, "enable_low_vram_mode is only for single GPU."
+    else:
+        rank = 0
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        world_size = 1
+
+    prompt = None
+    image_path = None
+    video_path = None
+    interpolate_time_list = None
+    if args.sample_type == "t2v" and args.prompt is None:
+        prompt = "An extreme close-up of an gray-haired man with a beard in his 60s, he is deep in thought pondering the history of the universe as he sits at a cafe in Paris, his eyes focus on people offscreen as they walk as he sits mostly motionless, he is dressed in a wool coat suit coat with a button-down shirt , he wears a brown beret and glasses and has a very professorial appearance, and the end he offers a subtle closed-mouth smile as if he found the answer to the mystery of life, the lighting is very cinematic with the golden light and the Parisian streets and city in the background, depth of field, cinematic 35mm film."
+    elif args.sample_type == "i2v" and (args.image_path is None and args.prompt is None):
+        image_path = (
+            "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg"
+        )
+        prompt = "An astronaut hatching from an egg, on the surface of the moon, the darkness and depth of space realised in the background. High quality, ultrarealistic detail and breath-taking movie-like camera shot."
+    elif args.sample_type == "v2v" and (args.video_path is None and args.prompt is None):
+        video_path = (
+            "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/hiker.mp4"
+        )
+        prompt = "A robot standing on a mountain top. The sun is setting in the background."
+    else:
+        image_path = args.image_path
+        video_path = args.video_path
+        prompt = args.prompt
+
+    transformer = HeliosTransformer3DModel.from_pretrained(
+        args.transformer_path,
+        subfolder="transformer",
+        torch_dtype=args.weight_dtype,
+    )
+    if not args.enable_compile:
+        transformer = replace_rmsnorm_with_fp32(transformer)
+        transformer = replace_all_norms_with_flash_norms(transformer)
+        replace_rope_with_flash_rope()
+    cuda_major = torch.cuda.get_device_capability()[0]
+    if cuda_major >= 9:
+        # H100/H800 (SM90+) with FA3
+        try:
+            transformer.set_attention_backend("_flash_3_hub")
+        except Exception:
+            transformer.set_attention_backend("flash_hub")
+    else:
+        # 4090/A100 etc (SM89+) with FA2
+        transformer.set_attention_backend("flash_hub")
+
+    vae = AutoencoderKLWan.from_pretrained(
+        args.base_model_path,
+        subfolder="vae",
+        torch_dtype=torch.float32,
+    )
+    scheduler = HeliosScheduler.from_pretrained(
+        args.base_model_path,
+        subfolder="scheduler",
+    )
+    pipe = HeliosPipeline.from_pretrained(
+        args.base_model_path,
+        transformer=transformer,
+        vae=vae,
+        scheduler=scheduler,
+        torch_dtype=args.weight_dtype,
+    )
+
+    if args.lora_path is not None:
+        pipe.load_lora_weights(args.lora_path, adapter_name="default")
+        pipe.set_adapters(["default"], adapter_weights=[1.0])
+
+        if args.partial_path is not None:
+            if not hasattr(args, "training_config"):
+                from argparse import Namespace
+
+                args.training_config = Namespace()
+            args.training_config.is_enable_stage1 = True
+            args.training_config.restrict_self_attn = True
+            args.training_config.is_amplify_history = True
+            args.training_config.is_use_gan = True
+            load_extra_components(args, transformer, args.partial_path)
+
+    if args.enable_compile:
+        torch.backends.cudnn.benchmark = True
+        pipe.text_encoder.compile(mode="max-autotune-no-cudagraphs", dynamic=False)
+        pipe.vae.compile(mode="max-autotune-no-cudagraphs", dynamic=False)
+        pipe.transformer.compile(mode="max-autotune-no-cudagraphs", dynamic=False)
+
+    if args.enable_low_vram_mode:
+        pipe.enable_group_offload(
+            onload_device=torch.device("cuda"),
+            offload_device=torch.device("cpu"),
+            offload_type=args.group_offloading_type,
+            num_blocks_per_group=args.num_blocks_per_group if args.group_offloading_type == "block_level" else None,
+            use_stream=True,
+            record_stream=True,
+        )
+    else:
+        pipe = pipe.to(device)
+
+    if world_size > 1 and args.enable_parallelism:
+        if args.cp_backend == "ring":
+            cp_config = ContextParallelConfig(ring_degree=world_size)
+        elif args.cp_backend == "unified":
+            cp_config = ContextParallelConfig(ring_degree=world_size // 2, ulysses_degree=world_size // 2)
+        elif args.cp_backend == "ulysses":
+            cp_config = ContextParallelConfig(ulysses_degree=world_size)
+        elif args.cp_backend == "ulysses_anything":
+            cp_config = ContextParallelConfig(ulysses_degree=world_size, ulysses_anything=True)
+        else:
+            raise ValueError(f"Unsupported cp_backend: {args.cp_backend}")
+
+        pipe.transformer.enable_parallelism(config=cp_config)
+
+    if args.prompt_txt_path is not None:
+        with open(args.prompt_txt_path, "r") as f:
+            prompt_list = [line.strip() for line in f.readlines() if line.strip()]
+        if not args.enable_parallelism:
+            prompt_list_with_idx = [(i, prompt) for i, prompt in enumerate(prompt_list)]
+            prompt_list_with_idx = prompt_list_with_idx[rank::world_size]
+        else:
+            prompt_list_with_idx = [(i, prompt) for i, prompt in enumerate(prompt_list)]
+
+        for idx, prompt in tqdm(prompt_list_with_idx, desc="Processing prompts"):
+            with torch.no_grad():
+                try:
+                    pipe_output = pipe(
+                        prompt=prompt,
+                        negative_prompt=args.negative_prompt,
+                        height=args.height,
+                        width=args.width,
+                        num_frames=args.num_frames,
+                        num_inference_steps=args.num_inference_steps,
+                        guidance_scale=args.guidance_scale,
+                        generator=torch.Generator(device="cuda").manual_seed(args.seed),
+                        # stage 1
+                        history_sizes=[16, 2, 1],
+                        num_latent_frames_per_chunk=args.num_latent_frames_per_chunk,
+                        keep_first_frame=True,
+                        # stage 2
+                        is_enable_stage2=args.is_enable_stage2,
+                        pyramid_num_inference_steps_list=args.pyramid_num_inference_steps_list,
+                        # stage 3
+                        is_skip_first_chunk=args.is_skip_first_chunk,
+                        is_amplify_first_chunk=args.is_amplify_first_chunk,
+                        # cfg zero
+                        use_zero_init=args.use_zero_init,
+                        zero_steps=args.zero_steps,
+                        # i2v
+                        image=load_image(image_path).resize((args.width, args.height))
+                        if image_path is not None
+                        else None,
+                        image_noise_sigma_min=args.image_noise_sigma_min,
+                        image_noise_sigma_max=args.image_noise_sigma_max,
+                        # v2v
+                        video=load_video(video_path) if video_path is not None else None,
+                        video_noise_sigma_min=args.video_noise_sigma_min,
+                        video_noise_sigma_max=args.video_noise_sigma_max,
+                        # interpolate_prompt
+                        use_interpolate_prompt=args.use_interpolate_prompt,
+                        interpolation_steps=args.interpolation_steps,
+                        interpolate_time_list=interpolate_time_list,
+                        output_relative_l1=args.visualize_relative_l1,
+                    )
+                    output = pipe_output.frames[0]
+                except Exception:
+                    continue
+            if not args.enable_parallelism or rank == 0:
+                sample_dir = build_sample_output_dir(args.output_folder, prompt)
+                output_path = sample_dir / "video.mp4"
+                export_to_video(output, str(output_path), fps=24)
+                if args.visualize_relative_l1:
+                    save_relative_l1_outputs(pipe_output.relative_l1, sample_dir)
+    elif args.image_prompt_csv_path is not None:
+        df = pd.read_csv(args.image_prompt_csv_path)
+        if not args.enable_parallelism:
+            df = df.iloc[rank::world_size]
+
+        for idx, row in tqdm(df.iterrows(), total=len(df), desc="Processing prompts"):
+            prompt = row.get("refined_prompt") or row["prompt"]
+            image_path = os.path.join(args.base_image_prompt_path, row["image_name"])
+
+            with torch.no_grad():
+                try:
+                    pipe_output = pipe(
+                        prompt=prompt,
+                        negative_prompt=args.negative_prompt,
+                        height=args.height,
+                        width=args.width,
+                        num_frames=args.num_frames,
+                        num_inference_steps=args.num_inference_steps,
+                        guidance_scale=args.guidance_scale,
+                        generator=torch.Generator(device="cuda").manual_seed(args.seed),
+                        # stage 1
+                        history_sizes=[16, 2, 1],
+                        num_latent_frames_per_chunk=args.num_latent_frames_per_chunk,
+                        keep_first_frame=True,
+                        # stage 2
+                        is_enable_stage2=args.is_enable_stage2,
+                        pyramid_num_inference_steps_list=args.pyramid_num_inference_steps_list,
+                        # stage 3
+                        is_skip_first_chunk=args.is_skip_first_chunk,
+                        is_amplify_first_chunk=args.is_amplify_first_chunk,
+                        # cfg zero
+                        use_zero_init=args.use_zero_init,
+                        zero_steps=args.zero_steps,
+                        # i2v
+                        image=load_image(image_path).resize((args.width, args.height))
+                        if image_path is not None
+                        else None,
+                        image_noise_sigma_min=args.image_noise_sigma_min,
+                        image_noise_sigma_max=args.image_noise_sigma_max,
+                        # v2v
+                        video=load_video(video_path) if video_path is not None else None,
+                        video_noise_sigma_min=args.video_noise_sigma_min,
+                        video_noise_sigma_max=args.video_noise_sigma_max,
+                        # interpolate_prompt
+                        use_interpolate_prompt=args.use_interpolate_prompt,
+                        interpolation_steps=args.interpolation_steps,
+                        interpolate_time_list=interpolate_time_list,
+                        output_relative_l1=args.visualize_relative_l1,
+                    )
+                    output = pipe_output.frames[0]
+                except Exception:
+                    continue
+            if not args.enable_parallelism or rank == 0:
+                sample_dir = build_sample_output_dir(args.output_folder, prompt)
+                output_path = sample_dir / "video.mp4"
+                export_to_video(output, str(output_path), fps=24)
+                if args.visualize_relative_l1:
+                    save_relative_l1_outputs(pipe_output.relative_l1, sample_dir)
+    elif args.interactive_prompt_csv_path is not None:
+        df = pd.read_csv(args.interactive_prompt_csv_path)
+
+        df = df.sort_values(by=["id", "prompt_index"])
+        all_video_ids = df["id"].unique()
+
+        if not args.enable_parallelism:
+            my_video_ids = all_video_ids[rank::world_size]
+        else:
+            my_video_ids = all_video_ids
+
+        for video_id in tqdm(my_video_ids, desc="Processing prompts"):
+            group_df = df[df["id"] == video_id]
+
+            if "refined_prompt" in df.columns:
+                prompt_list = group_df["refined_prompt"].fillna(group_df["prompt"]).tolist()
+            else:
+                prompt_list = group_df["prompt"].tolist()
+            interpolate_time_list = [args.interpolate_time] * len(prompt_list)
+
+            with torch.no_grad():
+                try:
+                    pipe_output = pipe(
+                        prompt=prompt_list,
+                        negative_prompt=args.negative_prompt,
+                        height=args.height,
+                        width=args.width,
+                        num_frames=args.num_frames,
+                        num_inference_steps=args.num_inference_steps,
+                        guidance_scale=args.guidance_scale,
+                        generator=torch.Generator(device="cuda").manual_seed(args.seed),
+                        # stage 1
+                        history_sizes=[16, 2, 1],
+                        num_latent_frames_per_chunk=args.num_latent_frames_per_chunk,
+                        keep_first_frame=True,
+                        # stage 2
+                        is_enable_stage2=args.is_enable_stage2,
+                        pyramid_num_inference_steps_list=args.pyramid_num_inference_steps_list,
+                        # stage 3
+                        is_skip_first_chunk=args.is_skip_first_chunk,
+                        is_amplify_first_chunk=args.is_amplify_first_chunk,
+                        # cfg zero
+                        use_zero_init=args.use_zero_init,
+                        zero_steps=args.zero_steps,
+                        # i2v
+                        image=load_image(image_path).resize((args.width, args.height))
+                        if image_path is not None
+                        else None,
+                        image_noise_sigma_min=args.image_noise_sigma_min,
+                        image_noise_sigma_max=args.image_noise_sigma_max,
+                        # v2v
+                        video=load_video(video_path) if video_path is not None else None,
+                        video_noise_sigma_min=args.video_noise_sigma_min,
+                        video_noise_sigma_max=args.video_noise_sigma_max,
+                        # interpolate_prompt
+                        use_interpolate_prompt=args.use_interpolate_prompt,
+                        interpolation_steps=args.interpolation_steps,
+                        interpolate_time_list=interpolate_time_list,
+                        output_relative_l1=args.visualize_relative_l1,
+                    )
+                    output = pipe_output.frames[0]
+                except Exception:
+                    continue
+            if not args.enable_parallelism or rank == 0:
+                sample_dir = build_sample_output_dir(args.output_folder, prompt_list)
+                output_path = sample_dir / "video.mp4"
+                export_to_video(output, str(output_path), fps=24)
+                if args.visualize_relative_l1:
+                    save_relative_l1_outputs(pipe_output.relative_l1, sample_dir)
+    else:
+        with torch.no_grad():
+            # import time
+            # for _ in range(20):
+            #     start_time = time.time()
+            pipe_output = pipe(
+                prompt=prompt,
+                negative_prompt=args.negative_prompt,
+                height=args.height,
+                width=args.width,
+                num_frames=args.num_frames,
+                num_inference_steps=args.num_inference_steps,
+                guidance_scale=args.guidance_scale,
+                generator=torch.Generator(device="cuda").manual_seed(args.seed),
+                # stage 1
+                history_sizes=[16, 2, 1],
+                num_latent_frames_per_chunk=args.num_latent_frames_per_chunk,
+                keep_first_frame=True,
+                # stage 2
+                is_enable_stage2=args.is_enable_stage2,
+                pyramid_num_inference_steps_list=args.pyramid_num_inference_steps_list,
+                # stage 3
+                is_skip_first_chunk=args.is_skip_first_chunk,
+                is_amplify_first_chunk=args.is_amplify_first_chunk,
+                # cfg zero
+                use_zero_init=args.use_zero_init,
+                zero_steps=args.zero_steps,
+                # i2v
+                image=load_image(image_path).resize((args.width, args.height)) if image_path is not None else None,
+                image_noise_sigma_min=args.image_noise_sigma_min,
+                image_noise_sigma_max=args.image_noise_sigma_max,
+                # v2v
+                video=load_video(video_path) if video_path is not None else None,
+                video_noise_sigma_min=args.video_noise_sigma_min,
+                video_noise_sigma_max=args.video_noise_sigma_max,
+                # interpolate_prompt
+                use_interpolate_prompt=args.use_interpolate_prompt,
+                interpolation_steps=args.interpolation_steps,
+                interpolate_time_list=interpolate_time_list,
+                output_relative_l1=args.visualize_relative_l1,
+            )
+            output = pipe_output.frames[0]
+            # elapsed_time = time.time() - start_time
+            # print(f"Inference time: {elapsed_time:.2f} seconds ({elapsed_time/60:.2f} minutes)")
+
+        if not args.enable_parallelism or rank == 0:
+            sample_dir = build_sample_output_dir(args.output_folder, prompt)
+            output_path = sample_dir / "video.mp4"
+            export_to_video(output, str(output_path), fps=24)
+            if args.visualize_relative_l1:
+                save_relative_l1_outputs(pipe_output.relative_l1, sample_dir)
+
+    print(f"Max memory: {torch.cuda.max_memory_allocated() / 1024**3:.3f} GB")
+
+
+if __name__ == "__main__":
+    main()

Helios/_DEV2/install.sh

@@ -0,0 +1,10 @@
+pip install -r requirements.txt
+
+rm -rf ~/.triton/cache/
+rm -rf /tmp/torchinductor_*
+
+pip uninstall triton torchao xformers wandb tensorflow tensorflow-cpu -y
+pip install wandb==0.23.0 triton==3.6.0
+
+rm -rf ~/.triton/cache/
+rm -rf /tmp/torchinductor_*

Helios/_DEV2/requirements.txt

@@ -0,0 +1,35 @@
+torch==2.10.0
+torchvision==0.25.0
+torchaudio==2.10.0
+triton==3.6.0
+kernels==0.13.0
+# diffusers==0.36.0
+# transformers==4.57.6
+git+https://github.com/huggingface/diffusers.git
+transformers==5.3.0
+sentence-transformers==5.2.3
+accelerate==1.12.0
+deepspeed==0.18.4
+peft==0.18.1
+huggingface-hub==1.4.1
+zstandard==0.25.0
+wandb==0.23.0
+video-reader-rs==0.4.1
+numpy<2.0.0
+opencv-python
+gradio
+spaces
+moviepy
+imageio-ffmpeg
+ftfy
+Jinja2
+einops
+nvitop
+packaging
+ninja
+omegaconf
+mpi4py
+hf-doc-builder
+torchdata
+loguru
+tf_keras

Helios/_DEV2/requirements_npu.txt

@@ -0,0 +1,6 @@
+# Please refer to here for installation the latest version: https://github.com/Ascend/pytorch?tab=readme-ov-file#ascend-auxiliary-software
+torch==2.9.0
+torchvision==0.24.0
+torchaudio==2.9.0
+torch_npu==2.9.0
+triton==3.5.1

Helios/_DEV2/run_bench.sh

@@ -0,0 +1,275 @@
+#!/bin/bash
+# =============================================================================
+#  Helios Benchmark Inference Runner
+#  用法: bash run_bench.sh [--gpus 5 6 7] [--prompt_range 0-50] [--num_frames 240]
+#                         [--version base] [--version mid distilled]
+#  默认使用所有可见 GPU；默认跑全部版本（base/mid/distilled），也可手动指定版本
+#  同一时刻只跑一个版本；若有多张卡，会先扫描输出目录，只把缺失 case 均分到多张卡并行
+#  低显存: LOW_VRAM=1 bash run_bench.sh
+# =============================================================================
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+if [[ -n "${PYTHON:-}" ]]; then
+    PYTHON_BIN="${PYTHON}"
+elif command -v python3 >/dev/null 2>&1; then
+    PYTHON_BIN="$(command -v python3)"
+elif command -v python >/dev/null 2>&1; then
+    PYTHON_BIN="$(command -v python)"
+else
+    echo "Python interpreter not found. Set PYTHON=/path/to/python." >&2
+    exit 1
+fi
+
+GPUS=()
+PROMPT_START="${PROMPT_START:-0}"
+PROMPT_END="${PROMPT_END:-100}"
+NUM_FRAMES="${NUM_FRAMES:-}"
+VERSIONS=(base mid distilled)
+OUTPUT_ROOT="${OUTPUT_ROOT:-}"
+PROMPT_FILE="${PROMPT_FILE:-${SCRIPT_DIR}/demo_data/MovieGenVideoBench_extended.txt}"
+LOW_VRAM="${LOW_VRAM:-0}"
+
+discover_gpus() {
+    if ! command -v nvidia-smi >/dev/null 2>&1; then
+        echo "nvidia-smi not found; use --gpus to specify GPU ids explicitly." >&2
+        exit 1
+    fi
+
+    mapfile -t GPUS < <(nvidia-smi --query-gpu=index --format=csv,noheader,nounits)
+    if [[ ${#GPUS[@]} -eq 0 ]]; then
+        echo "No GPUs found." >&2
+        exit 1
+    fi
+}
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --gpus)        shift; GPUS=(); while [[ $# -gt 0 && ! "$1" =~ ^-- ]]; do GPUS+=("$1"); shift; done ;;
+        --prompt_range)
+            if [[ ! "$2" =~ ^([0-9]+)-([0-9]+)$ ]]; then
+                echo "Invalid --prompt_range: $2 (expected START-END, e.g. 0-50)" >&2
+                exit 1
+            fi
+            PROMPT_START="${BASH_REMATCH[1]}"
+            PROMPT_END="${BASH_REMATCH[2]}"
+            shift 2
+            ;;
+        --prompt_start) PROMPT_START="$2"; shift 2 ;;
+        --prompt_end)   PROMPT_END="$2"; shift 2 ;;
+        --num_frames)  NUM_FRAMES="$2";  shift 2 ;;
+        --version)     shift; VERSIONS=(); while [[ $# -gt 0 && ! "$1" =~ ^-- ]]; do VERSIONS+=("$1"); shift; done ;;
+        --output_root) OUTPUT_ROOT="$2"; shift 2 ;;
+        --prompt_file) PROMPT_FILE="$2"; shift 2 ;;
+        *) echo "Unknown option: $1"; exit 1 ;;
+    esac
+done
+
+if [[ ${#GPUS[@]} -eq 0 ]]; then
+    discover_gpus
+fi
+
+if [[ ${#VERSIONS[@]} -eq 0 ]]; then
+    echo "No versions specified. Use --version base [mid distilled]." >&2
+    exit 1
+fi
+
+if [[ ! "${PROMPT_START}" =~ ^[0-9]+$ ]] || [[ ! "${PROMPT_END}" =~ ^[0-9]+$ ]]; then
+    echo "prompt_start and prompt_end must be non-negative integers." >&2
+    exit 1
+fi
+
+if (( PROMPT_END <= PROMPT_START )); then
+    echo "prompt_end must be greater than prompt_start." >&2
+    exit 1
+fi
+
+if [[ -z "${OUTPUT_ROOT}" ]]; then
+    if [[ -n "${NUM_FRAMES}" ]]; then
+        OUTPUT_ROOT="${SCRIPT_DIR}/outputs/num_frames_${NUM_FRAMES}"
+    else
+        OUTPUT_ROOT="${SCRIPT_DIR}/outputs/num_frames_default"
+    fi
+fi
+
+echo "============================================================"
+echo "  Helios Benchmark Inference"
+echo "  $(date '+%Y-%m-%d %H:%M:%S')"
+echo "  Python: ${PYTHON_BIN}"
+echo "  GPUs: ${GPUS[*]}  |  Prompt range: ${PROMPT_START}-${PROMPT_END}  |  Versions: ${VERSIONS[*]}"
+[[ -n "${NUM_FRAMES}" ]] && echo "  Frames: ${NUM_FRAMES}"
+echo "  Prompt file: ${PROMPT_FILE}"
+echo "  Output: ${OUTPUT_ROOT}"
+echo "============================================================"
+
+mkdir -p "${OUTPUT_ROOT}"
+
+if [[ ! -f "${PROMPT_FILE}" ]]; then
+    echo "Prompt file not found: ${PROMPT_FILE}" >&2
+    exit 1
+fi
+
+TOTAL_PROMPTS=$(awk 'NF {count++} END {print count + 0}' "${PROMPT_FILE}")
+if (( PROMPT_START >= TOTAL_PROMPTS )); then
+    echo "prompt_start (${PROMPT_START}) is out of range; prompt file has ${TOTAL_PROMPTS} non-empty prompts." >&2
+    exit 1
+fi
+
+if (( PROMPT_END > TOTAL_PROMPTS )); then
+    echo "prompt_end (${PROMPT_END}) exceeds total prompts (${TOTAL_PROMPTS}); clamping to ${TOTAL_PROMPTS}."
+    PROMPT_END="${TOTAL_PROMPTS}"
+fi
+
+EXTRA=()
+if [[ "${LOW_VRAM}" == "1" ]]; then
+    EXTRA+=(--enable_low_vram_mode)
+fi
+if [[ -n "${NUM_FRAMES}" ]]; then
+    EXTRA+=(--num_frames "${NUM_FRAMES}")
+fi
+
+EXIT_CODE=0
+WORKER_PIDS=()
+WORKER_GPUS=()
+WORKER_SHARDS=()
+
+prepare_missing_shards() {
+    local version="$1"
+    local shard_dir="${OUTPUT_ROOT}/shards/${version}_${PROMPT_START}_${PROMPT_END}_$$"
+    mkdir -p "${shard_dir}"
+
+    "${PYTHON_BIN}" - \
+        "${PROMPT_FILE}" \
+        "${OUTPUT_ROOT}" \
+        "${version}" \
+        "${PROMPT_START}" \
+        "${PROMPT_END}" \
+        "${#GPUS[@]}" \
+        "${shard_dir}" <<'PY'
+import os
+import re
+import sys
+from pathlib import Path
+
+prompt_file = Path(sys.argv[1])
+output_root = Path(sys.argv[2])
+version = sys.argv[3]
+prompt_start = int(sys.argv[4])
+prompt_end = int(sys.argv[5])
+gpu_count = int(sys.argv[6])
+shard_dir = Path(sys.argv[7])
+
+with prompt_file.open("r", encoding="utf-8") as f:
+    prompts = [line.strip() for line in f if line.strip()]
+
+def sanitize_filename(text, max_len=80):
+    text = text.strip().lower()
+    text = re.sub(r"[^a-z0-9]+", "_", text)
+    text = text.strip("_")
+    return text[:max_len]
+
+missing = []
+existing = 0
+version_dir = output_root / "by_version" / version
+for idx in range(prompt_start, prompt_end):
+    slug = sanitize_filename(prompts[idx])
+    video_path = version_dir / f"{idx:04d}_{slug}.mp4"
+    if video_path.is_file() and video_path.stat().st_size > 0:
+        existing += 1
+    else:
+        missing.append(idx)
+
+print(
+    f"[scan] version={version} range={prompt_start}-{prompt_end} "
+    f"existing={existing} missing={len(missing)} output={version_dir}",
+    file=sys.stderr,
+)
+
+if not missing:
+    sys.exit(0)
+
+active_workers = min(gpu_count, len(missing))
+base_chunk = len(missing) // active_workers
+remainder = len(missing) % active_workers
+offset = 0
+
+for shard_idx in range(active_workers):
+    shard_size = base_chunk + (1 if shard_idx < remainder else 0)
+    shard_indices = missing[offset:offset + shard_size]
+    offset += shard_size
+    shard_path = shard_dir / f"shard_{shard_idx:02d}.txt"
+    shard_path.write_text(
+        "".join(f"{idx}\n" for idx in shard_indices),
+        encoding="utf-8",
+    )
+    print(shard_path)
+    print(
+        f"[shard] version={version} shard={shard_idx} count={len(shard_indices)} "
+        f"indices={shard_indices[0]}-{shard_indices[-1]} file={shard_path}",
+        file=sys.stderr,
+    )
+PY
+}
+
+launch_job() {
+    local version="$1"
+    local gpu="$2"
+    local shard_file="$3"
+    local shard_id
+    shard_id="$(basename "${shard_file}" .txt)"
+    local timing_file="${OUTPUT_ROOT}/timing_${version}_${shard_id}.txt"
+
+    echo "[launch] version=${version} gpu=${gpu} shard=${shard_id} indices=${shard_file} output=${OUTPUT_ROOT}"
+    "${PYTHON_BIN}" "${SCRIPT_DIR}/bench_infer.py" \
+        --prompt_file  "${PROMPT_FILE}" \
+        --prompt_start "${PROMPT_START}" \
+        --prompt_end   "${PROMPT_END}" \
+        --prompt_indices_file "${shard_file}" \
+        --output_root  "${OUTPUT_ROOT}" \
+        --timing_file  "${timing_file}" \
+        --version      "${version}" \
+        --gpu          "${gpu}" \
+        "${EXTRA[@]}" &
+
+    WORKER_PIDS+=("$!")
+    WORKER_GPUS+=("${gpu}")
+    WORKER_SHARDS+=("${shard_id}")
+}
+
+wait_for_current_version() {
+    local version="$1"
+    for idx in "${!WORKER_PIDS[@]}"; do
+        local pid="${WORKER_PIDS[$idx]}"
+        local gpu="${WORKER_GPUS[$idx]}"
+        local shard_id="${WORKER_SHARDS[$idx]}"
+        if wait "${pid}"; then
+            echo "[done] ${version} finished on gpu=${gpu} shard=${shard_id}"
+        else
+            echo "[fail] ${version} failed on gpu=${gpu} shard=${shard_id}"
+            EXIT_CODE=1
+        fi
+    done
+    WORKER_PIDS=()
+    WORKER_GPUS=()
+    WORKER_SHARDS=()
+}
+
+for version in "${VERSIONS[@]}"; do
+    echo ""
+    echo "-------------------- version=${version} --------------------"
+    mapfile -t SHARD_FILES < <(prepare_missing_shards "${version}")
+    if (( ${#SHARD_FILES[@]} == 0 )); then
+        echo "[skip] version=${version} has no missing cases in ${PROMPT_START}-${PROMPT_END}"
+        continue
+    fi
+
+    for worker_idx in "${!SHARD_FILES[@]}"; do
+        launch_job "${version}" "${GPUS[$worker_idx]}" "${SHARD_FILES[$worker_idx]}"
+    done
+    wait_for_current_version "${version}"
+done
+
+echo ""
+echo "Done. Per-shard timing reports are under ${OUTPUT_ROOT}/timing_<version>_shard_<id>.txt"
+
+exit ${EXIT_CODE:-0}

Helios/_DEV3/.gitignore

@@ -0,0 +1,43 @@
+*.py[cod]
+*.gif
+*.bmp
+*.mov
+*.mkv
+*.log
+*.zip
+*.pt
+*.pth
+*.ckpt
+*.safetensors
+*.backup
+*.pt
+*.pth
+*.ckpt
+*.pkl
+*.html
+*.pdf
+*.whl
+*.txt.gz
+!.gitignore
+!requirements.txt
+.DS_Store
+*DS_Store
+poetry.lock
+__pycache__/
+*.cache*
+*temp_path*
+*_ckpt
+*_results
+*temp
+*.pem
+*profile
+.gradio
+ablation_*
+cache
+wandb
+output_helios
+AMT-S.yaml
+bpe_simple_vocab_16e6.txt
+Videoreward
+1_formal_ckpts
+demo_data

Helios/_DEV3/LICENSE.txt

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

Helios/_DEV3/README.md

@@ -0,0 +1,67 @@
+# _DEV3 Token Dynamics Debug
+
+分析 **short history 最近一帧** 与 **current chunk 第一帧（noise frame）** 之间 token 的匹配关系，以及去噪过程中 token 变化率的对比。
+
+## 实现逻辑
+
+1. **最后一步开始时匹配**（基于 patch 后的 latent token）  
+   在 denoise 最后一步的 forward 开始时，取：
+   - short history 最近一帧（默认 `history_frame=-1` → 第 2 帧）
+   - current chunk 第一帧（默认 `noise_frame=0`）  
+   对 noise 帧每个 token，在历史帧中找 **cos 相似度最高** 的 token 作为匹配。
+
+2. **去噪过程变化率**（基于 patch 后 latent token）  
+   只记录调试需要的两帧（默认 `CHUNKS=1`：`history_frame=-1` + `noise_frame=0`）：
+   - chunk 0 **最后一帧**（将作为 history）
+   - chunk 1 **第 0 帧**（将作为 noise）  
+   各自去噪时逐步记录：
+   ```text
+   change_rate(token) = (||token_t|| - ||token_{t-1}||) / ||token_t||
+   ```
+   在 chunk 1 最后一步做 cos 匹配后，按匹配 token 对比两条曲线。
+
+3. **可视化**  
+   - 变化率曲线：每一对匹配 token 一张图，两根曲线（history / noise 逐步变化率）
+   - 匹配帧空间图：chunk 去噪**完成后**，用 fully-denoised latent 经 VAE decode，左 history、右 noise，框出 cos 匹配 token 对
+
+## 运行
+
+```bash
+cd _DEV3
+CUDA_VISIBLE_DEVICES=0 bash scripts/inference/run_token_dynamics_debug.sh
+```
+
+常用环境变量：
+
+| 变量 | 默认 | 说明 |
+|------|------|------|
+| `CHUNKS` | `1` | 分析哪个 chunk（需 `NUM_FRAMES>=66` 才有 chunk 1） |
+| `HISTORY_FRAME` | `-1` | short history 帧索引（-1=最后一帧） |
+| `NOISE_FRAME` | `0` | current chunk 帧索引（0=第一帧） |
+| `VIS_STRIDE` | `16` | 每 N 个 token 画一对图 |
+| `VIS_MAX_PAIRS` | `32` | 最多画多少对 |
+
+## 输出
+
+- `output_helios/token_dynamics_debug/token_dynamics_debug_video.mp4`
+- `output_helios/token_dynamics_debug/artifacts/token_dynamics_chunk*.pt`
+- `output_helios/token_dynamics_debug/artifacts/*_pair_*.png` — 每对 token 双曲线图
+- `output_helios/token_dynamics_debug/artifacts/*_mean_summary.png` — 全体均值对比
+- `output_helios/token_dynamics_debug/artifacts/*_match_frames/noise*.png` — 每个 noise token 一张图：左 history 前一帧，右 noise0，分别框出匹配 token
+
+单独跑匹配帧可视化（默认保存全部 960 个 noise token）：
+
+```bash
+python tools/visualize_token_match_frames.py \
+  output_helios/token_dynamics_debug/artifacts/token_dynamics_chunk1_hist-1_noise0_cond.pt \
+  --model-path ./checkpoints/Helios-Base \
+  --tokens "4:0,10:16"   # 可选：只画指定 token
+```
+
+## 代码位置
+
+- `helios/utils/token_dynamics_debug.py` — 匹配与变化率核心逻辑
+- `helios/diffusers_version/transformer_helios_diffusers.py` — forward hook
+- `helios/diffusers_version/pipeline_helios_diffusers.py` — pipeline 参数 `token_dynamics_debug`
+- `tools/visualize_token_dynamics.py` — 变化率曲线可视化
+- `tools/visualize_token_match_frames.py` — 匹配帧空间可视化（VAE decode + 框选 token）

Helios/_DEV3/app.py

@@ -0,0 +1,322 @@
+import tempfile
+import time
+from pathlib import Path
+
+import gradio as gr
+import spaces
+import torch
+
+from torch.utils._pytree import tree_map
+from diffusers import AutoencoderKLWan, HeliosDMDScheduler, HeliosPyramidPipeline
+from diffusers.utils import export_to_video, load_image, load_video
+
+
+# ---------------------------------------------------------------------------
+# Pre-load model
+# ---------------------------------------------------------------------------
+PROJECT_ROOT = Path(__file__).resolve().parent
+MODEL_ID = str(PROJECT_ROOT / "checkpoints" / "Helios-Distilled")
+
+vae = AutoencoderKLWan.from_pretrained(MODEL_ID, subfolder="vae", torch_dtype=torch.float32)
+scheduler = HeliosDMDScheduler.from_pretrained(MODEL_ID, subfolder="scheduler")
+pipe = HeliosPyramidPipeline.from_pretrained(
+    MODEL_ID, vae=vae, scheduler=scheduler, torch_dtype=torch.bfloat16, is_distilled=True
+)
+pipe.to("cuda")
+
+cuda_major = torch.cuda.get_device_capability()[0]
+if cuda_major >= 9:
+    # H100/H800 (SM90+) with FA3
+    try:
+        pipe.transformer.set_attention_backend("_flash_3_hub")
+    except Exception:
+        pipe.transformer.set_attention_backend("flash_hub")
+else:
+    # 4090/A100 etc (SM89+) with FA2
+    pipe.transformer.set_attention_backend("flash_hub")
+
+# ---------------------------------------------------------------------------
+# AoTI
+# ---------------------------------------------------------------------------
+
+# Dynamic shapes: within a generation, only hidden_states H/W change across
+# pyramid stages (history latents stay at full resolution). text_seq_length
+# varies between different prompts.
+_AUTO = torch.export.Dim.AUTO
+
+TRANSFORMER_DYNAMIC_SHAPES = {
+    "hidden_states": {
+        3: _AUTO,  # H — doubles each pyramid stage
+        4: _AUTO,  # W — doubles each pyramid stage
+    },
+    "encoder_hidden_states": {
+        1: _AUTO,  # text_seq_length — varies with prompt
+    },
+}
+
+INDUCTOR_CONFIGS = {
+    "conv_1x1_as_mm": True,
+    "epilogue_fusion": False,
+    "coordinate_descent_tuning": True,
+    "coordinate_descent_check_all_directions": True,
+    # "max_autotune": True,
+    "triton.cudagraphs": True,
+}
+
+@spaces.GPU(duration=1500) # maximum duration allowed during startup
+def compile_transformer():
+    with spaces.aoti_capture(pipe.transformer) as call:
+        pipe(
+            "arbitrary example prompt",
+            height=384,
+            width=640,
+            num_frames=33,
+            guidance_scale=1.0,
+            generator=torch.Generator(device="cuda").manual_seed(42),
+            pyramid_num_inference_steps_list=[2, 2, 2],
+            is_amplify_first_chunk=True,
+        )
+
+    dynamic_shapes = tree_map(lambda t: None, call.kwargs)
+    dynamic_shapes |= TRANSFORMER_DYNAMIC_SHAPES
+
+    with torch.no_grad():
+        exported = torch.export.export(
+            pipe.transformer,
+            args=call.args,
+            kwargs=call.kwargs,
+            dynamic_shapes=dynamic_shapes,
+        )
+
+    return spaces.aoti_compile(exported, INDUCTOR_CONFIGS)
+
+compiled_transformer = compile_transformer()
+spaces.aoti_apply(compiled_transformer, pipe.transformer)
+
+
+# ---------------------------------------------------------------------------
+# Generation
+# ---------------------------------------------------------------------------
+@spaces.GPU(duration=60)
+def generate_video(
+    mode: str,
+    prompt: str,
+    image_input,
+    video_input,
+    height: int,
+    width: int,
+    num_frames: int,
+    num_inference_steps: int,
+    seed: int,
+    is_amplify_first_chunk: bool,
+    progress=gr.Progress(track_tqdm=True),
+):
+    if not prompt:
+        raise gr.Error("Please provide a prompt.")
+
+    generator = torch.Generator(device="cuda").manual_seed(int(seed))
+
+    kwargs = {
+        "prompt": prompt,
+        "height": int(height),
+        "width": int(width),
+        "num_frames": int(num_frames),
+        "guidance_scale": 1.0,
+        "generator": generator,
+        "output_type": "np",
+        "pyramid_num_inference_steps_list": [
+            int(num_inference_steps),
+            int(num_inference_steps),
+            int(num_inference_steps),
+        ],
+        "is_amplify_first_chunk": is_amplify_first_chunk,
+    }
+
+    if mode == "Image-to-Video" and image_input is not None:
+        img = load_image(image_input).resize((int(width), int(height)))
+        kwargs["image"] = img
+    elif mode == "Video-to-Video" and video_input is not None:
+        kwargs["video"] = load_video(video_input)
+
+    t0 = time.time()
+    output = pipe(**kwargs).frames[0]
+    elapsed = time.time() - t0
+
+    tmp = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
+    export_to_video(output, tmp.name, fps=24)
+    info = f"Generated in {elapsed:.1f}s · {num_frames} frames · {height}×{width}"
+    return tmp.name, info
+
+
+# ---------------------------------------------------------------------------
+# UI Setup
+# ---------------------------------------------------------------------------
+def update_conditional_visibility(mode):
+    if mode == "Image-to-Video":
+        return gr.update(visible=True), gr.update(visible=False)
+    elif mode == "Video-to-Video":
+        return gr.update(visible=False), gr.update(visible=True)
+    else:
+        return gr.update(visible=False), gr.update(visible=False)
+
+
+CSS = """
+#header { text-align: center; margin-bottom: 1.5em; }
+#header h1 { font-size: 2.2em; margin-bottom: 0.2em; }
+.logo { max-height: 100px; margin: 0 auto 10px auto; display: block; }
+.link-buttons { display: flex; justify-content: center; gap: 15px; margin-top: 10px; }
+.link-buttons a {
+    background-color: #2b3137;
+    color: #ffffff !important;
+    padding: 8px 20px;
+    border-radius: 6px;
+    text-decoration: none;
+    font-weight: 600;
+    font-size: 1em;
+    transition: all 0.2s ease-in-out;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+}
+.link-buttons a:hover { background-color: #4a535c; transform: translateY(-1px); }
+.contain { max-width: 1350px; margin: 0 auto !important; }
+"""
+
+with gr.Blocks(title="Helios Video Generation") as demo:
+    gr.HTML(
+        """
+        <div style='display: flex; align-items: center; justify-content: center; width: 100%;'>
+            <img src="https://raw.githubusercontent.com/SHYuanBest/shyuanbest_media/main/Helios/logo_white.png" style='width: 400px; height: auto;' />
+        </div>
+        <div id="header">
+            <h1>🎬 Helios 14B Distilled: Real Real-Time Long Video Generation Model</h1>
+            <p style="font-size: 1.1em; color: #666; margin-top: 0.5em; margin-bottom: 1em;">
+                If you like our project, please give us a star ⭐ on GitHub for the latest update.
+            </p>
+            <div class="link-buttons">
+                <a href="https://github.com/PKU-YuanGroup/Helios" target="_blank">💻 Code</a>
+                <a href="https://pku-yuangroup.github.io/Helios-Page" target="_blank">📄 Page</a>
+                <a href="https://www.youtube.com/watch?v=vd_AgHtOUFQ" target="_blank">🎥 Main Feature</a>
+                <a href="https://www.youtube.com/watch?v=1GeIU2Dn7UY" target="_blank">⚡ Inference Speed</a>
+            </div>
+        </div>
+        """
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            mode = gr.Radio(
+                choices=["Text-to-Video", "Image-to-Video", "Video-to-Video"],
+                value="Text-to-Video",
+                label="Generation Mode",
+            )
+            image_input = gr.Image(label="Image (for I2V)", type="filepath", visible=False)
+            video_input = gr.Video(label="Video (for V2V)", visible=False)
+            prompt = gr.Textbox(
+                label="Prompt",
+                lines=4,
+                value=(
+                    "A vibrant tropical fish swimming gracefully among colorful coral reefs in "
+                    "a clear, turquoise ocean. The fish has bright blue and yellow scales with a "
+                    "small, distinctive orange spot on its side, its fins moving fluidly. The coral "
+                    "reefs are alive with a variety of marine life, including small schools of "
+                    "colorful fish and sea turtles gliding by. The water is crystal clear, allowing "
+                    "for a view of the sandy ocean floor below. The reef itself is adorned with a mix "
+                    "of hard and soft corals in shades of red, orange, and green. The photo captures "
+                    "the fish from a slightly elevated angle, emphasizing its lively movements and the "
+                    "vivid colors of its surroundings. A close-up shot with dynamic movement."
+                ),
+            )
+            with gr.Accordion("Advanced Settings", open=False):
+                with gr.Row():
+                    height = gr.Number(value=384, label="Height", precision=0, interactive=False)
+                    width = gr.Number(value=640, label="Width", precision=0, interactive=False)
+                with gr.Row():
+                    num_frames = gr.Slider(33, 231, value=231, step=33, label="Num Frames")
+                    num_inference_steps = gr.Slider(1, 10, value=2, step=1, label="Steps per stage")
+                with gr.Row():
+                    seed = gr.Number(value=42, label="Seed", precision=0)
+                    is_amplify_first_chunk = gr.Checkbox(label="Amplify First Chunk", value=True)
+
+            generate_btn = gr.Button("🚀 Generate Video", variant="primary", size="lg")
+
+        with gr.Column(scale=1):
+            video_output = gr.Video(label="Generated Video", autoplay=True)
+            info_output = gr.Textbox(label="Info", interactive=False)
+
+    mode.change(fn=update_conditional_visibility, inputs=[mode], outputs=[image_input, video_input])
+    generate_btn.click(
+        fn=generate_video,
+        inputs=[
+            mode,
+            prompt,
+            image_input,
+            video_input,
+            height,
+            width,
+            num_frames,
+            num_inference_steps,
+            seed,
+            is_amplify_first_chunk,
+        ],
+        outputs=[video_output, info_output],
+    )
+
+    gr.Examples(
+        examples=[
+            [
+                "Text-to-Video",
+                "A vibrant tropical fish swimming gracefully among colorful coral reefs in "
+                "a clear, turquoise ocean. The fish has bright blue and yellow scales with a "
+                "small, distinctive orange spot on its side, its fins moving fluidly. The coral "
+                "reefs are alive with a variety of marine life, including small schools of "
+                "colorful fish and sea turtles gliding by. The water is crystal clear, allowing "
+                "for a view of the sandy ocean floor below. The reef itself is adorned with a mix "
+                "of hard and soft corals in shades of red, orange, and green. The photo captures "
+                "the fish from a slightly elevated angle, emphasizing its lively movements and the "
+                "vivid colors of its surroundings. A close-up shot with dynamic movement.",
+                None,
+                None,
+            ],
+            [
+                "Text-to-Video",
+                "An extreme close-up of an gray-haired man with a beard in his 60s, he is deep in "
+                "thought pondering the history of the universe as he sits at a cafe in Paris, his eyes "
+                "focus on people offscreen as they walk as he sits mostly motionless, he is dressed in "
+                "a wool coat suit coat with a button-down shirt , he wears a brown beret and glasses "
+                "and has a very professorial appearance, and the end he offers a subtle closed-mouth "
+                "smile as if he found the answer to the mystery of life, the lighting is very cinematic "
+                "with the golden light and the Parisian streets and city in the background, depth of "
+                "field, cinematic 35mm film.",
+                None,
+                None,
+            ],
+            [
+                "Text-to-Video",
+                "A drone camera circles around a beautiful historic church built on a rocky outcropping "
+                "along the Amalfi Coast, the view showcases historic and magnificent architectural "
+                "details and tiered pathways and patios, waves are seen crashing against the rocks "
+                "below as the view overlooks the horizon of the coastal waters and hilly landscapes "
+                "of the Amalfi Coast Italy, several distant people are seen walking and enjoying vistas "
+                "on patios of the dramatic ocean views, the warm glow of the afternoon sun creates a "
+                "magical and romantic feeling to the scene, the view is stunning captured with beautiful photography.",
+                None,
+                None,
+            ],
+            [
+                "Image-to-Video",
+                "A towering emerald wave surges forward, its crest curling with raw power and energy. Sunlight glints off the translucent water, illuminating the intricate textures and deep green hues within the wave’s body. A thick spray erupts from the breaking crest, casting a misty veil that dances above the churning surface. As the perspective widens, the immense scale of the wave becomes apparent, revealing the restless expanse of the ocean stretching beyond. The scene captures the ocean’s untamed beauty and relentless force, with every droplet and ripple shimmering in the light. The dynamic motion and vivid colors evoke both awe and respect for nature’s might.",
+                "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/helios/wave.jpg",
+                None,
+            ],
+            [
+                "Video-to-Video",
+                "A bright yellow Lamborghini Huracn Tecnica speeds along a curving mountain road, surrounded by lush green trees under a partly cloudy sky. The car's sleek design and vibrant color stand out against the natural backdrop, emphasizing its dynamic movement. The road curves gently, with a guardrail visible on one side, adding depth to the scene. The motion blur captures the sense of speed and energy, creating a thrilling and exhilarating atmosphere. A front-facing shot from a slightly elevated angle, highlighting the car's aggressive stance and the surrounding greenery.",
+                None,
+                "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/helios/car.mp4",
+            ],
+        ],
+        inputs=[mode, prompt, image_input, video_input],
+        label="Example Prompts",
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=True, css=CSS, theme=gr.themes.Soft())

Helios/_DEV3/bench_infer.py

@@ -0,0 +1,569 @@
+"""
+Helios Benchmark Inference Script
+- Runs T2V inference for a single model version on a single GPU
+- Uses the first N prompts from a txt file
+- Saves videos in two layouts:  by_prompt/<slug>/<version>.mp4
+                                 by_version/<version>/<slug>.mp4
+- Records per-video timing to timing_<version>.txt and computes summary stats
+"""
+
+import importlib
+import os
+import re
+import shutil
+import sys
+import time
+
+os.environ["HF_ENABLE_PARALLEL_LOADING"] = "yes"
+os.environ["HF_PARALLEL_LOADING_WORKERS"] = "8"
+
+import argparse
+import subprocess
+from pathlib import Path
+
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+DEFAULT_PROMPT_FILE = SCRIPT_DIR / "demo_data" / "MovieGenVideoBench_extended.txt"
+DEFAULT_MODEL_ROOT = SCRIPT_DIR / "checkpoints"
+DEFAULT_OUTPUT_ROOT = SCRIPT_DIR / "output_helios" / "bench"
+
+
+def pick_gpu_by_free_vram(min_free_mib=20000):
+    """Pick physical GPU index with the most free memory (via nvidia-smi). No torch import."""
+    try:
+        out = subprocess.check_output(
+            [
+                "nvidia-smi",
+                "--query-gpu=index,memory.free",
+                "--format=csv,noheader,nounits",
+            ],
+            text=True,
+            stderr=subprocess.DEVNULL,
+        )
+    except (subprocess.CalledProcessError, FileNotFoundError) as e:
+        raise RuntimeError("nvidia-smi failed; specify --gpu explicitly") from e
+
+    best_idx, best_free = None, -1
+    for line in out.strip().splitlines():
+        parts = [p.strip() for p in line.split(",")]
+        if len(parts) < 2:
+            continue
+        idx, free = int(parts[0]), int(parts[1])
+        if free > best_free:
+            best_free, best_idx = free, idx
+    if best_idx is None:
+        raise RuntimeError("Could not parse nvidia-smi GPU list")
+    if best_free < min_free_mib:
+        print(
+            f"[warn] Best GPU {best_idx} has only {best_free} MiB free "
+            f"(<{min_free_mib} MiB); OOM risk — consider --enable_low_vram_mode",
+            file=sys.stderr,
+        )
+    return best_idx, best_free
+
+
+def _apply_cuda_visible_devices_before_torch():
+    """CUDA_VISIBLE_DEVICES must be set before `import torch` (first CUDA init)."""
+    pre = argparse.ArgumentParser(add_help=False)
+    pre.add_argument("--gpu", type=str, default="auto")
+    known, _ = pre.parse_known_args()
+    g = known.gpu.strip().lower()
+    if g == "auto":
+        idx, free = pick_gpu_by_free_vram()
+        os.environ["CUDA_VISIBLE_DEVICES"] = str(idx)
+        os.environ["_BENCH_PHYSICAL_GPU"] = f"{idx} ({free} MiB free)"
+    else:
+        os.environ["CUDA_VISIBLE_DEVICES"] = known.gpu.strip()
+        os.environ["_BENCH_PHYSICAL_GPU"] = known.gpu.strip()
+    os.environ["_BENCH_GPU_ARG"] = known.gpu.strip()
+
+
+_apply_cuda_visible_devices_before_torch()
+
+import torch
+from tqdm import tqdm
+
+if importlib.util.find_spec("torch_npu") is not None:
+    import torch_npu  # noqa: F401
+
+from helios.diffusers_version.pipeline_helios_diffusers import HeliosPipeline
+from helios.diffusers_version.scheduling_helios_diffusers import HeliosScheduler
+from helios.diffusers_version.transformer_helios_diffusers import HeliosTransformer3DModel
+from helios.modules.helios_kernels import (
+    replace_all_norms_with_flash_norms,
+    replace_rmsnorm_with_fp32,
+    replace_rope_with_flash_rope,
+)
+from diffusers.models import AutoencoderKLWan
+from diffusers.utils import export_to_video
+
+# ── per-version inference presets (matching official scripts) ─────────────────
+
+MODEL_PRESETS = {
+    "base": dict(
+        model_dir="Helios-Base",
+        num_frames=99,
+        num_inference_steps=50,
+        guidance_scale=5.0,
+        is_enable_stage2=False,
+        pyramid_num_inference_steps_list=[20, 20, 20],
+        is_amplify_first_chunk=False,
+        use_zero_init=False,
+        zero_steps=1,
+    ),
+    "mid": dict(
+        model_dir="Helios-Mid",
+        num_frames=99,
+        num_inference_steps=50,
+        guidance_scale=5.0,
+        is_enable_stage2=True,
+        pyramid_num_inference_steps_list=[20, 20, 20],
+        is_amplify_first_chunk=False,
+        use_zero_init=True,
+        zero_steps=1,
+    ),
+    "distilled": dict(
+        model_dir="Helios-Distilled",
+        num_frames=240,
+        num_inference_steps=50,
+        guidance_scale=1.0,
+        is_enable_stage2=True,
+        pyramid_num_inference_steps_list=[2, 2, 2],
+        is_amplify_first_chunk=True,
+        use_zero_init=False,
+        zero_steps=1,
+    ),
+}
+
+NEGATIVE_PROMPT = (
+    "Bright tones, overexposed, static, blurred details, subtitles, style, "
+    "works, paintings, images, static, overall gray, worst quality, low quality, "
+    "JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, "
+    "poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, "
+    "still picture, messy background, three legs, many people in the background, "
+    "walking backwards"
+)
+
+
+def sanitize_filename(text, max_len=80):
+    """Turn a prompt into a filesystem-safe slug."""
+    text = text.strip().lower()
+    text = re.sub(r"[^a-z0-9]+", "_", text)
+    text = text.strip("_")
+    return text[:max_len]
+
+
+def load_prompt_indices(path):
+    indices = []
+    with open(path, "r", encoding="utf-8") as f:
+        for line_no, raw_line in enumerate(f, start=1):
+            line = raw_line.strip()
+            if not line or line.startswith("#"):
+                continue
+            try:
+                idx = int(line)
+            except ValueError as exc:
+                raise ValueError(
+                    f"Invalid prompt index at {path}:{line_no}: {line!r}"
+                ) from exc
+            if idx < 0:
+                raise ValueError(f"Prompt index must be >= 0 at {path}:{line_no}")
+            indices.append(idx)
+    return indices
+
+
+def load_prompts(path, prompt_start=0, prompt_end=None, prompt_indices=None):
+    with open(path, "r", encoding="utf-8") as f:
+        lines = [line.strip() for line in f if line.strip()]
+    if prompt_indices is not None:
+        selected = []
+        total = len(lines)
+        for idx in prompt_indices:
+            if idx >= total:
+                raise ValueError(
+                    f"Prompt index {idx} is out of range; prompt file has {total} prompts"
+                )
+            selected.append((idx, lines[idx]))
+        return selected
+
+    if prompt_start < 0:
+        raise ValueError("prompt_start must be >= 0")
+    if prompt_end is not None and prompt_end < prompt_start:
+        raise ValueError("prompt_end must be >= prompt_start")
+
+    selected = lines[prompt_start:prompt_end]
+    return [(prompt_start + offset, prompt) for offset, prompt in enumerate(selected)]
+
+
+def build_expected_outputs(prompts, version, by_version_dir):
+    version_dir = os.path.join(by_version_dir, version)
+    expected = []
+    for idx, prompt in prompts:
+        slug = sanitize_filename(prompt)
+        vid_name = f"{idx:04d}_{slug}"
+        expected.append((idx, slug, os.path.join(version_dir, f"{vid_name}.mp4")))
+    return version_dir, expected
+
+
+def output_exists(path):
+    return os.path.isfile(path) and os.path.getsize(path) > 0
+
+
+def find_missing_outputs(expected_outputs):
+    return [item for item in expected_outputs if not output_exists(item[2])]
+
+
+def make_timing_line(version, idx, elapsed, slug):
+    return (
+        f"  {version:10s}  #{idx:04d}  {elapsed:8.2f}s  "
+        f"({elapsed / 60:5.2f}min)  {slug[:50]}"
+    )
+
+
+def load_existing_timing_records(timing_file, version):
+    if not os.path.exists(timing_file):
+        return {}
+
+    pattern = re.compile(
+        rf"^\s*{re.escape(version)}\s+#(\d+)\s+([0-9.]+)s\s+\([^)]+\)\s+(.*)$"
+    )
+    records = {}
+    with open(timing_file, "r", encoding="utf-8") as f:
+        for raw_line in f:
+            line = raw_line.rstrip("\n")
+            match = pattern.match(line)
+            if not match:
+                continue
+            idx = int(match.group(1))
+            elapsed = float(match.group(2))
+            slug = match.group(3)
+            records[idx] = (elapsed, slug)
+    return records
+
+
+def build_pipeline(
+    model_path,
+    device,
+    weight_dtype,
+    enable_low_vram=False,
+    group_offloading_type="leaf_level",
+    num_blocks_per_group=4,
+):
+    transformer = HeliosTransformer3DModel.from_pretrained(
+        model_path, subfolder="transformer", torch_dtype=weight_dtype,
+    )
+    transformer = replace_rmsnorm_with_fp32(transformer)
+    transformer = replace_all_norms_with_flash_norms(transformer)
+    replace_rope_with_flash_rope()
+
+    cuda_major = torch.cuda.get_device_capability()[0]
+    if cuda_major >= 9:
+        try:
+            transformer.set_attention_backend("_flash_3_hub")
+        except Exception:
+            transformer.set_attention_backend("flash_hub")
+    else:
+        transformer.set_attention_backend("flash_hub")
+
+    vae = AutoencoderKLWan.from_pretrained(
+        model_path, subfolder="vae", torch_dtype=torch.float32,
+    )
+    scheduler = HeliosScheduler.from_pretrained(model_path, subfolder="scheduler")
+
+    pipe = HeliosPipeline.from_pretrained(
+        model_path,
+        transformer=transformer,
+        vae=vae,
+        scheduler=scheduler,
+        torch_dtype=weight_dtype,
+    )
+    if enable_low_vram:
+        nbg = int(num_blocks_per_group) if group_offloading_type == "block_level" else None
+        pipe.enable_group_offload(
+            onload_device=torch.device("cuda"),
+            offload_device=torch.device("cpu"),
+            offload_type=group_offloading_type,
+            num_blocks_per_group=nbg,
+            use_stream=True,
+            record_stream=True,
+        )
+    else:
+        pipe = pipe.to(device)
+    return pipe
+
+
+def run_single(pipe, prompt, preset, height, width, seed):
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+
+    t0 = time.time()
+    with torch.no_grad():
+        output = pipe(
+            prompt=prompt,
+            negative_prompt=NEGATIVE_PROMPT,
+            height=height,
+            width=width,
+            num_frames=preset["num_frames"],
+            num_inference_steps=preset["num_inference_steps"],
+            guidance_scale=preset["guidance_scale"],
+            generator=gen,
+            history_sizes=[16, 2, 1],
+            num_latent_frames_per_chunk=9,
+            keep_first_frame=True,
+            is_enable_stage2=preset["is_enable_stage2"],
+            pyramid_num_inference_steps_list=preset["pyramid_num_inference_steps_list"],
+            is_skip_first_chunk=False,
+            is_amplify_first_chunk=preset["is_amplify_first_chunk"],
+            use_zero_init=preset["use_zero_init"],
+            zero_steps=preset["zero_steps"],
+        ).frames[0]
+    elapsed = time.time() - t0
+    return output, elapsed
+
+
+def _parse_gpu(s):
+    if isinstance(s, str) and s.lower() == "auto":
+        return "auto"
+    return int(s)
+
+
+def parse_args():
+    p = argparse.ArgumentParser(description="Helios benchmark inference for one model version")
+    p.add_argument("--prompt_file", type=str,
+                    default=str(DEFAULT_PROMPT_FILE))
+    p.add_argument("--prompt_start", type=int, default=0)
+    p.add_argument("--prompt_end", type=int, default=100,
+                    help="Exclusive end index for prompts, e.g. 50 means up to #49")
+    p.add_argument("--prompt_indices_file", type=str, default=None,
+                    help="Optional file containing exact prompt indices to run, one per line")
+    p.add_argument("--model_root", type=str, default=str(DEFAULT_MODEL_ROOT),
+                    help="Parent dir containing Helios-Base / Helios-Mid / Helios-Distilled")
+    p.add_argument("--output_root", type=str, default=str(DEFAULT_OUTPUT_ROOT))
+    p.add_argument("--version", type=str, choices=sorted(MODEL_PRESETS.keys()), required=True,
+                    help="Which model version to run")
+    p.add_argument("--timing_file", type=str, default=None,
+                    help="Optional override for timing report path")
+    p.add_argument("--height", type=int, default=384)
+    p.add_argument("--width", type=int, default=640)
+    p.add_argument("--num_frames", type=int, default=None,
+                    help="Override preset frame count for all selected versions")
+    p.add_argument("--seed", type=int, default=42)
+    p.add_argument(
+        "--gpu",
+        type=_parse_gpu,
+        default="auto",
+        help='Physical GPU id or "auto" (pick most free VRAM via nvidia-smi)',
+    )
+    p.add_argument(
+        "--enable_low_vram_mode",
+        action="store_true",
+        help="CPU group-offload (slower, less VRAM); use if GPU is shared or OOM",
+    )
+    p.add_argument(
+        "--group_offloading_type",
+        type=str,
+        choices=["leaf_level", "block_level"],
+        default="leaf_level",
+    )
+    p.add_argument("--num_blocks_per_group", type=int, default=4)
+    return p.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    if not os.path.isfile(args.prompt_file):
+        raise FileNotFoundError(f"Prompt file not found: {args.prompt_file}")
+    if not os.path.isdir(args.model_root):
+        raise FileNotFoundError(f"Model root not found: {args.model_root}")
+
+    os.environ["CUDA_VISIBLE_DEVICES"] = str(args.gpu)
+    device = torch.device("cuda")
+    weight_dtype = torch.bfloat16
+
+    prompt_indices = None
+    if args.prompt_indices_file:
+        if not os.path.isfile(args.prompt_indices_file):
+            raise FileNotFoundError(f"Prompt indices file not found: {args.prompt_indices_file}")
+        prompt_indices = load_prompt_indices(args.prompt_indices_file)
+
+    prompts = load_prompts(
+        args.prompt_file,
+        args.prompt_start,
+        args.prompt_end,
+        prompt_indices=prompt_indices,
+    )
+    prompt_map = dict(prompts)
+    if args.prompt_indices_file:
+        print(
+            f"Loaded {len(prompts)} prompts from {args.prompt_file} "
+            f"(indices: {args.prompt_indices_file})"
+        )
+    else:
+        print(
+            f"Loaded {len(prompts)} prompts from {args.prompt_file} "
+            f"(range: {args.prompt_start}:{args.prompt_end})"
+        )
+
+    if args.num_frames is not None:
+        MODEL_PRESETS[args.version]["num_frames"] = args.num_frames
+
+    by_prompt_dir = os.path.join(args.output_root, "by_prompt")
+    by_version_dir = os.path.join(args.output_root, "by_version")
+    timing_file = args.timing_file or os.path.join(args.output_root, f"timing_{args.version}.txt")
+    os.makedirs(args.output_root, exist_ok=True)
+
+    preset = MODEL_PRESETS[args.version]
+    model_path = os.path.join(args.model_root, preset["model_dir"])
+    timing_records = load_existing_timing_records(timing_file, args.version)
+    selected_indices = set(prompt_map)
+    timing_records = {
+        idx: record for idx, record in timing_records.items() if idx in selected_indices
+    }
+    ver_dir, expected_outputs = build_expected_outputs(prompts, args.version, by_version_dir)
+    missing_outputs = find_missing_outputs(expected_outputs)
+    if not os.path.isdir(model_path):
+        raise FileNotFoundError(f"Model not found: {model_path}")
+
+    peak_mem = None
+    if not missing_outputs:
+        print(
+            f"[SKIP] All outputs already exist for version={args.version} under {ver_dir}"
+        )
+    else:
+        header = (
+            f"\n{'=' * 60}\n"
+            f"  Version: {args.version}  |  Model: {preset['model_dir']}\n"
+            f"  Frames: {preset['num_frames']}  |  guidance_scale: {preset['guidance_scale']}\n"
+            f"  stage2: {preset['is_enable_stage2']}  |  pyramid_steps: {preset['pyramid_num_inference_steps_list']}\n"
+            f"{'=' * 60}\n"
+        )
+        print(header)
+
+        pipe = build_pipeline(
+            model_path,
+            device,
+            weight_dtype,
+            enable_low_vram=args.enable_low_vram_mode,
+            group_offloading_type=args.group_offloading_type,
+            num_blocks_per_group=args.num_blocks_per_group,
+        )
+
+        os.makedirs(ver_dir, exist_ok=True)
+
+        print(
+            f"[resume] version={args.version} existing={len(expected_outputs) - len(missing_outputs)} "
+            f"missing={len(missing_outputs)} timed={len(timing_records)}"
+        )
+        for idx, slug, ver_out in tqdm(missing_outputs, desc=f"[{args.version}]"):
+            if os.path.exists(ver_out):
+                print(f"  [skip] {ver_out}")
+                continue
+
+            try:
+                frames, elapsed = run_single(
+                    pipe, prompt_map[idx], preset, args.height, args.width, args.seed,
+                )
+            except Exception as e:
+                msg = f"  [FAIL] {args.version} #{idx:04d}: {e}"
+                print(msg)
+                continue
+
+            export_to_video(frames, ver_out, fps=24)
+
+            vid_name = os.path.splitext(os.path.basename(ver_out))[0]
+            prompt_dir = os.path.join(by_prompt_dir, vid_name)
+            os.makedirs(prompt_dir, exist_ok=True)
+            shutil.copy2(ver_out, os.path.join(prompt_dir, f"{args.version}.mp4"))
+
+            timing_records[idx] = (elapsed, slug)
+            print(make_timing_line(args.version, idx, elapsed, slug))
+
+        peak_mem = torch.cuda.max_memory_allocated() / 1024 ** 3
+        print(f"  >> [{args.version}] peak GPU memory: {peak_mem:.2f} GB")
+
+        del pipe
+        torch.cuda.empty_cache()
+        torch.cuda.reset_peak_memory_stats()
+
+    sorted_records = [timing_records[idx] for idx in sorted(timing_records)]
+    all_timings = [elapsed for elapsed, _ in sorted_records]
+
+    with open(timing_file, "w", encoding="utf-8") as tf:
+        tf.write(f"{'=' * 80}\n")
+        tf.write(f"  Helios Benchmark Inference Timing Report\n")
+        tf.write(f"  {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
+        tf.write(
+            f"  Prompts: {len(prompts)}  |  Range: {args.prompt_start}:{args.prompt_end}  "
+            f"|  Version: {args.version}\n"
+        )
+        if args.prompt_indices_file:
+            tf.write(f"  Prompt indices file: {args.prompt_indices_file}\n")
+        tf.write(
+            f"  Resolution: {args.width}x{args.height}  |  Seed: {args.seed}  |  "
+            f"GPU: {args.gpu}  |  low_vram: {args.enable_low_vram_mode}\n"
+        )
+        tf.write(f"{'=' * 80}\n\n")
+
+        tf.write(
+            f"\n{'=' * 60}\n"
+            f"  Version: {args.version}  |  Model: {preset['model_dir']}\n"
+            f"  Frames: {preset['num_frames']}  |  guidance_scale: {preset['guidance_scale']}\n"
+            f"  stage2: {preset['is_enable_stage2']}  |  pyramid_steps: {preset['pyramid_num_inference_steps_list']}\n"
+            f"{'=' * 60}\n"
+        )
+        tf.write(
+            f"  Existing timing records: {len(timing_records)} / expected outputs: {len(expected_outputs)}\n"
+        )
+
+        for idx in sorted(timing_records):
+            elapsed, slug = timing_records[idx]
+            tf.write(make_timing_line(args.version, idx, elapsed, slug) + "\n")
+
+        if all_timings:
+            avg_t = sum(all_timings) / len(all_timings)
+            total_t = sum(all_timings)
+            summary = (
+                f"\n  >> [{args.version}] completed {len(all_timings)} videos  |  "
+                f"avg: {avg_t:.2f}s ({avg_t / 60:.2f}min)  |  "
+                f"total: {total_t:.1f}s ({total_t / 60:.1f}min)\n"
+            )
+        else:
+            summary = f"\n  >> [{args.version}] no timing records available\n"
+        print(summary)
+        tf.write(summary)
+
+        if peak_mem is not None:
+            mem_line = f"  >> [{args.version}] peak GPU memory: {peak_mem:.2f} GB\n"
+            tf.write(mem_line)
+
+        sep = f"\n{'=' * 80}\n"
+        tf.write(sep)
+        tf.write("  FINAL SUMMARY\n")
+        tf.write(f"{'=' * 80}\n")
+        print(sep)
+        print("  FINAL SUMMARY")
+        print(f"{'=' * 80}")
+
+        fmt = "  {ver:12s} | videos: {n:3d} | avg: {avg:8.2f}s ({avgm:5.2f}min) | min: {mn:8.2f}s | max: {mx:8.2f}s | total: {tot:8.1f}s ({totm:5.1f}min)"
+        if all_timings:
+            line = fmt.format(
+                ver=args.version, n=len(all_timings),
+                avg=sum(all_timings) / len(all_timings), avgm=sum(all_timings) / len(all_timings) / 60,
+                mn=min(all_timings), mx=max(all_timings),
+                tot=sum(all_timings), totm=sum(all_timings) / 60,
+            )
+        else:
+            line = f"  {args.version:12s} | N/A (no timing records)"
+        print(line)
+        tf.write(line + "\n")
+
+        tf.write(f"{'=' * 80}\n")
+
+    print(f"{'=' * 80}")
+    print(f"\nTiming report: {timing_file}")
+    print(f"Videos:        {by_prompt_dir}")
+    print(f"               {by_version_dir}")
+
+
+if __name__ == "__main__":
+    main()

Helios/_DEV3/infer_helios.py

@@ -0,0 +1,673 @@
+import importlib
+import os
+
+
+os.environ["HF_ENABLE_PARALLEL_LOADING"] = "yes"
+os.environ["HF_PARALLEL_LOADING_WORKERS"] = "8"
+
+import argparse
+import time
+from pathlib import Path
+
+import pandas as pd
+import torch
+import torch.distributed as dist
+from tqdm import tqdm
+
+
+if importlib.util.find_spec("torch_npu") is not None:
+    import torch_npu
+else:
+    torch_npu = None
+
+from helios.diffusers_version.pipeline_helios_diffusers import HeliosPipeline
+from helios.diffusers_version.scheduling_helios_diffusers import HeliosScheduler
+from helios.diffusers_version.transformer_helios_diffusers import HeliosTransformer3DModel
+from helios.modules.helios_kernels import (
+    replace_all_norms_with_flash_norms,
+    replace_rmsnorm_with_fp32,
+    replace_rope_with_flash_rope,
+)
+from helios.utils.utils_base import load_extra_components
+
+from diffusers import ContextParallelConfig
+from diffusers.models import AutoencoderKLWan
+from diffusers.utils import export_to_video, load_image, load_video
+
+PROJECT_ROOT = Path(__file__).resolve().parent
+DEFAULT_BASE_MODEL_PATH = str(PROJECT_ROOT / "checkpoints" / "Helios-Base")
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Generate video with model")
+
+    # === Model paths ===
+    parser.add_argument("--base_model_path", type=str, default=DEFAULT_BASE_MODEL_PATH)
+    parser.add_argument(
+        "--transformer_path",
+        type=str,
+        default=DEFAULT_BASE_MODEL_PATH,
+    )
+    parser.add_argument(
+        "--lora_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--partial_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument("--output_folder", type=str, default="./output_helios")
+    parser.add_argument("--enable_compile", action="store_true")
+
+    # === Generation parameters ===
+    # environment
+    parser.add_argument(
+        "--sample_type",
+        type=str,
+        default="t2v",
+        choices=["t2v", "i2v", "v2v"],
+    )
+    parser.add_argument(
+        "--weight_dtype",
+        type=str,
+        default="bf16",
+        choices=["bf16", "fp16", "fp32"],
+        help="Data type for model weights.",
+    )
+    parser.add_argument("--seed", type=int, default=42, help="Seed for random number generator.")
+    # base
+    parser.add_argument("--height", type=int, default=384)
+    parser.add_argument("--width", type=int, default=640)
+    parser.add_argument("--num_frames", type=int, default=99)
+    parser.add_argument("--fps", type=int, default=24)
+    parser.add_argument("--num_inference_steps", type=int, default=50)
+    parser.add_argument("--guidance_scale", type=float, default=5.0)
+    # cfg zero
+    parser.add_argument("--use_zero_init", action="store_true")
+    parser.add_argument("--zero_steps", type=int, default=1)
+    # stage 1
+    parser.add_argument("--num_latent_frames_per_chunk", type=int, default=9)
+    # stage 2
+    parser.add_argument("--is_enable_stage2", action="store_true")
+    parser.add_argument("--pyramid_num_inference_steps_list", type=int, nargs="+", default=[20, 20, 20])
+    # stage 3
+    parser.add_argument("--is_skip_first_chunk", action="store_true")
+    parser.add_argument("--is_amplify_first_chunk", action="store_true")
+    parser.add_argument(
+        "--visualize_relative_l1",
+        action="store_true",
+        help="Save per-chunk denoising relative L1 records and a timestep plot.",
+    )
+    parser.add_argument(
+        "--relative_l1_output_folder",
+        type=str,
+        default=None,
+        help="Deprecated. Relative L1 files are saved next to the mp4 in each prompt timestamp folder.",
+    )
+
+    # === Prompts ===
+    parser.add_argument("--use_interpolate_prompt", action="store_true")
+    parser.add_argument("--interpolation_steps", type=int, default=3)
+    parser.add_argument("--interpolate_time", type=int, default=7)
+    parser.add_argument(
+        "--image_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--image_noise_sigma_min", type=float, default=0.111, help="Balance motion amplitude and visual consistency"
+    )
+    parser.add_argument(
+        "--image_noise_sigma_max", type=float, default=0.135, help="Balance motion amplitude and visual consistency"
+    )
+    parser.add_argument(
+        "--video_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--video_noise_sigma_min", type=float, default=0.111, help="Balance motion amplitude and visual consistency"
+    )
+    parser.add_argument(
+        "--video_noise_sigma_max", type=float, default=0.135, help="Balance motion amplitude and visual consistency"
+    )
+    parser.add_argument(
+        "--prompt",
+        type=str,
+        default="A dynamic time-lapse video showing the rapidly moving scenery from the window of a speeding train. The camera captures various elements such as lush green fields, towering trees, quaint countryside houses, and distant mountain ranges passing by quickly. The train window frames the view, adding a sense of speed and motion as the landscape rushes past. The camera remains static but emphasizes the fast-paced movement outside. The overall atmosphere is serene yet exhilarating, capturing the essence of travel and exploration. Medium shot focusing on the train window and the rushing scenery beyond.",
+    )
+    parser.add_argument(
+        "--negative_prompt",
+        type=str,
+        default="Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards",
+    )
+    parser.add_argument(
+        "--prompt_txt_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--base_image_prompt_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--image_prompt_csv_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--interactive_prompt_csv_path",
+        type=str,
+        default=None,
+    )
+
+    # === Context parallelism ===
+    # Please refer to https://huggingface.co/docs/diffusers/main/en/training/distributed_inference#context-parallelism
+    parser.add_argument("--enable_parallelism", action="store_true")
+    parser.add_argument(
+        "--cp_backend",
+        type=str,
+        choices=["ring", "ulysses", "unified", "ulysses_anything"],
+        default="ulysses",
+        help="Context parallel backend to use.",
+    )
+
+    # === Group-Offloading ===
+    # Please refer to https://huggingface.co/docs/diffusers/main/en/optimization/memory#group-offloading
+    parser.add_argument("--enable_low_vram_mode", action="store_true")
+    parser.add_argument(
+        "--group_offloading_type",
+        type=str,
+        choices=["leaf_level", "block_level"],
+        default="leaf_level",
+        help="Specifies the granularity for group CPU offloading. Choose between 'leaf_level' (individual modules) or 'block_level' (entire blocks).",
+    )
+    parser.add_argument(
+        "--num_blocks_per_group",
+        type=str,
+        default="4",
+        help="The number of blocks to bundle together in each offloading group. Only relevant when using block-level offloading.",
+    )
+
+    return parser.parse_args()
+
+
+def build_sample_output_dir(output_folder, prompt_or_prompts):
+    if isinstance(prompt_or_prompts, list):
+        prompt_text = prompt_or_prompts[0] if prompt_or_prompts else "prompt"
+    else:
+        prompt_text = prompt_or_prompts or "prompt"
+
+    prompt_text = str(prompt_text).strip()
+    safe_chars = []
+    previous_was_sep = False
+    for char in prompt_text:
+        if char.isalnum():
+            safe_chars.append(char)
+            previous_was_sep = False
+        elif not previous_was_sep:
+            safe_chars.append("_")
+            previous_was_sep = True
+
+    prompt_stem = "".join(safe_chars).strip("_")[:80] or "prompt"
+    sample_dir = Path(output_folder) / f"{prompt_stem}_{int(time.time())}"
+
+    suffix = 1
+    base_sample_dir = sample_dir
+    while sample_dir.exists():
+        sample_dir = Path(f"{base_sample_dir}_{suffix}")
+        suffix += 1
+
+    sample_dir.mkdir(parents=True, exist_ok=False)
+    return sample_dir
+
+
+def save_relative_l1_outputs(records, output_folder):
+    if not records:
+        print(f"No relative L1 records for {output_folder}.")
+        return
+
+    metrics_dir = Path(output_folder)
+    metrics_dir.mkdir(parents=True, exist_ok=True)
+    df = pd.DataFrame(records).sort_values(["chunk_index", "step_index", "stage_index"])
+
+    csv_path = metrics_dir / "relative_l1.csv"
+    df.to_csv(csv_path, index=False)
+
+    try:
+        import matplotlib
+
+        matplotlib.use("Agg")
+        import matplotlib.pyplot as plt
+
+        def save_metric_plot(metric_name, ylabel, title, plot_name):
+            fig, ax = plt.subplots(figsize=(9, 5))
+            for chunk_index, chunk_df in df.groupby("chunk_index"):
+                chunk_df = chunk_df.sort_values(["step_index", "stage_index"])
+                ax.plot(
+                    chunk_df["timestep"],
+                    chunk_df[metric_name],
+                    marker="o",
+                    linewidth=1.5,
+                    markersize=3,
+                    label=f"chunk {chunk_index}",
+                )
+
+            ax.set_xlabel("timestep")
+            ax.set_ylabel(ylabel)
+            ax.set_title(title)
+            ax.grid(True, alpha=0.3)
+            ax.invert_xaxis()
+            ax.legend()
+            fig.tight_layout()
+
+            plot_path = metrics_dir / plot_name
+            fig.savefig(plot_path, dpi=200)
+            plt.close(fig)
+            return plot_path
+
+        plot_path = save_metric_plot(
+            "relative_l1",
+            "mean relative L1",
+            "Denoising relative L1 per chunk",
+            "relative_l1.png",
+        )
+        ratio_plot_path = None
+        if "relative_l1_ratio" in df.columns:
+            ratio_plot_path = save_metric_plot(
+                "relative_l1_ratio",
+                "mean(delta L1) / mean(latent L1)",
+                "Denoising relative L1 ratio per chunk",
+                "relative_l1_ratio.png",
+            )
+
+        if ratio_plot_path is None:
+            print(f"Saved relative L1 CSV to {csv_path} and plot to {plot_path}")
+        else:
+            print(f"Saved relative L1 CSV to {csv_path} and plots to {plot_path}, {ratio_plot_path}")
+    except Exception as exc:
+        print(f"Saved relative L1 CSV to {csv_path}, but failed to save plot: {exc}")
+
+
+def main():
+    args = parse_args()
+
+    assert not (args.enable_low_vram_mode and args.enable_compile), (
+        "enable_low_vram_mode and enable_compile cannot be used together."
+    )
+
+    if args.weight_dtype == "fp32":
+        args.weight_dtype = torch.float32
+    elif args.weight_dtype == "fp16":
+        args.weight_dtype = torch.float16
+    else:
+        args.weight_dtype = torch.bfloat16
+
+    os.makedirs(args.output_folder, exist_ok=True)
+
+    if dist.is_available() and "RANK" in os.environ:
+        if args.cp_backend == "ulysses_anything":
+            dist.init_process_group(backend="cpu:gloo,cuda:nccl")
+        else:
+            dist.init_process_group(backend="nccl")
+        rank = dist.get_rank()
+        device = torch.device("cuda", rank % torch.cuda.device_count())
+        world_size = dist.get_world_size()
+        torch.cuda.set_device(device)
+        assert world_size == 1 or not args.enable_low_vram_mode, "enable_low_vram_mode is only for single GPU."
+    else:
+        rank = 0
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        world_size = 1
+
+    prompt = None
+    image_path = None
+    video_path = None
+    interpolate_time_list = None
+    if args.sample_type == "t2v" and args.prompt is None:
+        prompt = "An extreme close-up of an gray-haired man with a beard in his 60s, he is deep in thought pondering the history of the universe as he sits at a cafe in Paris, his eyes focus on people offscreen as they walk as he sits mostly motionless, he is dressed in a wool coat suit coat with a button-down shirt , he wears a brown beret and glasses and has a very professorial appearance, and the end he offers a subtle closed-mouth smile as if he found the answer to the mystery of life, the lighting is very cinematic with the golden light and the Parisian streets and city in the background, depth of field, cinematic 35mm film."
+    elif args.sample_type == "i2v" and (args.image_path is None and args.prompt is None):
+        image_path = (
+            "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg"
+        )
+        prompt = "An astronaut hatching from an egg, on the surface of the moon, the darkness and depth of space realised in the background. High quality, ultrarealistic detail and breath-taking movie-like camera shot."
+    elif args.sample_type == "v2v" and (args.video_path is None and args.prompt is None):
+        video_path = (
+            "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/hiker.mp4"
+        )
+        prompt = "A robot standing on a mountain top. The sun is setting in the background."
+    else:
+        image_path = args.image_path
+        video_path = args.video_path
+        prompt = args.prompt
+
+    transformer = HeliosTransformer3DModel.from_pretrained(
+        args.transformer_path,
+        subfolder="transformer",
+        torch_dtype=args.weight_dtype,
+    )
+    if not args.enable_compile:
+        transformer = replace_rmsnorm_with_fp32(transformer)
+        transformer = replace_all_norms_with_flash_norms(transformer)
+        replace_rope_with_flash_rope()
+    cuda_major = torch.cuda.get_device_capability()[0]
+    if cuda_major >= 9:
+        # H100/H800 (SM90+) with FA3
+        try:
+            transformer.set_attention_backend("_flash_3_hub")
+        except Exception:
+            transformer.set_attention_backend("flash_hub")
+    else:
+        # 4090/A100 etc (SM89+) with FA2
+        transformer.set_attention_backend("flash_hub")
+
+    vae = AutoencoderKLWan.from_pretrained(
+        args.base_model_path,
+        subfolder="vae",
+        torch_dtype=torch.float32,
+    )
+    scheduler = HeliosScheduler.from_pretrained(
+        args.base_model_path,
+        subfolder="scheduler",
+    )
+    pipe = HeliosPipeline.from_pretrained(
+        args.base_model_path,
+        transformer=transformer,
+        vae=vae,
+        scheduler=scheduler,
+        torch_dtype=args.weight_dtype,
+    )
+
+    if args.lora_path is not None:
+        pipe.load_lora_weights(args.lora_path, adapter_name="default")
+        pipe.set_adapters(["default"], adapter_weights=[1.0])
+
+        if args.partial_path is not None:
+            if not hasattr(args, "training_config"):
+                from argparse import Namespace
+
+                args.training_config = Namespace()
+            args.training_config.is_enable_stage1 = True
+            args.training_config.restrict_self_attn = True
+            args.training_config.is_amplify_history = True
+            args.training_config.is_use_gan = True
+            load_extra_components(args, transformer, args.partial_path)
+
+    if args.enable_compile:
+        torch.backends.cudnn.benchmark = True
+        pipe.text_encoder.compile(mode="max-autotune-no-cudagraphs", dynamic=False)
+        pipe.vae.compile(mode="max-autotune-no-cudagraphs", dynamic=False)
+        pipe.transformer.compile(mode="max-autotune-no-cudagraphs", dynamic=False)
+
+    if args.enable_low_vram_mode:
+        pipe.enable_group_offload(
+            onload_device=torch.device("cuda"),
+            offload_device=torch.device("cpu"),
+            offload_type=args.group_offloading_type,
+            num_blocks_per_group=args.num_blocks_per_group if args.group_offloading_type == "block_level" else None,
+            use_stream=True,
+            record_stream=True,
+        )
+    else:
+        pipe = pipe.to(device)
+
+    if world_size > 1 and args.enable_parallelism:
+        if args.cp_backend == "ring":
+            cp_config = ContextParallelConfig(ring_degree=world_size)
+        elif args.cp_backend == "unified":
+            cp_config = ContextParallelConfig(ring_degree=world_size // 2, ulysses_degree=world_size // 2)
+        elif args.cp_backend == "ulysses":
+            cp_config = ContextParallelConfig(ulysses_degree=world_size)
+        elif args.cp_backend == "ulysses_anything":
+            cp_config = ContextParallelConfig(ulysses_degree=world_size, ulysses_anything=True)
+        else:
+            raise ValueError(f"Unsupported cp_backend: {args.cp_backend}")
+
+        pipe.transformer.enable_parallelism(config=cp_config)
+
+    if args.prompt_txt_path is not None:
+        with open(args.prompt_txt_path, "r") as f:
+            prompt_list = [line.strip() for line in f.readlines() if line.strip()]
+        if not args.enable_parallelism:
+            prompt_list_with_idx = [(i, prompt) for i, prompt in enumerate(prompt_list)]
+            prompt_list_with_idx = prompt_list_with_idx[rank::world_size]
+        else:
+            prompt_list_with_idx = [(i, prompt) for i, prompt in enumerate(prompt_list)]
+
+        for idx, prompt in tqdm(prompt_list_with_idx, desc="Processing prompts"):
+            with torch.no_grad():
+                try:
+                    pipe_output = pipe(
+                        prompt=prompt,
+                        negative_prompt=args.negative_prompt,
+                        height=args.height,
+                        width=args.width,
+                        num_frames=args.num_frames,
+                        num_inference_steps=args.num_inference_steps,
+                        guidance_scale=args.guidance_scale,
+                        generator=torch.Generator(device="cuda").manual_seed(args.seed),
+                        # stage 1
+                        history_sizes=[16, 2, 1],
+                        num_latent_frames_per_chunk=args.num_latent_frames_per_chunk,
+                        keep_first_frame=True,
+                        # stage 2
+                        is_enable_stage2=args.is_enable_stage2,
+                        pyramid_num_inference_steps_list=args.pyramid_num_inference_steps_list,
+                        # stage 3
+                        is_skip_first_chunk=args.is_skip_first_chunk,
+                        is_amplify_first_chunk=args.is_amplify_first_chunk,
+                        # cfg zero
+                        use_zero_init=args.use_zero_init,
+                        zero_steps=args.zero_steps,
+                        # i2v
+                        image=load_image(image_path).resize((args.width, args.height))
+                        if image_path is not None
+                        else None,
+                        image_noise_sigma_min=args.image_noise_sigma_min,
+                        image_noise_sigma_max=args.image_noise_sigma_max,
+                        # v2v
+                        video=load_video(video_path) if video_path is not None else None,
+                        video_noise_sigma_min=args.video_noise_sigma_min,
+                        video_noise_sigma_max=args.video_noise_sigma_max,
+                        # interpolate_prompt
+                        use_interpolate_prompt=args.use_interpolate_prompt,
+                        interpolation_steps=args.interpolation_steps,
+                        interpolate_time_list=interpolate_time_list,
+                        output_relative_l1=args.visualize_relative_l1,
+                    )
+                    output = pipe_output.frames[0]
+                except Exception:
+                    continue
+            if not args.enable_parallelism or rank == 0:
+                sample_dir = build_sample_output_dir(args.output_folder, prompt)
+                output_path = sample_dir / "video.mp4"
+                export_to_video(output, str(output_path), fps=24)
+                if args.visualize_relative_l1:
+                    save_relative_l1_outputs(pipe_output.relative_l1, sample_dir)
+    elif args.image_prompt_csv_path is not None:
+        df = pd.read_csv(args.image_prompt_csv_path)
+        if not args.enable_parallelism:
+            df = df.iloc[rank::world_size]
+
+        for idx, row in tqdm(df.iterrows(), total=len(df), desc="Processing prompts"):
+            prompt = row.get("refined_prompt") or row["prompt"]
+            image_path = os.path.join(args.base_image_prompt_path, row["image_name"])
+
+            with torch.no_grad():
+                try:
+                    pipe_output = pipe(
+                        prompt=prompt,
+                        negative_prompt=args.negative_prompt,
+                        height=args.height,
+                        width=args.width,
+                        num_frames=args.num_frames,
+                        num_inference_steps=args.num_inference_steps,
+                        guidance_scale=args.guidance_scale,
+                        generator=torch.Generator(device="cuda").manual_seed(args.seed),
+                        # stage 1
+                        history_sizes=[16, 2, 1],
+                        num_latent_frames_per_chunk=args.num_latent_frames_per_chunk,
+                        keep_first_frame=True,
+                        # stage 2
+                        is_enable_stage2=args.is_enable_stage2,
+                        pyramid_num_inference_steps_list=args.pyramid_num_inference_steps_list,
+                        # stage 3
+                        is_skip_first_chunk=args.is_skip_first_chunk,
+                        is_amplify_first_chunk=args.is_amplify_first_chunk,
+                        # cfg zero
+                        use_zero_init=args.use_zero_init,
+                        zero_steps=args.zero_steps,
+                        # i2v
+                        image=load_image(image_path).resize((args.width, args.height))
+                        if image_path is not None
+                        else None,
+                        image_noise_sigma_min=args.image_noise_sigma_min,
+                        image_noise_sigma_max=args.image_noise_sigma_max,
+                        # v2v
+                        video=load_video(video_path) if video_path is not None else None,
+                        video_noise_sigma_min=args.video_noise_sigma_min,
+                        video_noise_sigma_max=args.video_noise_sigma_max,
+                        # interpolate_prompt
+                        use_interpolate_prompt=args.use_interpolate_prompt,
+                        interpolation_steps=args.interpolation_steps,
+                        interpolate_time_list=interpolate_time_list,
+                        output_relative_l1=args.visualize_relative_l1,
+                    )
+                    output = pipe_output.frames[0]
+                except Exception:
+                    continue
+            if not args.enable_parallelism or rank == 0:
+                sample_dir = build_sample_output_dir(args.output_folder, prompt)
+                output_path = sample_dir / "video.mp4"
+                export_to_video(output, str(output_path), fps=24)
+                if args.visualize_relative_l1:
+                    save_relative_l1_outputs(pipe_output.relative_l1, sample_dir)
+    elif args.interactive_prompt_csv_path is not None:
+        df = pd.read_csv(args.interactive_prompt_csv_path)
+
+        df = df.sort_values(by=["id", "prompt_index"])
+        all_video_ids = df["id"].unique()
+
+        if not args.enable_parallelism:
+            my_video_ids = all_video_ids[rank::world_size]
+        else:
+            my_video_ids = all_video_ids
+
+        for video_id in tqdm(my_video_ids, desc="Processing prompts"):
+            group_df = df[df["id"] == video_id]
+
+            if "refined_prompt" in df.columns:
+                prompt_list = group_df["refined_prompt"].fillna(group_df["prompt"]).tolist()
+            else:
+                prompt_list = group_df["prompt"].tolist()
+            interpolate_time_list = [args.interpolate_time] * len(prompt_list)
+
+            with torch.no_grad():
+                try:
+                    pipe_output = pipe(
+                        prompt=prompt_list,
+                        negative_prompt=args.negative_prompt,
+                        height=args.height,
+                        width=args.width,
+                        num_frames=args.num_frames,
+                        num_inference_steps=args.num_inference_steps,
+                        guidance_scale=args.guidance_scale,
+                        generator=torch.Generator(device="cuda").manual_seed(args.seed),
+                        # stage 1
+                        history_sizes=[16, 2, 1],
+                        num_latent_frames_per_chunk=args.num_latent_frames_per_chunk,
+                        keep_first_frame=True,
+                        # stage 2
+                        is_enable_stage2=args.is_enable_stage2,
+                        pyramid_num_inference_steps_list=args.pyramid_num_inference_steps_list,
+                        # stage 3
+                        is_skip_first_chunk=args.is_skip_first_chunk,
+                        is_amplify_first_chunk=args.is_amplify_first_chunk,
+                        # cfg zero
+                        use_zero_init=args.use_zero_init,
+                        zero_steps=args.zero_steps,
+                        # i2v
+                        image=load_image(image_path).resize((args.width, args.height))
+                        if image_path is not None
+                        else None,
+                        image_noise_sigma_min=args.image_noise_sigma_min,
+                        image_noise_sigma_max=args.image_noise_sigma_max,
+                        # v2v
+                        video=load_video(video_path) if video_path is not None else None,
+                        video_noise_sigma_min=args.video_noise_sigma_min,
+                        video_noise_sigma_max=args.video_noise_sigma_max,
+                        # interpolate_prompt
+                        use_interpolate_prompt=args.use_interpolate_prompt,
+                        interpolation_steps=args.interpolation_steps,
+                        interpolate_time_list=interpolate_time_list,
+                        output_relative_l1=args.visualize_relative_l1,
+                    )
+                    output = pipe_output.frames[0]
+                except Exception:
+                    continue
+            if not args.enable_parallelism or rank == 0:
+                sample_dir = build_sample_output_dir(args.output_folder, prompt_list)
+                output_path = sample_dir / "video.mp4"
+                export_to_video(output, str(output_path), fps=24)
+                if args.visualize_relative_l1:
+                    save_relative_l1_outputs(pipe_output.relative_l1, sample_dir)
+    else:
+        with torch.no_grad():
+            # import time
+            # for _ in range(20):
+            #     start_time = time.time()
+            pipe_output = pipe(
+                prompt=prompt,
+                negative_prompt=args.negative_prompt,
+                height=args.height,
+                width=args.width,
+                num_frames=args.num_frames,
+                num_inference_steps=args.num_inference_steps,
+                guidance_scale=args.guidance_scale,
+                generator=torch.Generator(device="cuda").manual_seed(args.seed),
+                # stage 1
+                history_sizes=[16, 2, 1],
+                num_latent_frames_per_chunk=args.num_latent_frames_per_chunk,
+                keep_first_frame=True,
+                # stage 2
+                is_enable_stage2=args.is_enable_stage2,
+                pyramid_num_inference_steps_list=args.pyramid_num_inference_steps_list,
+                # stage 3
+                is_skip_first_chunk=args.is_skip_first_chunk,
+                is_amplify_first_chunk=args.is_amplify_first_chunk,
+                # cfg zero
+                use_zero_init=args.use_zero_init,
+                zero_steps=args.zero_steps,
+                # i2v
+                image=load_image(image_path).resize((args.width, args.height)) if image_path is not None else None,
+                image_noise_sigma_min=args.image_noise_sigma_min,
+                image_noise_sigma_max=args.image_noise_sigma_max,
+                # v2v
+                video=load_video(video_path) if video_path is not None else None,
+                video_noise_sigma_min=args.video_noise_sigma_min,
+                video_noise_sigma_max=args.video_noise_sigma_max,
+                # interpolate_prompt
+                use_interpolate_prompt=args.use_interpolate_prompt,
+                interpolation_steps=args.interpolation_steps,
+                interpolate_time_list=interpolate_time_list,
+                output_relative_l1=args.visualize_relative_l1,
+            )
+            output = pipe_output.frames[0]
+            # elapsed_time = time.time() - start_time
+            # print(f"Inference time: {elapsed_time:.2f} seconds ({elapsed_time/60:.2f} minutes)")
+
+        if not args.enable_parallelism or rank == 0:
+            sample_dir = build_sample_output_dir(args.output_folder, prompt)
+            output_path = sample_dir / "video.mp4"
+            export_to_video(output, str(output_path), fps=24)
+            if args.visualize_relative_l1:
+                save_relative_l1_outputs(pipe_output.relative_l1, sample_dir)
+
+    print(f"Max memory: {torch.cuda.max_memory_allocated() / 1024**3:.3f} GB")
+
+
+if __name__ == "__main__":
+    main()

Helios/_DEV3/install.sh

@@ -0,0 +1,10 @@
+pip install -r requirements.txt
+
+rm -rf ~/.triton/cache/
+rm -rf /tmp/torchinductor_*
+
+pip uninstall triton torchao xformers wandb tensorflow tensorflow-cpu -y
+pip install wandb==0.23.0 triton==3.6.0
+
+rm -rf ~/.triton/cache/
+rm -rf /tmp/torchinductor_*

Helios/_DEV3/requirements.txt

@@ -0,0 +1,35 @@
+torch==2.10.0
+torchvision==0.25.0
+torchaudio==2.10.0
+triton==3.6.0
+kernels==0.13.0
+# diffusers==0.36.0
+# transformers==4.57.6
+git+https://github.com/huggingface/diffusers.git
+transformers==5.3.0
+sentence-transformers==5.2.3
+accelerate==1.12.0
+deepspeed==0.18.4
+peft==0.18.1
+huggingface-hub==1.4.1
+zstandard==0.25.0
+wandb==0.23.0
+video-reader-rs==0.4.1
+numpy<2.0.0
+opencv-python
+gradio
+spaces
+moviepy
+imageio-ffmpeg
+ftfy
+Jinja2
+einops
+nvitop
+packaging
+ninja
+omegaconf
+mpi4py
+hf-doc-builder
+torchdata
+loguru
+tf_keras

Helios/_DEV3/requirements_npu.txt

@@ -0,0 +1,6 @@
+# Please refer to here for installation the latest version: https://github.com/Ascend/pytorch?tab=readme-ov-file#ascend-auxiliary-software
+torch==2.9.0
+torchvision==0.24.0
+torchaudio==2.9.0
+torch_npu==2.9.0
+triton==3.5.1

Helios/_DEV3/run_bench.sh

@@ -0,0 +1,275 @@
+#!/bin/bash
+# =============================================================================
+#  Helios Benchmark Inference Runner
+#  用法: bash run_bench.sh [--gpus 5 6 7] [--prompt_range 0-50] [--num_frames 240]
+#                         [--version base] [--version mid distilled]
+#  默认使用所有可见 GPU；默认跑全部版本（base/mid/distilled），也可手动指定版本
+#  同一时刻只跑一个版本；若有多张卡，会先扫描输出目录，只把缺失 case 均分到多张卡并行
+#  低显存: LOW_VRAM=1 bash run_bench.sh
+# =============================================================================
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+if [[ -n "${PYTHON:-}" ]]; then
+    PYTHON_BIN="${PYTHON}"
+elif command -v python3 >/dev/null 2>&1; then
+    PYTHON_BIN="$(command -v python3)"
+elif command -v python >/dev/null 2>&1; then
+    PYTHON_BIN="$(command -v python)"
+else
+    echo "Python interpreter not found. Set PYTHON=/path/to/python." >&2
+    exit 1
+fi
+
+GPUS=()
+PROMPT_START="${PROMPT_START:-0}"
+PROMPT_END="${PROMPT_END:-100}"
+NUM_FRAMES="${NUM_FRAMES:-}"
+VERSIONS=(base mid distilled)
+OUTPUT_ROOT="${OUTPUT_ROOT:-}"
+PROMPT_FILE="${PROMPT_FILE:-${SCRIPT_DIR}/demo_data/MovieGenVideoBench_extended.txt}"
+LOW_VRAM="${LOW_VRAM:-0}"
+
+discover_gpus() {
+    if ! command -v nvidia-smi >/dev/null 2>&1; then
+        echo "nvidia-smi not found; use --gpus to specify GPU ids explicitly." >&2
+        exit 1
+    fi
+
+    mapfile -t GPUS < <(nvidia-smi --query-gpu=index --format=csv,noheader,nounits)
+    if [[ ${#GPUS[@]} -eq 0 ]]; then
+        echo "No GPUs found." >&2
+        exit 1
+    fi
+}
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --gpus)        shift; GPUS=(); while [[ $# -gt 0 && ! "$1" =~ ^-- ]]; do GPUS+=("$1"); shift; done ;;
+        --prompt_range)
+            if [[ ! "$2" =~ ^([0-9]+)-([0-9]+)$ ]]; then
+                echo "Invalid --prompt_range: $2 (expected START-END, e.g. 0-50)" >&2
+                exit 1
+            fi
+            PROMPT_START="${BASH_REMATCH[1]}"
+            PROMPT_END="${BASH_REMATCH[2]}"
+            shift 2
+            ;;
+        --prompt_start) PROMPT_START="$2"; shift 2 ;;
+        --prompt_end)   PROMPT_END="$2"; shift 2 ;;
+        --num_frames)  NUM_FRAMES="$2";  shift 2 ;;
+        --version)     shift; VERSIONS=(); while [[ $# -gt 0 && ! "$1" =~ ^-- ]]; do VERSIONS+=("$1"); shift; done ;;
+        --output_root) OUTPUT_ROOT="$2"; shift 2 ;;
+        --prompt_file) PROMPT_FILE="$2"; shift 2 ;;
+        *) echo "Unknown option: $1"; exit 1 ;;
+    esac
+done
+
+if [[ ${#GPUS[@]} -eq 0 ]]; then
+    discover_gpus
+fi
+
+if [[ ${#VERSIONS[@]} -eq 0 ]]; then
+    echo "No versions specified. Use --version base [mid distilled]." >&2
+    exit 1
+fi
+
+if [[ ! "${PROMPT_START}" =~ ^[0-9]+$ ]] || [[ ! "${PROMPT_END}" =~ ^[0-9]+$ ]]; then
+    echo "prompt_start and prompt_end must be non-negative integers." >&2
+    exit 1
+fi
+
+if (( PROMPT_END <= PROMPT_START )); then
+    echo "prompt_end must be greater than prompt_start." >&2
+    exit 1
+fi
+
+if [[ -z "${OUTPUT_ROOT}" ]]; then
+    if [[ -n "${NUM_FRAMES}" ]]; then
+        OUTPUT_ROOT="${SCRIPT_DIR}/outputs/num_frames_${NUM_FRAMES}"
+    else
+        OUTPUT_ROOT="${SCRIPT_DIR}/outputs/num_frames_default"
+    fi
+fi
+
+echo "============================================================"
+echo "  Helios Benchmark Inference"
+echo "  $(date '+%Y-%m-%d %H:%M:%S')"
+echo "  Python: ${PYTHON_BIN}"
+echo "  GPUs: ${GPUS[*]}  |  Prompt range: ${PROMPT_START}-${PROMPT_END}  |  Versions: ${VERSIONS[*]}"
+[[ -n "${NUM_FRAMES}" ]] && echo "  Frames: ${NUM_FRAMES}"
+echo "  Prompt file: ${PROMPT_FILE}"
+echo "  Output: ${OUTPUT_ROOT}"
+echo "============================================================"
+
+mkdir -p "${OUTPUT_ROOT}"
+
+if [[ ! -f "${PROMPT_FILE}" ]]; then
+    echo "Prompt file not found: ${PROMPT_FILE}" >&2
+    exit 1
+fi
+
+TOTAL_PROMPTS=$(awk 'NF {count++} END {print count + 0}' "${PROMPT_FILE}")
+if (( PROMPT_START >= TOTAL_PROMPTS )); then
+    echo "prompt_start (${PROMPT_START}) is out of range; prompt file has ${TOTAL_PROMPTS} non-empty prompts." >&2
+    exit 1
+fi
+
+if (( PROMPT_END > TOTAL_PROMPTS )); then
+    echo "prompt_end (${PROMPT_END}) exceeds total prompts (${TOTAL_PROMPTS}); clamping to ${TOTAL_PROMPTS}."
+    PROMPT_END="${TOTAL_PROMPTS}"
+fi
+
+EXTRA=()
+if [[ "${LOW_VRAM}" == "1" ]]; then
+    EXTRA+=(--enable_low_vram_mode)
+fi
+if [[ -n "${NUM_FRAMES}" ]]; then
+    EXTRA+=(--num_frames "${NUM_FRAMES}")
+fi
+
+EXIT_CODE=0
+WORKER_PIDS=()
+WORKER_GPUS=()
+WORKER_SHARDS=()
+
+prepare_missing_shards() {
+    local version="$1"
+    local shard_dir="${OUTPUT_ROOT}/shards/${version}_${PROMPT_START}_${PROMPT_END}_$$"
+    mkdir -p "${shard_dir}"
+
+    "${PYTHON_BIN}" - \
+        "${PROMPT_FILE}" \
+        "${OUTPUT_ROOT}" \
+        "${version}" \
+        "${PROMPT_START}" \
+        "${PROMPT_END}" \
+        "${#GPUS[@]}" \
+        "${shard_dir}" <<'PY'
+import os
+import re
+import sys
+from pathlib import Path
+
+prompt_file = Path(sys.argv[1])
+output_root = Path(sys.argv[2])
+version = sys.argv[3]
+prompt_start = int(sys.argv[4])
+prompt_end = int(sys.argv[5])
+gpu_count = int(sys.argv[6])
+shard_dir = Path(sys.argv[7])
+
+with prompt_file.open("r", encoding="utf-8") as f:
+    prompts = [line.strip() for line in f if line.strip()]
+
+def sanitize_filename(text, max_len=80):
+    text = text.strip().lower()
+    text = re.sub(r"[^a-z0-9]+", "_", text)
+    text = text.strip("_")
+    return text[:max_len]
+
+missing = []
+existing = 0
+version_dir = output_root / "by_version" / version
+for idx in range(prompt_start, prompt_end):
+    slug = sanitize_filename(prompts[idx])
+    video_path = version_dir / f"{idx:04d}_{slug}.mp4"
+    if video_path.is_file() and video_path.stat().st_size > 0:
+        existing += 1
+    else:
+        missing.append(idx)
+
+print(
+    f"[scan] version={version} range={prompt_start}-{prompt_end} "
+    f"existing={existing} missing={len(missing)} output={version_dir}",
+    file=sys.stderr,
+)
+
+if not missing:
+    sys.exit(0)
+
+active_workers = min(gpu_count, len(missing))
+base_chunk = len(missing) // active_workers
+remainder = len(missing) % active_workers
+offset = 0
+
+for shard_idx in range(active_workers):
+    shard_size = base_chunk + (1 if shard_idx < remainder else 0)
+    shard_indices = missing[offset:offset + shard_size]
+    offset += shard_size
+    shard_path = shard_dir / f"shard_{shard_idx:02d}.txt"
+    shard_path.write_text(
+        "".join(f"{idx}\n" for idx in shard_indices),
+        encoding="utf-8",
+    )
+    print(shard_path)
+    print(
+        f"[shard] version={version} shard={shard_idx} count={len(shard_indices)} "
+        f"indices={shard_indices[0]}-{shard_indices[-1]} file={shard_path}",
+        file=sys.stderr,
+    )
+PY
+}
+
+launch_job() {
+    local version="$1"
+    local gpu="$2"
+    local shard_file="$3"
+    local shard_id
+    shard_id="$(basename "${shard_file}" .txt)"
+    local timing_file="${OUTPUT_ROOT}/timing_${version}_${shard_id}.txt"
+
+    echo "[launch] version=${version} gpu=${gpu} shard=${shard_id} indices=${shard_file} output=${OUTPUT_ROOT}"
+    "${PYTHON_BIN}" "${SCRIPT_DIR}/bench_infer.py" \
+        --prompt_file  "${PROMPT_FILE}" \
+        --prompt_start "${PROMPT_START}" \
+        --prompt_end   "${PROMPT_END}" \
+        --prompt_indices_file "${shard_file}" \
+        --output_root  "${OUTPUT_ROOT}" \
+        --timing_file  "${timing_file}" \
+        --version      "${version}" \
+        --gpu          "${gpu}" \
+        "${EXTRA[@]}" &
+
+    WORKER_PIDS+=("$!")
+    WORKER_GPUS+=("${gpu}")
+    WORKER_SHARDS+=("${shard_id}")
+}
+
+wait_for_current_version() {
+    local version="$1"
+    for idx in "${!WORKER_PIDS[@]}"; do
+        local pid="${WORKER_PIDS[$idx]}"
+        local gpu="${WORKER_GPUS[$idx]}"
+        local shard_id="${WORKER_SHARDS[$idx]}"
+        if wait "${pid}"; then
+            echo "[done] ${version} finished on gpu=${gpu} shard=${shard_id}"
+        else
+            echo "[fail] ${version} failed on gpu=${gpu} shard=${shard_id}"
+            EXIT_CODE=1
+        fi
+    done
+    WORKER_PIDS=()
+    WORKER_GPUS=()
+    WORKER_SHARDS=()
+}
+
+for version in "${VERSIONS[@]}"; do
+    echo ""
+    echo "-------------------- version=${version} --------------------"
+    mapfile -t SHARD_FILES < <(prepare_missing_shards "${version}")
+    if (( ${#SHARD_FILES[@]} == 0 )); then
+        echo "[skip] version=${version} has no missing cases in ${PROMPT_START}-${PROMPT_END}"
+        continue
+    fi
+
+    for worker_idx in "${!SHARD_FILES[@]}"; do
+        launch_job "${version}" "${GPUS[$worker_idx]}" "${SHARD_FILES[$worker_idx]}"
+    done
+    wait_for_current_version "${version}"
+done
+
+echo ""
+echo "Done. Per-shard timing reports are under ${OUTPUT_ROOT}/timing_<version>_shard_<id>.txt"
+
+exit ${EXIT_CODE:-0}

Helios/app.py

@@ -0,0 +1,320 @@
+import tempfile
+import time
+
+import gradio as gr
+import spaces
+import torch
+
+from torch.utils._pytree import tree_map
+from diffusers import AutoencoderKLWan, HeliosDMDScheduler, HeliosPyramidPipeline
+from diffusers.utils import export_to_video, load_image, load_video
+
+
+# ---------------------------------------------------------------------------
+# Pre-load model
+# ---------------------------------------------------------------------------
+MODEL_ID = "BestWishYsh/Helios-Distilled"
+
+vae = AutoencoderKLWan.from_pretrained(MODEL_ID, subfolder="vae", torch_dtype=torch.float32)
+scheduler = HeliosDMDScheduler.from_pretrained(MODEL_ID, subfolder="scheduler")
+pipe = HeliosPyramidPipeline.from_pretrained(
+    MODEL_ID, vae=vae, scheduler=scheduler, torch_dtype=torch.bfloat16, is_distilled=True
+)
+pipe.to("cuda")
+
+cuda_major = torch.cuda.get_device_capability()[0]
+if cuda_major >= 9:
+    # H100/H800 (SM90+) with FA3
+    try:
+        pipe.transformer.set_attention_backend("_flash_3_hub")
+    except Exception:
+        pipe.transformer.set_attention_backend("flash_hub")
+else:
+    # 4090/A100 etc (SM89+) with FA2
+    pipe.transformer.set_attention_backend("flash_hub")
+
+# ---------------------------------------------------------------------------
+# AoTI
+# ---------------------------------------------------------------------------
+
+# Dynamic shapes: within a generation, only hidden_states H/W change across
+# pyramid stages (history latents stay at full resolution). text_seq_length
+# varies between different prompts.
+_AUTO = torch.export.Dim.AUTO
+
+TRANSFORMER_DYNAMIC_SHAPES = {
+    "hidden_states": {
+        3: _AUTO,  # H — doubles each pyramid stage
+        4: _AUTO,  # W — doubles each pyramid stage
+    },
+    "encoder_hidden_states": {
+        1: _AUTO,  # text_seq_length — varies with prompt
+    },
+}
+
+INDUCTOR_CONFIGS = {
+    "conv_1x1_as_mm": True,
+    "epilogue_fusion": False,
+    "coordinate_descent_tuning": True,
+    "coordinate_descent_check_all_directions": True,
+    # "max_autotune": True,
+    "triton.cudagraphs": True,
+}
+
+@spaces.GPU(duration=1500) # maximum duration allowed during startup
+def compile_transformer():
+    with spaces.aoti_capture(pipe.transformer) as call:
+        pipe(
+            "arbitrary example prompt",
+            height=384,
+            width=640,
+            num_frames=33,
+            guidance_scale=1.0,
+            generator=torch.Generator(device="cuda").manual_seed(42),
+            pyramid_num_inference_steps_list=[2, 2, 2],
+            is_amplify_first_chunk=True,
+        )
+
+    dynamic_shapes = tree_map(lambda t: None, call.kwargs)
+    dynamic_shapes |= TRANSFORMER_DYNAMIC_SHAPES
+
+    with torch.no_grad():
+        exported = torch.export.export(
+            pipe.transformer,
+            args=call.args,
+            kwargs=call.kwargs,
+            dynamic_shapes=dynamic_shapes,
+        )
+
+    return spaces.aoti_compile(exported, INDUCTOR_CONFIGS)
+
+compiled_transformer = compile_transformer()
+spaces.aoti_apply(compiled_transformer, pipe.transformer)
+
+
+# ---------------------------------------------------------------------------
+# Generation
+# ---------------------------------------------------------------------------
+@spaces.GPU(duration=60)
+def generate_video(
+    mode: str,
+    prompt: str,
+    image_input,
+    video_input,
+    height: int,
+    width: int,
+    num_frames: int,
+    num_inference_steps: int,
+    seed: int,
+    is_amplify_first_chunk: bool,
+    progress=gr.Progress(track_tqdm=True),
+):
+    if not prompt:
+        raise gr.Error("Please provide a prompt.")
+
+    generator = torch.Generator(device="cuda").manual_seed(int(seed))
+
+    kwargs = {
+        "prompt": prompt,
+        "height": int(height),
+        "width": int(width),
+        "num_frames": int(num_frames),
+        "guidance_scale": 1.0,
+        "generator": generator,
+        "output_type": "np",
+        "pyramid_num_inference_steps_list": [
+            int(num_inference_steps),
+            int(num_inference_steps),
+            int(num_inference_steps),
+        ],
+        "is_amplify_first_chunk": is_amplify_first_chunk,
+    }
+
+    if mode == "Image-to-Video" and image_input is not None:
+        img = load_image(image_input).resize((int(width), int(height)))
+        kwargs["image"] = img
+    elif mode == "Video-to-Video" and video_input is not None:
+        kwargs["video"] = load_video(video_input)
+
+    t0 = time.time()
+    output = pipe(**kwargs).frames[0]
+    elapsed = time.time() - t0
+
+    tmp = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
+    export_to_video(output, tmp.name, fps=24)
+    info = f"Generated in {elapsed:.1f}s · {num_frames} frames · {height}×{width}"
+    return tmp.name, info
+
+
+# ---------------------------------------------------------------------------
+# UI Setup
+# ---------------------------------------------------------------------------
+def update_conditional_visibility(mode):
+    if mode == "Image-to-Video":
+        return gr.update(visible=True), gr.update(visible=False)
+    elif mode == "Video-to-Video":
+        return gr.update(visible=False), gr.update(visible=True)
+    else:
+        return gr.update(visible=False), gr.update(visible=False)
+
+
+CSS = """
+#header { text-align: center; margin-bottom: 1.5em; }
+#header h1 { font-size: 2.2em; margin-bottom: 0.2em; }
+.logo { max-height: 100px; margin: 0 auto 10px auto; display: block; }
+.link-buttons { display: flex; justify-content: center; gap: 15px; margin-top: 10px; }
+.link-buttons a {
+    background-color: #2b3137;
+    color: #ffffff !important;
+    padding: 8px 20px;
+    border-radius: 6px;
+    text-decoration: none;
+    font-weight: 600;
+    font-size: 1em;
+    transition: all 0.2s ease-in-out;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+}
+.link-buttons a:hover { background-color: #4a535c; transform: translateY(-1px); }
+.contain { max-width: 1350px; margin: 0 auto !important; }
+"""
+
+with gr.Blocks(title="Helios Video Generation") as demo:
+    gr.HTML(
+        """
+        <div style='display: flex; align-items: center; justify-content: center; width: 100%;'>
+            <img src="https://raw.githubusercontent.com/SHYuanBest/shyuanbest_media/main/Helios/logo_white.png" style='width: 400px; height: auto;' />
+        </div>
+        <div id="header">
+            <h1>🎬 Helios 14B Distilled: Real Real-Time Long Video Generation Model</h1>
+            <p style="font-size: 1.1em; color: #666; margin-top: 0.5em; margin-bottom: 1em;">
+                If you like our project, please give us a star ⭐ on GitHub for the latest update.
+            </p>
+            <div class="link-buttons">
+                <a href="https://github.com/PKU-YuanGroup/Helios" target="_blank">💻 Code</a>
+                <a href="https://pku-yuangroup.github.io/Helios-Page" target="_blank">📄 Page</a>
+                <a href="https://www.youtube.com/watch?v=vd_AgHtOUFQ" target="_blank">🎥 Main Feature</a>
+                <a href="https://www.youtube.com/watch?v=1GeIU2Dn7UY" target="_blank">⚡ Inference Speed</a>
+            </div>
+        </div>
+        """
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            mode = gr.Radio(
+                choices=["Text-to-Video", "Image-to-Video", "Video-to-Video"],
+                value="Text-to-Video",
+                label="Generation Mode",
+            )
+            image_input = gr.Image(label="Image (for I2V)", type="filepath", visible=False)
+            video_input = gr.Video(label="Video (for V2V)", visible=False)
+            prompt = gr.Textbox(
+                label="Prompt",
+                lines=4,
+                value=(
+                    "A vibrant tropical fish swimming gracefully among colorful coral reefs in "
+                    "a clear, turquoise ocean. The fish has bright blue and yellow scales with a "
+                    "small, distinctive orange spot on its side, its fins moving fluidly. The coral "
+                    "reefs are alive with a variety of marine life, including small schools of "
+                    "colorful fish and sea turtles gliding by. The water is crystal clear, allowing "
+                    "for a view of the sandy ocean floor below. The reef itself is adorned with a mix "
+                    "of hard and soft corals in shades of red, orange, and green. The photo captures "
+                    "the fish from a slightly elevated angle, emphasizing its lively movements and the "
+                    "vivid colors of its surroundings. A close-up shot with dynamic movement."
+                ),
+            )
+            with gr.Accordion("Advanced Settings", open=False):
+                with gr.Row():
+                    height = gr.Number(value=384, label="Height", precision=0, interactive=False)
+                    width = gr.Number(value=640, label="Width", precision=0, interactive=False)
+                with gr.Row():
+                    num_frames = gr.Slider(33, 231, value=231, step=33, label="Num Frames")
+                    num_inference_steps = gr.Slider(1, 10, value=2, step=1, label="Steps per stage")
+                with gr.Row():
+                    seed = gr.Number(value=42, label="Seed", precision=0)
+                    is_amplify_first_chunk = gr.Checkbox(label="Amplify First Chunk", value=True)
+
+            generate_btn = gr.Button("🚀 Generate Video", variant="primary", size="lg")
+
+        with gr.Column(scale=1):
+            video_output = gr.Video(label="Generated Video", autoplay=True)
+            info_output = gr.Textbox(label="Info", interactive=False)
+
+    mode.change(fn=update_conditional_visibility, inputs=[mode], outputs=[image_input, video_input])
+    generate_btn.click(
+        fn=generate_video,
+        inputs=[
+            mode,
+            prompt,
+            image_input,
+            video_input,
+            height,
+            width,
+            num_frames,
+            num_inference_steps,
+            seed,
+            is_amplify_first_chunk,
+        ],
+        outputs=[video_output, info_output],
+    )
+
+    gr.Examples(
+        examples=[
+            [
+                "Text-to-Video",
+                "A vibrant tropical fish swimming gracefully among colorful coral reefs in "
+                "a clear, turquoise ocean. The fish has bright blue and yellow scales with a "
+                "small, distinctive orange spot on its side, its fins moving fluidly. The coral "
+                "reefs are alive with a variety of marine life, including small schools of "
+                "colorful fish and sea turtles gliding by. The water is crystal clear, allowing "
+                "for a view of the sandy ocean floor below. The reef itself is adorned with a mix "
+                "of hard and soft corals in shades of red, orange, and green. The photo captures "
+                "the fish from a slightly elevated angle, emphasizing its lively movements and the "
+                "vivid colors of its surroundings. A close-up shot with dynamic movement.",
+                None,
+                None,
+            ],
+            [
+                "Text-to-Video",
+                "An extreme close-up of an gray-haired man with a beard in his 60s, he is deep in "
+                "thought pondering the history of the universe as he sits at a cafe in Paris, his eyes "
+                "focus on people offscreen as they walk as he sits mostly motionless, he is dressed in "
+                "a wool coat suit coat with a button-down shirt , he wears a brown beret and glasses "
+                "and has a very professorial appearance, and the end he offers a subtle closed-mouth "
+                "smile as if he found the answer to the mystery of life, the lighting is very cinematic "
+                "with the golden light and the Parisian streets and city in the background, depth of "
+                "field, cinematic 35mm film.",
+                None,
+                None,
+            ],
+            [
+                "Text-to-Video",
+                "A drone camera circles around a beautiful historic church built on a rocky outcropping "
+                "along the Amalfi Coast, the view showcases historic and magnificent architectural "
+                "details and tiered pathways and patios, waves are seen crashing against the rocks "
+                "below as the view overlooks the horizon of the coastal waters and hilly landscapes "
+                "of the Amalfi Coast Italy, several distant people are seen walking and enjoying vistas "
+                "on patios of the dramatic ocean views, the warm glow of the afternoon sun creates a "
+                "magical and romantic feeling to the scene, the view is stunning captured with beautiful photography.",
+                None,
+                None,
+            ],
+            [
+                "Image-to-Video",
+                "A towering emerald wave surges forward, its crest curling with raw power and energy. Sunlight glints off the translucent water, illuminating the intricate textures and deep green hues within the wave’s body. A thick spray erupts from the breaking crest, casting a misty veil that dances above the churning surface. As the perspective widens, the immense scale of the wave becomes apparent, revealing the restless expanse of the ocean stretching beyond. The scene captures the ocean’s untamed beauty and relentless force, with every droplet and ripple shimmering in the light. The dynamic motion and vivid colors evoke both awe and respect for nature’s might.",
+                "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/helios/wave.jpg",
+                None,
+            ],
+            [
+                "Video-to-Video",
+                "A bright yellow Lamborghini Huracn Tecnica speeds along a curving mountain road, surrounded by lush green trees under a partly cloudy sky. The car's sleek design and vibrant color stand out against the natural backdrop, emphasizing its dynamic movement. The road curves gently, with a guardrail visible on one side, adding depth to the scene. The motion blur captures the sense of speed and energy, creating a thrilling and exhilarating atmosphere. A front-facing shot from a slightly elevated angle, highlighting the car's aggressive stance and the surrounding greenery.",
+                None,
+                "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/helios/car.mp4",
+            ],
+        ],
+        inputs=[mode, prompt, image_input, video_input],
+        label="Example Prompts",
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=True, css=CSS, theme=gr.themes.Soft())

Helios/bench_infer.py

@@ -0,0 +1,569 @@
+"""
+Helios Benchmark Inference Script
+- Runs T2V inference for a single model version on a single GPU
+- Uses the first N prompts from a txt file
+- Saves videos in two layouts:  by_prompt/<slug>/<version>.mp4
+                                 by_version/<version>/<slug>.mp4
+- Records per-video timing to timing_<version>.txt and computes summary stats
+"""
+
+import importlib
+import os
+import re
+import shutil
+import sys
+import time
+
+os.environ["HF_ENABLE_PARALLEL_LOADING"] = "yes"
+os.environ["HF_PARALLEL_LOADING_WORKERS"] = "8"
+
+import argparse
+import subprocess
+from pathlib import Path
+
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+DEFAULT_PROMPT_FILE = SCRIPT_DIR / "demo_data" / "MovieGenVideoBench_extended.txt"
+DEFAULT_MODEL_ROOT = SCRIPT_DIR / "checkpoints"
+DEFAULT_OUTPUT_ROOT = SCRIPT_DIR / "output_helios" / "bench"
+
+
+def pick_gpu_by_free_vram(min_free_mib=20000):
+    """Pick physical GPU index with the most free memory (via nvidia-smi). No torch import."""
+    try:
+        out = subprocess.check_output(
+            [
+                "nvidia-smi",
+                "--query-gpu=index,memory.free",
+                "--format=csv,noheader,nounits",
+            ],
+            text=True,
+            stderr=subprocess.DEVNULL,
+        )
+    except (subprocess.CalledProcessError, FileNotFoundError) as e:
+        raise RuntimeError("nvidia-smi failed; specify --gpu explicitly") from e
+
+    best_idx, best_free = None, -1
+    for line in out.strip().splitlines():
+        parts = [p.strip() for p in line.split(",")]
+        if len(parts) < 2:
+            continue
+        idx, free = int(parts[0]), int(parts[1])
+        if free > best_free:
+            best_free, best_idx = free, idx
+    if best_idx is None:
+        raise RuntimeError("Could not parse nvidia-smi GPU list")
+    if best_free < min_free_mib:
+        print(
+            f"[warn] Best GPU {best_idx} has only {best_free} MiB free "
+            f"(<{min_free_mib} MiB); OOM risk — consider --enable_low_vram_mode",
+            file=sys.stderr,
+        )
+    return best_idx, best_free
+
+
+def _apply_cuda_visible_devices_before_torch():
+    """CUDA_VISIBLE_DEVICES must be set before `import torch` (first CUDA init)."""
+    pre = argparse.ArgumentParser(add_help=False)
+    pre.add_argument("--gpu", type=str, default="auto")
+    known, _ = pre.parse_known_args()
+    g = known.gpu.strip().lower()
+    if g == "auto":
+        idx, free = pick_gpu_by_free_vram()
+        os.environ["CUDA_VISIBLE_DEVICES"] = str(idx)
+        os.environ["_BENCH_PHYSICAL_GPU"] = f"{idx} ({free} MiB free)"
+    else:
+        os.environ["CUDA_VISIBLE_DEVICES"] = known.gpu.strip()
+        os.environ["_BENCH_PHYSICAL_GPU"] = known.gpu.strip()
+    os.environ["_BENCH_GPU_ARG"] = known.gpu.strip()
+
+
+_apply_cuda_visible_devices_before_torch()
+
+import torch
+from tqdm import tqdm
+
+if importlib.util.find_spec("torch_npu") is not None:
+    import torch_npu  # noqa: F401
+
+from helios.diffusers_version.pipeline_helios_diffusers import HeliosPipeline
+from helios.diffusers_version.scheduling_helios_diffusers import HeliosScheduler
+from helios.diffusers_version.transformer_helios_diffusers import HeliosTransformer3DModel
+from helios.modules.helios_kernels import (
+    replace_all_norms_with_flash_norms,
+    replace_rmsnorm_with_fp32,
+    replace_rope_with_flash_rope,
+)
+from diffusers.models import AutoencoderKLWan
+from diffusers.utils import export_to_video
+
+# ── per-version inference presets (matching official scripts) ─────────────────
+
+MODEL_PRESETS = {
+    "base": dict(
+        model_dir="Helios-Base",
+        num_frames=99,
+        num_inference_steps=50,
+        guidance_scale=5.0,
+        is_enable_stage2=False,
+        pyramid_num_inference_steps_list=[20, 20, 20],
+        is_amplify_first_chunk=False,
+        use_zero_init=False,
+        zero_steps=1,
+    ),
+    "mid": dict(
+        model_dir="Helios-Mid",
+        num_frames=99,
+        num_inference_steps=50,
+        guidance_scale=5.0,
+        is_enable_stage2=True,
+        pyramid_num_inference_steps_list=[20, 20, 20],
+        is_amplify_first_chunk=False,
+        use_zero_init=True,
+        zero_steps=1,
+    ),
+    "distilled": dict(
+        model_dir="Helios-Distilled",
+        num_frames=240,
+        num_inference_steps=50,
+        guidance_scale=1.0,
+        is_enable_stage2=True,
+        pyramid_num_inference_steps_list=[2, 2, 2],
+        is_amplify_first_chunk=True,
+        use_zero_init=False,
+        zero_steps=1,
+    ),
+}
+
+NEGATIVE_PROMPT = (
+    "Bright tones, overexposed, static, blurred details, subtitles, style, "
+    "works, paintings, images, static, overall gray, worst quality, low quality, "
+    "JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, "
+    "poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, "
+    "still picture, messy background, three legs, many people in the background, "
+    "walking backwards"
+)
+
+
+def sanitize_filename(text, max_len=80):
+    """Turn a prompt into a filesystem-safe slug."""
+    text = text.strip().lower()
+    text = re.sub(r"[^a-z0-9]+", "_", text)
+    text = text.strip("_")
+    return text[:max_len]
+
+
+def load_prompt_indices(path):
+    indices = []
+    with open(path, "r", encoding="utf-8") as f:
+        for line_no, raw_line in enumerate(f, start=1):
+            line = raw_line.strip()
+            if not line or line.startswith("#"):
+                continue
+            try:
+                idx = int(line)
+            except ValueError as exc:
+                raise ValueError(
+                    f"Invalid prompt index at {path}:{line_no}: {line!r}"
+                ) from exc
+            if idx < 0:
+                raise ValueError(f"Prompt index must be >= 0 at {path}:{line_no}")
+            indices.append(idx)
+    return indices
+
+
+def load_prompts(path, prompt_start=0, prompt_end=None, prompt_indices=None):
+    with open(path, "r", encoding="utf-8") as f:
+        lines = [line.strip() for line in f if line.strip()]
+    if prompt_indices is not None:
+        selected = []
+        total = len(lines)
+        for idx in prompt_indices:
+            if idx >= total:
+                raise ValueError(
+                    f"Prompt index {idx} is out of range; prompt file has {total} prompts"
+                )
+            selected.append((idx, lines[idx]))
+        return selected
+
+    if prompt_start < 0:
+        raise ValueError("prompt_start must be >= 0")
+    if prompt_end is not None and prompt_end < prompt_start:
+        raise ValueError("prompt_end must be >= prompt_start")
+
+    selected = lines[prompt_start:prompt_end]
+    return [(prompt_start + offset, prompt) for offset, prompt in enumerate(selected)]
+
+
+def build_expected_outputs(prompts, version, by_version_dir):
+    version_dir = os.path.join(by_version_dir, version)
+    expected = []
+    for idx, prompt in prompts:
+        slug = sanitize_filename(prompt)
+        vid_name = f"{idx:04d}_{slug}"
+        expected.append((idx, slug, os.path.join(version_dir, f"{vid_name}.mp4")))
+    return version_dir, expected
+
+
+def output_exists(path):
+    return os.path.isfile(path) and os.path.getsize(path) > 0
+
+
+def find_missing_outputs(expected_outputs):
+    return [item for item in expected_outputs if not output_exists(item[2])]
+
+
+def make_timing_line(version, idx, elapsed, slug):
+    return (
+        f"  {version:10s}  #{idx:04d}  {elapsed:8.2f}s  "
+        f"({elapsed / 60:5.2f}min)  {slug[:50]}"
+    )
+
+
+def load_existing_timing_records(timing_file, version):
+    if not os.path.exists(timing_file):
+        return {}
+
+    pattern = re.compile(
+        rf"^\s*{re.escape(version)}\s+#(\d+)\s+([0-9.]+)s\s+\([^)]+\)\s+(.*)$"
+    )
+    records = {}
+    with open(timing_file, "r", encoding="utf-8") as f:
+        for raw_line in f:
+            line = raw_line.rstrip("\n")
+            match = pattern.match(line)
+            if not match:
+                continue
+            idx = int(match.group(1))
+            elapsed = float(match.group(2))
+            slug = match.group(3)
+            records[idx] = (elapsed, slug)
+    return records
+
+
+def build_pipeline(
+    model_path,
+    device,
+    weight_dtype,
+    enable_low_vram=False,
+    group_offloading_type="leaf_level",
+    num_blocks_per_group=4,
+):
+    transformer = HeliosTransformer3DModel.from_pretrained(
+        model_path, subfolder="transformer", torch_dtype=weight_dtype,
+    )
+    transformer = replace_rmsnorm_with_fp32(transformer)
+    transformer = replace_all_norms_with_flash_norms(transformer)
+    replace_rope_with_flash_rope()
+
+    cuda_major = torch.cuda.get_device_capability()[0]
+    if cuda_major >= 9:
+        try:
+            transformer.set_attention_backend("_flash_3_hub")
+        except Exception:
+            transformer.set_attention_backend("flash_hub")
+    else:
+        transformer.set_attention_backend("flash_hub")
+
+    vae = AutoencoderKLWan.from_pretrained(
+        model_path, subfolder="vae", torch_dtype=torch.float32,
+    )
+    scheduler = HeliosScheduler.from_pretrained(model_path, subfolder="scheduler")
+
+    pipe = HeliosPipeline.from_pretrained(
+        model_path,
+        transformer=transformer,
+        vae=vae,
+        scheduler=scheduler,
+        torch_dtype=weight_dtype,
+    )
+    if enable_low_vram:
+        nbg = int(num_blocks_per_group) if group_offloading_type == "block_level" else None
+        pipe.enable_group_offload(
+            onload_device=torch.device("cuda"),
+            offload_device=torch.device("cpu"),
+            offload_type=group_offloading_type,
+            num_blocks_per_group=nbg,
+            use_stream=True,
+            record_stream=True,
+        )
+    else:
+        pipe = pipe.to(device)
+    return pipe
+
+
+def run_single(pipe, prompt, preset, height, width, seed):
+    gen = torch.Generator(device="cuda").manual_seed(seed)
+
+    t0 = time.time()
+    with torch.no_grad():
+        output = pipe(
+            prompt=prompt,
+            negative_prompt=NEGATIVE_PROMPT,
+            height=height,
+            width=width,
+            num_frames=preset["num_frames"],
+            num_inference_steps=preset["num_inference_steps"],
+            guidance_scale=preset["guidance_scale"],
+            generator=gen,
+            history_sizes=[16, 2, 1],
+            num_latent_frames_per_chunk=9,
+            keep_first_frame=True,
+            is_enable_stage2=preset["is_enable_stage2"],
+            pyramid_num_inference_steps_list=preset["pyramid_num_inference_steps_list"],
+            is_skip_first_chunk=False,
+            is_amplify_first_chunk=preset["is_amplify_first_chunk"],
+            use_zero_init=preset["use_zero_init"],
+            zero_steps=preset["zero_steps"],
+        ).frames[0]
+    elapsed = time.time() - t0
+    return output, elapsed
+
+
+def _parse_gpu(s):
+    if isinstance(s, str) and s.lower() == "auto":
+        return "auto"
+    return int(s)
+
+
+def parse_args():
+    p = argparse.ArgumentParser(description="Helios benchmark inference for one model version")
+    p.add_argument("--prompt_file", type=str,
+                    default=str(DEFAULT_PROMPT_FILE))
+    p.add_argument("--prompt_start", type=int, default=0)
+    p.add_argument("--prompt_end", type=int, default=100,
+                    help="Exclusive end index for prompts, e.g. 50 means up to #49")
+    p.add_argument("--prompt_indices_file", type=str, default=None,
+                    help="Optional file containing exact prompt indices to run, one per line")
+    p.add_argument("--model_root", type=str, default=str(DEFAULT_MODEL_ROOT),
+                    help="Parent dir containing Helios-Base / Helios-Mid / Helios-Distilled")
+    p.add_argument("--output_root", type=str, default=str(DEFAULT_OUTPUT_ROOT))
+    p.add_argument("--version", type=str, choices=sorted(MODEL_PRESETS.keys()), required=True,
+                    help="Which model version to run")
+    p.add_argument("--timing_file", type=str, default=None,
+                    help="Optional override for timing report path")
+    p.add_argument("--height", type=int, default=384)
+    p.add_argument("--width", type=int, default=640)
+    p.add_argument("--num_frames", type=int, default=None,
+                    help="Override preset frame count for all selected versions")
+    p.add_argument("--seed", type=int, default=42)
+    p.add_argument(
+        "--gpu",
+        type=_parse_gpu,
+        default="auto",
+        help='Physical GPU id or "auto" (pick most free VRAM via nvidia-smi)',
+    )
+    p.add_argument(
+        "--enable_low_vram_mode",
+        action="store_true",
+        help="CPU group-offload (slower, less VRAM); use if GPU is shared or OOM",
+    )
+    p.add_argument(
+        "--group_offloading_type",
+        type=str,
+        choices=["leaf_level", "block_level"],
+        default="leaf_level",
+    )
+    p.add_argument("--num_blocks_per_group", type=int, default=4)
+    return p.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    if not os.path.isfile(args.prompt_file):
+        raise FileNotFoundError(f"Prompt file not found: {args.prompt_file}")
+    if not os.path.isdir(args.model_root):
+        raise FileNotFoundError(f"Model root not found: {args.model_root}")
+
+    os.environ["CUDA_VISIBLE_DEVICES"] = str(args.gpu)
+    device = torch.device("cuda")
+    weight_dtype = torch.bfloat16
+
+    prompt_indices = None
+    if args.prompt_indices_file:
+        if not os.path.isfile(args.prompt_indices_file):
+            raise FileNotFoundError(f"Prompt indices file not found: {args.prompt_indices_file}")
+        prompt_indices = load_prompt_indices(args.prompt_indices_file)
+
+    prompts = load_prompts(
+        args.prompt_file,
+        args.prompt_start,
+        args.prompt_end,
+        prompt_indices=prompt_indices,
+    )
+    prompt_map = dict(prompts)
+    if args.prompt_indices_file:
+        print(
+            f"Loaded {len(prompts)} prompts from {args.prompt_file} "
+            f"(indices: {args.prompt_indices_file})"
+        )
+    else:
+        print(
+            f"Loaded {len(prompts)} prompts from {args.prompt_file} "
+            f"(range: {args.prompt_start}:{args.prompt_end})"
+        )
+
+    if args.num_frames is not None:
+        MODEL_PRESETS[args.version]["num_frames"] = args.num_frames
+
+    by_prompt_dir = os.path.join(args.output_root, "by_prompt")
+    by_version_dir = os.path.join(args.output_root, "by_version")
+    timing_file = args.timing_file or os.path.join(args.output_root, f"timing_{args.version}.txt")
+    os.makedirs(args.output_root, exist_ok=True)
+
+    preset = MODEL_PRESETS[args.version]
+    model_path = os.path.join(args.model_root, preset["model_dir"])
+    timing_records = load_existing_timing_records(timing_file, args.version)
+    selected_indices = set(prompt_map)
+    timing_records = {
+        idx: record for idx, record in timing_records.items() if idx in selected_indices
+    }
+    ver_dir, expected_outputs = build_expected_outputs(prompts, args.version, by_version_dir)
+    missing_outputs = find_missing_outputs(expected_outputs)
+    if not os.path.isdir(model_path):
+        raise FileNotFoundError(f"Model not found: {model_path}")
+
+    peak_mem = None
+    if not missing_outputs:
+        print(
+            f"[SKIP] All outputs already exist for version={args.version} under {ver_dir}"
+        )
+    else:
+        header = (
+            f"\n{'=' * 60}\n"
+            f"  Version: {args.version}  |  Model: {preset['model_dir']}\n"
+            f"  Frames: {preset['num_frames']}  |  guidance_scale: {preset['guidance_scale']}\n"
+            f"  stage2: {preset['is_enable_stage2']}  |  pyramid_steps: {preset['pyramid_num_inference_steps_list']}\n"
+            f"{'=' * 60}\n"
+        )
+        print(header)
+
+        pipe = build_pipeline(
+            model_path,
+            device,
+            weight_dtype,
+            enable_low_vram=args.enable_low_vram_mode,
+            group_offloading_type=args.group_offloading_type,
+            num_blocks_per_group=args.num_blocks_per_group,
+        )
+
+        os.makedirs(ver_dir, exist_ok=True)
+
+        print(
+            f"[resume] version={args.version} existing={len(expected_outputs) - len(missing_outputs)} "
+            f"missing={len(missing_outputs)} timed={len(timing_records)}"
+        )
+        for idx, slug, ver_out in tqdm(missing_outputs, desc=f"[{args.version}]"):
+            if os.path.exists(ver_out):
+                print(f"  [skip] {ver_out}")
+                continue
+
+            try:
+                frames, elapsed = run_single(
+                    pipe, prompt_map[idx], preset, args.height, args.width, args.seed,
+                )
+            except Exception as e:
+                msg = f"  [FAIL] {args.version} #{idx:04d}: {e}"
+                print(msg)
+                continue
+
+            export_to_video(frames, ver_out, fps=24)
+
+            vid_name = os.path.splitext(os.path.basename(ver_out))[0]
+            prompt_dir = os.path.join(by_prompt_dir, vid_name)
+            os.makedirs(prompt_dir, exist_ok=True)
+            shutil.copy2(ver_out, os.path.join(prompt_dir, f"{args.version}.mp4"))
+
+            timing_records[idx] = (elapsed, slug)
+            print(make_timing_line(args.version, idx, elapsed, slug))
+
+        peak_mem = torch.cuda.max_memory_allocated() / 1024 ** 3
+        print(f"  >> [{args.version}] peak GPU memory: {peak_mem:.2f} GB")
+
+        del pipe
+        torch.cuda.empty_cache()
+        torch.cuda.reset_peak_memory_stats()
+
+    sorted_records = [timing_records[idx] for idx in sorted(timing_records)]
+    all_timings = [elapsed for elapsed, _ in sorted_records]
+
+    with open(timing_file, "w", encoding="utf-8") as tf:
+        tf.write(f"{'=' * 80}\n")
+        tf.write(f"  Helios Benchmark Inference Timing Report\n")
+        tf.write(f"  {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
+        tf.write(
+            f"  Prompts: {len(prompts)}  |  Range: {args.prompt_start}:{args.prompt_end}  "
+            f"|  Version: {args.version}\n"
+        )
+        if args.prompt_indices_file:
+            tf.write(f"  Prompt indices file: {args.prompt_indices_file}\n")
+        tf.write(
+            f"  Resolution: {args.width}x{args.height}  |  Seed: {args.seed}  |  "
+            f"GPU: {args.gpu}  |  low_vram: {args.enable_low_vram_mode}\n"
+        )
+        tf.write(f"{'=' * 80}\n\n")
+
+        tf.write(
+            f"\n{'=' * 60}\n"
+            f"  Version: {args.version}  |  Model: {preset['model_dir']}\n"
+            f"  Frames: {preset['num_frames']}  |  guidance_scale: {preset['guidance_scale']}\n"
+            f"  stage2: {preset['is_enable_stage2']}  |  pyramid_steps: {preset['pyramid_num_inference_steps_list']}\n"
+            f"{'=' * 60}\n"
+        )
+        tf.write(
+            f"  Existing timing records: {len(timing_records)} / expected outputs: {len(expected_outputs)}\n"
+        )
+
+        for idx in sorted(timing_records):
+            elapsed, slug = timing_records[idx]
+            tf.write(make_timing_line(args.version, idx, elapsed, slug) + "\n")
+
+        if all_timings:
+            avg_t = sum(all_timings) / len(all_timings)
+            total_t = sum(all_timings)
+            summary = (
+                f"\n  >> [{args.version}] completed {len(all_timings)} videos  |  "
+                f"avg: {avg_t:.2f}s ({avg_t / 60:.2f}min)  |  "
+                f"total: {total_t:.1f}s ({total_t / 60:.1f}min)\n"
+            )
+        else:
+            summary = f"\n  >> [{args.version}] no timing records available\n"
+        print(summary)
+        tf.write(summary)
+
+        if peak_mem is not None:
+            mem_line = f"  >> [{args.version}] peak GPU memory: {peak_mem:.2f} GB\n"
+            tf.write(mem_line)
+
+        sep = f"\n{'=' * 80}\n"
+        tf.write(sep)
+        tf.write("  FINAL SUMMARY\n")
+        tf.write(f"{'=' * 80}\n")
+        print(sep)
+        print("  FINAL SUMMARY")
+        print(f"{'=' * 80}")
+
+        fmt = "  {ver:12s} | videos: {n:3d} | avg: {avg:8.2f}s ({avgm:5.2f}min) | min: {mn:8.2f}s | max: {mx:8.2f}s | total: {tot:8.1f}s ({totm:5.1f}min)"
+        if all_timings:
+            line = fmt.format(
+                ver=args.version, n=len(all_timings),
+                avg=sum(all_timings) / len(all_timings), avgm=sum(all_timings) / len(all_timings) / 60,
+                mn=min(all_timings), mx=max(all_timings),
+                tot=sum(all_timings), totm=sum(all_timings) / 60,
+            )
+        else:
+            line = f"  {args.version:12s} | N/A (no timing records)"
+        print(line)
+        tf.write(line + "\n")
+
+        tf.write(f"{'=' * 80}\n")
+
+    print(f"{'=' * 80}")
+    print(f"\nTiming report: {timing_file}")
+    print(f"Videos:        {by_prompt_dir}")
+    print(f"               {by_version_dir}")
+
+
+if __name__ == "__main__":
+    main()

Helios/infer_helios.py

@@ -0,0 +1,560 @@
+import importlib
+import os
+
+
+os.environ["HF_ENABLE_PARALLEL_LOADING"] = "yes"
+os.environ["HF_PARALLEL_LOADING_WORKERS"] = "8"
+
+import argparse
+import time
+
+import pandas as pd
+import torch
+import torch.distributed as dist
+from tqdm import tqdm
+
+
+if importlib.util.find_spec("torch_npu") is not None:
+    import torch_npu
+else:
+    torch_npu = None
+
+from helios.diffusers_version.pipeline_helios_diffusers import HeliosPipeline
+from helios.diffusers_version.scheduling_helios_diffusers import HeliosScheduler
+from helios.diffusers_version.transformer_helios_diffusers import HeliosTransformer3DModel
+from helios.modules.helios_kernels import (
+    replace_all_norms_with_flash_norms,
+    replace_rmsnorm_with_fp32,
+    replace_rope_with_flash_rope,
+)
+from helios.utils.utils_base import load_extra_components
+
+from diffusers import ContextParallelConfig
+from diffusers.models import AutoencoderKLWan
+from diffusers.utils import export_to_video, load_image, load_video
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Generate video with model")
+
+    # === Model paths ===
+    parser.add_argument("--base_model_path", type=str, default="BestWishYsh/Helios-Base")
+    parser.add_argument(
+        "--transformer_path",
+        type=str,
+        default="BestWishYsh/Helios-Base",
+    )
+    parser.add_argument(
+        "--lora_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--partial_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument("--output_folder", type=str, default="./output_helios")
+    parser.add_argument("--enable_compile", action="store_true")
+
+    # === Generation parameters ===
+    # environment
+    parser.add_argument(
+        "--sample_type",
+        type=str,
+        default="t2v",
+        choices=["t2v", "i2v", "v2v"],
+    )
+    parser.add_argument(
+        "--weight_dtype",
+        type=str,
+        default="bf16",
+        choices=["bf16", "fp16", "fp32"],
+        help="Data type for model weights.",
+    )
+    parser.add_argument("--seed", type=int, default=42, help="Seed for random number generator.")
+    # base
+    parser.add_argument("--height", type=int, default=384)
+    parser.add_argument("--width", type=int, default=640)
+    parser.add_argument("--num_frames", type=int, default=99)
+    parser.add_argument("--fps", type=int, default=24)
+    parser.add_argument("--num_inference_steps", type=int, default=50)
+    parser.add_argument("--guidance_scale", type=float, default=5.0)
+    # cfg zero
+    parser.add_argument("--use_zero_init", action="store_true")
+    parser.add_argument("--zero_steps", type=int, default=1)
+    # stage 1
+    parser.add_argument("--num_latent_frames_per_chunk", type=int, default=9)
+    # stage 2
+    parser.add_argument("--is_enable_stage2", action="store_true")
+    parser.add_argument("--pyramid_num_inference_steps_list", type=int, nargs="+", default=[20, 20, 20])
+    # stage 3
+    parser.add_argument("--is_skip_first_chunk", action="store_true")
+    parser.add_argument("--is_amplify_first_chunk", action="store_true")
+
+    # === Prompts ===
+    parser.add_argument("--use_interpolate_prompt", action="store_true")
+    parser.add_argument("--interpolation_steps", type=int, default=3)
+    parser.add_argument("--interpolate_time", type=int, default=7)
+    parser.add_argument(
+        "--image_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--image_noise_sigma_min", type=float, default=0.111, help="Balance motion amplitude and visual consistency"
+    )
+    parser.add_argument(
+        "--image_noise_sigma_max", type=float, default=0.135, help="Balance motion amplitude and visual consistency"
+    )
+    parser.add_argument(
+        "--video_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--video_noise_sigma_min", type=float, default=0.111, help="Balance motion amplitude and visual consistency"
+    )
+    parser.add_argument(
+        "--video_noise_sigma_max", type=float, default=0.135, help="Balance motion amplitude and visual consistency"
+    )
+    parser.add_argument(
+        "--prompt",
+        type=str,
+        default="A dynamic time-lapse video showing the rapidly moving scenery from the window of a speeding train. The camera captures various elements such as lush green fields, towering trees, quaint countryside houses, and distant mountain ranges passing by quickly. The train window frames the view, adding a sense of speed and motion as the landscape rushes past. The camera remains static but emphasizes the fast-paced movement outside. The overall atmosphere is serene yet exhilarating, capturing the essence of travel and exploration. Medium shot focusing on the train window and the rushing scenery beyond.",
+    )
+    parser.add_argument(
+        "--negative_prompt",
+        type=str,
+        default="Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards",
+    )
+    parser.add_argument(
+        "--prompt_txt_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--base_image_prompt_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--image_prompt_csv_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--interactive_prompt_csv_path",
+        type=str,
+        default=None,
+    )
+
+    # === Context parallelism ===
+    # Please refer to https://huggingface.co/docs/diffusers/main/en/training/distributed_inference#context-parallelism
+    parser.add_argument("--enable_parallelism", action="store_true")
+    parser.add_argument(
+        "--cp_backend",
+        type=str,
+        choices=["ring", "ulysses", "unified", "ulysses_anything"],
+        default="ulysses",
+        help="Context parallel backend to use.",
+    )
+
+    # === Group-Offloading ===
+    # Please refer to https://huggingface.co/docs/diffusers/main/en/optimization/memory#group-offloading
+    parser.add_argument("--enable_low_vram_mode", action="store_true")
+    parser.add_argument(
+        "--group_offloading_type",
+        type=str,
+        choices=["leaf_level", "block_level"],
+        default="leaf_level",
+        help="Specifies the granularity for group CPU offloading. Choose between 'leaf_level' (individual modules) or 'block_level' (entire blocks).",
+    )
+    parser.add_argument(
+        "--num_blocks_per_group",
+        type=str,
+        default="4",
+        help="The number of blocks to bundle together in each offloading group. Only relevant when using block-level offloading.",
+    )
+
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    assert not (args.enable_low_vram_mode and args.enable_compile), (
+        "enable_low_vram_mode and enable_compile cannot be used together."
+    )
+
+    if args.weight_dtype == "fp32":
+        args.weight_dtype = torch.float32
+    elif args.weight_dtype == "fp16":
+        args.weight_dtype = torch.float16
+    else:
+        args.weight_dtype = torch.bfloat16
+
+    os.makedirs(args.output_folder, exist_ok=True)
+
+    if dist.is_available() and "RANK" in os.environ:
+        if args.cp_backend == "ulysses_anything":
+            dist.init_process_group(backend="cpu:gloo,cuda:nccl")
+        else:
+            dist.init_process_group(backend="nccl")
+        rank = dist.get_rank()
+        device = torch.device("cuda", rank % torch.cuda.device_count())
+        world_size = dist.get_world_size()
+        torch.cuda.set_device(device)
+        assert world_size == 1 or not args.enable_low_vram_mode, "enable_low_vram_mode is only for single GPU."
+    else:
+        rank = 0
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        world_size = 1
+
+    prompt = None
+    image_path = None
+    video_path = None
+    interpolate_time_list = None
+    if args.sample_type == "t2v" and args.prompt is None:
+        prompt = "An extreme close-up of an gray-haired man with a beard in his 60s, he is deep in thought pondering the history of the universe as he sits at a cafe in Paris, his eyes focus on people offscreen as they walk as he sits mostly motionless, he is dressed in a wool coat suit coat with a button-down shirt , he wears a brown beret and glasses and has a very professorial appearance, and the end he offers a subtle closed-mouth smile as if he found the answer to the mystery of life, the lighting is very cinematic with the golden light and the Parisian streets and city in the background, depth of field, cinematic 35mm film."
+    elif args.sample_type == "i2v" and (args.image_path is None and args.prompt is None):
+        image_path = (
+            "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/astronaut.jpg"
+        )
+        prompt = "An astronaut hatching from an egg, on the surface of the moon, the darkness and depth of space realised in the background. High quality, ultrarealistic detail and breath-taking movie-like camera shot."
+    elif args.sample_type == "v2v" and (args.video_path is None and args.prompt is None):
+        video_path = (
+            "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/hiker.mp4"
+        )
+        prompt = "A robot standing on a mountain top. The sun is setting in the background."
+    else:
+        image_path = args.image_path
+        video_path = args.video_path
+        prompt = args.prompt
+
+    transformer = HeliosTransformer3DModel.from_pretrained(
+        args.transformer_path,
+        subfolder="transformer",
+        torch_dtype=args.weight_dtype,
+    )
+    if not args.enable_compile:
+        transformer = replace_rmsnorm_with_fp32(transformer)
+        transformer = replace_all_norms_with_flash_norms(transformer)
+        replace_rope_with_flash_rope()
+    cuda_major = torch.cuda.get_device_capability()[0]
+    if cuda_major >= 9:
+        # H100/H800 (SM90+) with FA3
+        try:
+            transformer.set_attention_backend("_flash_3_hub")
+        except Exception:
+            transformer.set_attention_backend("flash_hub")
+    else:
+        # 4090/A100 etc (SM89+) with FA2
+        transformer.set_attention_backend("flash_hub")
+
+    vae = AutoencoderKLWan.from_pretrained(
+        args.base_model_path,
+        subfolder="vae",
+        torch_dtype=torch.float32,
+    )
+    scheduler = HeliosScheduler.from_pretrained(
+        args.base_model_path,
+        subfolder="scheduler",
+    )
+    pipe = HeliosPipeline.from_pretrained(
+        args.base_model_path,
+        transformer=transformer,
+        vae=vae,
+        scheduler=scheduler,
+        torch_dtype=args.weight_dtype,
+    )
+
+    if args.lora_path is not None:
+        pipe.load_lora_weights(args.lora_path, adapter_name="default")
+        pipe.set_adapters(["default"], adapter_weights=[1.0])
+
+        if args.partial_path is not None:
+            if not hasattr(args, "training_config"):
+                from argparse import Namespace
+
+                args.training_config = Namespace()
+            args.training_config.is_enable_stage1 = True
+            args.training_config.restrict_self_attn = True
+            args.training_config.is_amplify_history = True
+            args.training_config.is_use_gan = True
+            load_extra_components(args, transformer, args.partial_path)
+
+    if args.enable_compile:
+        torch.backends.cudnn.benchmark = True
+        pipe.text_encoder.compile(mode="max-autotune-no-cudagraphs", dynamic=False)
+        pipe.vae.compile(mode="max-autotune-no-cudagraphs", dynamic=False)
+        pipe.transformer.compile(mode="max-autotune-no-cudagraphs", dynamic=False)
+
+    if args.enable_low_vram_mode:
+        pipe.enable_group_offload(
+            onload_device=torch.device("cuda"),
+            offload_device=torch.device("cpu"),
+            offload_type=args.group_offloading_type,
+            num_blocks_per_group=args.num_blocks_per_group if args.group_offloading_type == "block_level" else None,
+            use_stream=True,
+            record_stream=True,
+        )
+    else:
+        pipe = pipe.to(device)
+
+    if world_size > 1 and args.enable_parallelism:
+        if args.cp_backend == "ring":
+            cp_config = ContextParallelConfig(ring_degree=world_size)
+        elif args.cp_backend == "unified":
+            cp_config = ContextParallelConfig(ring_degree=world_size // 2, ulysses_degree=world_size // 2)
+        elif args.cp_backend == "ulysses":
+            cp_config = ContextParallelConfig(ulysses_degree=world_size)
+        elif args.cp_backend == "ulysses_anything":
+            cp_config = ContextParallelConfig(ulysses_degree=world_size, ulysses_anything=True)
+        else:
+            raise ValueError(f"Unsupported cp_backend: {args.cp_backend}")
+
+        pipe.transformer.enable_parallelism(config=cp_config)
+
+    if args.prompt_txt_path is not None:
+        with open(args.prompt_txt_path, "r") as f:
+            prompt_list = [line.strip() for line in f.readlines() if line.strip()]
+        if not args.enable_parallelism:
+            prompt_list_with_idx = [(i, prompt) for i, prompt in enumerate(prompt_list)]
+            prompt_list_with_idx = prompt_list_with_idx[rank::world_size]
+        else:
+            prompt_list_with_idx = [(i, prompt) for i, prompt in enumerate(prompt_list)]
+
+        for idx, prompt in tqdm(prompt_list_with_idx, desc="Processing prompts"):
+            output_path = os.path.join(args.output_folder, f"{idx}.mp4")
+            if os.path.exists(output_path):
+                print("skipping!")
+                continue
+
+            with torch.no_grad():
+                try:
+                    output = pipe(
+                        prompt=prompt,
+                        negative_prompt=args.negative_prompt,
+                        height=args.height,
+                        width=args.width,
+                        num_frames=args.num_frames,
+                        num_inference_steps=args.num_inference_steps,
+                        guidance_scale=args.guidance_scale,
+                        generator=torch.Generator(device="cuda").manual_seed(args.seed),
+                        # stage 1
+                        history_sizes=[16, 2, 1],
+                        num_latent_frames_per_chunk=args.num_latent_frames_per_chunk,
+                        keep_first_frame=True,
+                        # stage 2
+                        is_enable_stage2=args.is_enable_stage2,
+                        pyramid_num_inference_steps_list=args.pyramid_num_inference_steps_list,
+                        # stage 3
+                        is_skip_first_chunk=args.is_skip_first_chunk,
+                        is_amplify_first_chunk=args.is_amplify_first_chunk,
+                        # cfg zero
+                        use_zero_init=args.use_zero_init,
+                        zero_steps=args.zero_steps,
+                        # i2v
+                        image=load_image(image_path).resize((args.width, args.height))
+                        if image_path is not None
+                        else None,
+                        image_noise_sigma_min=args.image_noise_sigma_min,
+                        image_noise_sigma_max=args.image_noise_sigma_max,
+                        # v2v
+                        video=load_video(video_path) if video_path is not None else None,
+                        video_noise_sigma_min=args.video_noise_sigma_min,
+                        video_noise_sigma_max=args.video_noise_sigma_max,
+                        # interpolate_prompt
+                        use_interpolate_prompt=args.use_interpolate_prompt,
+                        interpolation_steps=args.interpolation_steps,
+                        interpolate_time_list=interpolate_time_list,
+                    ).frames[0]
+                except Exception:
+                    continue
+            if not args.enable_parallelism or rank == 0:
+                export_to_video(output, output_path, fps=24)
+    elif args.image_prompt_csv_path is not None:
+        df = pd.read_csv(args.image_prompt_csv_path)
+        if not args.enable_parallelism:
+            df = df.iloc[rank::world_size]
+
+        for idx, row in tqdm(df.iterrows(), total=len(df), desc="Processing prompts"):
+            # output_path = os.path.join(args.output_folder, f"{idx}.mp4")
+            output_path = os.path.join(args.output_folder, f"{row['id']}.mp4")
+            if os.path.exists(output_path):
+                print("skipping!")
+                continue
+
+            prompt = row.get("refined_prompt") or row["prompt"]
+            image_path = os.path.join(args.base_image_prompt_path, row["image_name"])
+
+            with torch.no_grad():
+                try:
+                    output = pipe(
+                        prompt=prompt,
+                        negative_prompt=args.negative_prompt,
+                        height=args.height,
+                        width=args.width,
+                        num_frames=args.num_frames,
+                        num_inference_steps=args.num_inference_steps,
+                        guidance_scale=args.guidance_scale,
+                        generator=torch.Generator(device="cuda").manual_seed(args.seed),
+                        # stage 1
+                        history_sizes=[16, 2, 1],
+                        num_latent_frames_per_chunk=args.num_latent_frames_per_chunk,
+                        keep_first_frame=True,
+                        # stage 2
+                        is_enable_stage2=args.is_enable_stage2,
+                        pyramid_num_inference_steps_list=args.pyramid_num_inference_steps_list,
+                        # stage 3
+                        is_skip_first_chunk=args.is_skip_first_chunk,
+                        is_amplify_first_chunk=args.is_amplify_first_chunk,
+                        # cfg zero
+                        use_zero_init=args.use_zero_init,
+                        zero_steps=args.zero_steps,
+                        # i2v
+                        image=load_image(image_path).resize((args.width, args.height))
+                        if image_path is not None
+                        else None,
+                        image_noise_sigma_min=args.image_noise_sigma_min,
+                        image_noise_sigma_max=args.image_noise_sigma_max,
+                        # v2v
+                        video=load_video(video_path) if video_path is not None else None,
+                        video_noise_sigma_min=args.video_noise_sigma_min,
+                        video_noise_sigma_max=args.video_noise_sigma_max,
+                        # interpolate_prompt
+                        use_interpolate_prompt=args.use_interpolate_prompt,
+                        interpolation_steps=args.interpolation_steps,
+                        interpolate_time_list=interpolate_time_list,
+                    ).frames[0]
+                except Exception:
+                    continue
+            if not args.enable_parallelism or rank == 0:
+                export_to_video(output, output_path, fps=24)
+    elif args.interactive_prompt_csv_path is not None:
+        df = pd.read_csv(args.interactive_prompt_csv_path)
+
+        df = df.sort_values(by=["id", "prompt_index"])
+        all_video_ids = df["id"].unique()
+
+        if not args.enable_parallelism:
+            my_video_ids = all_video_ids[rank::world_size]
+        else:
+            my_video_ids = all_video_ids
+
+        for video_id in tqdm(my_video_ids, desc="Processing prompts"):
+            output_path = os.path.join(args.output_folder, f"{video_id}.mp4")
+
+            if os.path.exists(output_path):
+                print(f"skipping {output_path}!")
+                continue
+
+            group_df = df[df["id"] == video_id]
+
+            if "refined_prompt" in df.columns:
+                prompt_list = group_df["refined_prompt"].fillna(group_df["prompt"]).tolist()
+            else:
+                prompt_list = group_df["prompt"].tolist()
+            interpolate_time_list = [args.interpolate_time] * len(prompt_list)
+
+            with torch.no_grad():
+                try:
+                    output = pipe(
+                        prompt=prompt_list,
+                        negative_prompt=args.negative_prompt,
+                        height=args.height,
+                        width=args.width,
+                        num_frames=args.num_frames,
+                        num_inference_steps=args.num_inference_steps,
+                        guidance_scale=args.guidance_scale,
+                        generator=torch.Generator(device="cuda").manual_seed(args.seed),
+                        # stage 1
+                        history_sizes=[16, 2, 1],
+                        num_latent_frames_per_chunk=args.num_latent_frames_per_chunk,
+                        keep_first_frame=True,
+                        # stage 2
+                        is_enable_stage2=args.is_enable_stage2,
+                        pyramid_num_inference_steps_list=args.pyramid_num_inference_steps_list,
+                        # stage 3
+                        is_skip_first_chunk=args.is_skip_first_chunk,
+                        is_amplify_first_chunk=args.is_amplify_first_chunk,
+                        # cfg zero
+                        use_zero_init=args.use_zero_init,
+                        zero_steps=args.zero_steps,
+                        # i2v
+                        image=load_image(image_path).resize((args.width, args.height))
+                        if image_path is not None
+                        else None,
+                        image_noise_sigma_min=args.image_noise_sigma_min,
+                        image_noise_sigma_max=args.image_noise_sigma_max,
+                        # v2v
+                        video=load_video(video_path) if video_path is not None else None,
+                        video_noise_sigma_min=args.video_noise_sigma_min,
+                        video_noise_sigma_max=args.video_noise_sigma_max,
+                        # interpolate_prompt
+                        use_interpolate_prompt=args.use_interpolate_prompt,
+                        interpolation_steps=args.interpolation_steps,
+                        interpolate_time_list=interpolate_time_list,
+                    ).frames[0]
+                except Exception:
+                    continue
+            if not args.enable_parallelism or rank == 0:
+                export_to_video(output, output_path, fps=24)
+    else:
+        with torch.no_grad():
+            # import time
+            # for _ in range(20):
+            #     start_time = time.time()
+            output = pipe(
+                prompt=prompt,
+                negative_prompt=args.negative_prompt,
+                height=args.height,
+                width=args.width,
+                num_frames=args.num_frames,
+                num_inference_steps=args.num_inference_steps,
+                guidance_scale=args.guidance_scale,
+                generator=torch.Generator(device="cuda").manual_seed(args.seed),
+                # stage 1
+                history_sizes=[16, 2, 1],
+                num_latent_frames_per_chunk=args.num_latent_frames_per_chunk,
+                keep_first_frame=True,
+                # stage 2
+                is_enable_stage2=args.is_enable_stage2,
+                pyramid_num_inference_steps_list=args.pyramid_num_inference_steps_list,
+                # stage 3
+                is_skip_first_chunk=args.is_skip_first_chunk,
+                is_amplify_first_chunk=args.is_amplify_first_chunk,
+                # cfg zero
+                use_zero_init=args.use_zero_init,
+                zero_steps=args.zero_steps,
+                # i2v
+                image=load_image(image_path).resize((args.width, args.height)) if image_path is not None else None,
+                image_noise_sigma_min=args.image_noise_sigma_min,
+                image_noise_sigma_max=args.image_noise_sigma_max,
+                # v2v
+                video=load_video(video_path) if video_path is not None else None,
+                video_noise_sigma_min=args.video_noise_sigma_min,
+                video_noise_sigma_max=args.video_noise_sigma_max,
+                # interpolate_prompt
+                use_interpolate_prompt=args.use_interpolate_prompt,
+                interpolation_steps=args.interpolation_steps,
+                interpolate_time_list=interpolate_time_list,
+            ).frames[0]
+            # elapsed_time = time.time() - start_time
+            # print(f"Inference time: {elapsed_time:.2f} seconds ({elapsed_time/60:.2f} minutes)")
+
+        if not args.enable_parallelism or rank == 0:
+            file_count = len(
+                [f for f in os.listdir(args.output_folder) if os.path.isfile(os.path.join(args.output_folder, f))]
+            )
+            output_path = os.path.join(
+                args.output_folder, f"{file_count:04d}_{args.sample_type}_{int(time.time())}.mp4"
+            )
+            export_to_video(output, output_path, fps=24)
+
+    print(f"Max memory: {torch.cuda.max_memory_allocated() / 1024**3:.3f} GB")
+
+
+if __name__ == "__main__":
+    main()

Helios/install.sh

@@ -0,0 +1,10 @@
+pip install -r requirements.txt
+
+rm -rf ~/.triton/cache/
+rm -rf /tmp/torchinductor_*
+
+pip uninstall triton torchao xformers wandb tensorflow tensorflow-cpu -y
+pip install wandb==0.23.0 triton==3.6.0
+
+rm -rf ~/.triton/cache/
+rm -rf /tmp/torchinductor_*

Helios/requirements.txt

@@ -0,0 +1,35 @@
+torch==2.10.0
+torchvision==0.25.0
+torchaudio==2.10.0
+triton==3.6.0
+kernels==0.13.0
+# diffusers==0.36.0
+# transformers==4.57.6
+git+https://github.com/huggingface/diffusers.git
+transformers==5.3.0
+sentence-transformers==5.2.3
+accelerate==1.12.0
+deepspeed==0.18.4
+peft==0.18.1
+huggingface-hub==1.4.1
+zstandard==0.25.0
+wandb==0.23.0
+video-reader-rs==0.4.1
+numpy<2.0.0
+opencv-python
+gradio
+spaces
+moviepy
+imageio-ffmpeg
+ftfy
+Jinja2
+einops
+nvitop
+packaging
+ninja
+omegaconf
+mpi4py
+hf-doc-builder
+torchdata
+loguru
+tf_keras

Helios/requirements_npu.txt

@@ -0,0 +1,6 @@
+# Please refer to here for installation the latest version: https://github.com/Ascend/pytorch?tab=readme-ov-file#ascend-auxiliary-software
+torch==2.9.0
+torchvision==0.24.0
+torchaudio==2.9.0
+torch_npu==2.9.0
+triton==3.5.1

Helios/run_bench.sh

@@ -0,0 +1,275 @@
+#!/bin/bash
+# =============================================================================
+#  Helios Benchmark Inference Runner
+#  用法: bash run_bench.sh [--gpus 5 6 7] [--prompt_range 0-50] [--num_frames 240]
+#                         [--version base] [--version mid distilled]
+#  默认使用所有可见 GPU；默认跑全部版本（base/mid/distilled），也可手动指定版本
+#  同一时刻只跑一个版本；若有多张卡，会先扫描输出目录，只把缺失 case 均分到多张卡并行
+#  低显存: LOW_VRAM=1 bash run_bench.sh
+# =============================================================================
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+if [[ -n "${PYTHON:-}" ]]; then
+    PYTHON_BIN="${PYTHON}"
+elif command -v python3 >/dev/null 2>&1; then
+    PYTHON_BIN="$(command -v python3)"
+elif command -v python >/dev/null 2>&1; then
+    PYTHON_BIN="$(command -v python)"
+else
+    echo "Python interpreter not found. Set PYTHON=/path/to/python." >&2
+    exit 1
+fi
+
+GPUS=()
+PROMPT_START="${PROMPT_START:-0}"
+PROMPT_END="${PROMPT_END:-100}"
+NUM_FRAMES="${NUM_FRAMES:-}"
+VERSIONS=(base mid distilled)
+OUTPUT_ROOT="${OUTPUT_ROOT:-}"
+PROMPT_FILE="${PROMPT_FILE:-${SCRIPT_DIR}/demo_data/MovieGenVideoBench_extended.txt}"
+LOW_VRAM="${LOW_VRAM:-0}"
+
+discover_gpus() {
+    if ! command -v nvidia-smi >/dev/null 2>&1; then
+        echo "nvidia-smi not found; use --gpus to specify GPU ids explicitly." >&2
+        exit 1
+    fi
+
+    mapfile -t GPUS < <(nvidia-smi --query-gpu=index --format=csv,noheader,nounits)
+    if [[ ${#GPUS[@]} -eq 0 ]]; then
+        echo "No GPUs found." >&2
+        exit 1
+    fi
+}
+
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --gpus)        shift; GPUS=(); while [[ $# -gt 0 && ! "$1" =~ ^-- ]]; do GPUS+=("$1"); shift; done ;;
+        --prompt_range)
+            if [[ ! "$2" =~ ^([0-9]+)-([0-9]+)$ ]]; then
+                echo "Invalid --prompt_range: $2 (expected START-END, e.g. 0-50)" >&2
+                exit 1
+            fi
+            PROMPT_START="${BASH_REMATCH[1]}"
+            PROMPT_END="${BASH_REMATCH[2]}"
+            shift 2
+            ;;
+        --prompt_start) PROMPT_START="$2"; shift 2 ;;
+        --prompt_end)   PROMPT_END="$2"; shift 2 ;;
+        --num_frames)  NUM_FRAMES="$2";  shift 2 ;;
+        --version)     shift; VERSIONS=(); while [[ $# -gt 0 && ! "$1" =~ ^-- ]]; do VERSIONS+=("$1"); shift; done ;;
+        --output_root) OUTPUT_ROOT="$2"; shift 2 ;;
+        --prompt_file) PROMPT_FILE="$2"; shift 2 ;;
+        *) echo "Unknown option: $1"; exit 1 ;;
+    esac
+done
+
+if [[ ${#GPUS[@]} -eq 0 ]]; then
+    discover_gpus
+fi
+
+if [[ ${#VERSIONS[@]} -eq 0 ]]; then
+    echo "No versions specified. Use --version base [mid distilled]." >&2
+    exit 1
+fi
+
+if [[ ! "${PROMPT_START}" =~ ^[0-9]+$ ]] || [[ ! "${PROMPT_END}" =~ ^[0-9]+$ ]]; then
+    echo "prompt_start and prompt_end must be non-negative integers." >&2
+    exit 1
+fi
+
+if (( PROMPT_END <= PROMPT_START )); then
+    echo "prompt_end must be greater than prompt_start." >&2
+    exit 1
+fi
+
+if [[ -z "${OUTPUT_ROOT}" ]]; then
+    if [[ -n "${NUM_FRAMES}" ]]; then
+        OUTPUT_ROOT="${SCRIPT_DIR}/outputs/num_frames_${NUM_FRAMES}"
+    else
+        OUTPUT_ROOT="${SCRIPT_DIR}/outputs/num_frames_default"
+    fi
+fi
+
+echo "============================================================"
+echo "  Helios Benchmark Inference"
+echo "  $(date '+%Y-%m-%d %H:%M:%S')"
+echo "  Python: ${PYTHON_BIN}"
+echo "  GPUs: ${GPUS[*]}  |  Prompt range: ${PROMPT_START}-${PROMPT_END}  |  Versions: ${VERSIONS[*]}"
+[[ -n "${NUM_FRAMES}" ]] && echo "  Frames: ${NUM_FRAMES}"
+echo "  Prompt file: ${PROMPT_FILE}"
+echo "  Output: ${OUTPUT_ROOT}"
+echo "============================================================"
+
+mkdir -p "${OUTPUT_ROOT}"
+
+if [[ ! -f "${PROMPT_FILE}" ]]; then
+    echo "Prompt file not found: ${PROMPT_FILE}" >&2
+    exit 1
+fi
+
+TOTAL_PROMPTS=$(awk 'NF {count++} END {print count + 0}' "${PROMPT_FILE}")
+if (( PROMPT_START >= TOTAL_PROMPTS )); then
+    echo "prompt_start (${PROMPT_START}) is out of range; prompt file has ${TOTAL_PROMPTS} non-empty prompts." >&2
+    exit 1
+fi
+
+if (( PROMPT_END > TOTAL_PROMPTS )); then
+    echo "prompt_end (${PROMPT_END}) exceeds total prompts (${TOTAL_PROMPTS}); clamping to ${TOTAL_PROMPTS}."
+    PROMPT_END="${TOTAL_PROMPTS}"
+fi
+
+EXTRA=()
+if [[ "${LOW_VRAM}" == "1" ]]; then
+    EXTRA+=(--enable_low_vram_mode)
+fi
+if [[ -n "${NUM_FRAMES}" ]]; then
+    EXTRA+=(--num_frames "${NUM_FRAMES}")
+fi
+
+EXIT_CODE=0
+WORKER_PIDS=()
+WORKER_GPUS=()
+WORKER_SHARDS=()
+
+prepare_missing_shards() {
+    local version="$1"
+    local shard_dir="${OUTPUT_ROOT}/shards/${version}_${PROMPT_START}_${PROMPT_END}_$$"
+    mkdir -p "${shard_dir}"
+
+    "${PYTHON_BIN}" - \
+        "${PROMPT_FILE}" \
+        "${OUTPUT_ROOT}" \
+        "${version}" \
+        "${PROMPT_START}" \
+        "${PROMPT_END}" \
+        "${#GPUS[@]}" \
+        "${shard_dir}" <<'PY'
+import os
+import re
+import sys
+from pathlib import Path
+
+prompt_file = Path(sys.argv[1])
+output_root = Path(sys.argv[2])
+version = sys.argv[3]
+prompt_start = int(sys.argv[4])
+prompt_end = int(sys.argv[5])
+gpu_count = int(sys.argv[6])
+shard_dir = Path(sys.argv[7])
+
+with prompt_file.open("r", encoding="utf-8") as f:
+    prompts = [line.strip() for line in f if line.strip()]
+
+def sanitize_filename(text, max_len=80):
+    text = text.strip().lower()
+    text = re.sub(r"[^a-z0-9]+", "_", text)
+    text = text.strip("_")
+    return text[:max_len]
+
+missing = []
+existing = 0
+version_dir = output_root / "by_version" / version
+for idx in range(prompt_start, prompt_end):
+    slug = sanitize_filename(prompts[idx])
+    video_path = version_dir / f"{idx:04d}_{slug}.mp4"
+    if video_path.is_file() and video_path.stat().st_size > 0:
+        existing += 1
+    else:
+        missing.append(idx)
+
+print(
+    f"[scan] version={version} range={prompt_start}-{prompt_end} "
+    f"existing={existing} missing={len(missing)} output={version_dir}",
+    file=sys.stderr,
+)
+
+if not missing:
+    sys.exit(0)
+
+active_workers = min(gpu_count, len(missing))
+base_chunk = len(missing) // active_workers
+remainder = len(missing) % active_workers
+offset = 0
+
+for shard_idx in range(active_workers):
+    shard_size = base_chunk + (1 if shard_idx < remainder else 0)
+    shard_indices = missing[offset:offset + shard_size]
+    offset += shard_size
+    shard_path = shard_dir / f"shard_{shard_idx:02d}.txt"
+    shard_path.write_text(
+        "".join(f"{idx}\n" for idx in shard_indices),
+        encoding="utf-8",
+    )
+    print(shard_path)
+    print(
+        f"[shard] version={version} shard={shard_idx} count={len(shard_indices)} "
+        f"indices={shard_indices[0]}-{shard_indices[-1]} file={shard_path}",
+        file=sys.stderr,
+    )
+PY
+}
+
+launch_job() {
+    local version="$1"
+    local gpu="$2"
+    local shard_file="$3"
+    local shard_id
+    shard_id="$(basename "${shard_file}" .txt)"
+    local timing_file="${OUTPUT_ROOT}/timing_${version}_${shard_id}.txt"
+
+    echo "[launch] version=${version} gpu=${gpu} shard=${shard_id} indices=${shard_file} output=${OUTPUT_ROOT}"
+    "${PYTHON_BIN}" "${SCRIPT_DIR}/bench_infer.py" \
+        --prompt_file  "${PROMPT_FILE}" \
+        --prompt_start "${PROMPT_START}" \
+        --prompt_end   "${PROMPT_END}" \
+        --prompt_indices_file "${shard_file}" \
+        --output_root  "${OUTPUT_ROOT}" \
+        --timing_file  "${timing_file}" \
+        --version      "${version}" \
+        --gpu          "${gpu}" \
+        "${EXTRA[@]}" &
+
+    WORKER_PIDS+=("$!")
+    WORKER_GPUS+=("${gpu}")
+    WORKER_SHARDS+=("${shard_id}")
+}
+
+wait_for_current_version() {
+    local version="$1"
+    for idx in "${!WORKER_PIDS[@]}"; do
+        local pid="${WORKER_PIDS[$idx]}"
+        local gpu="${WORKER_GPUS[$idx]}"
+        local shard_id="${WORKER_SHARDS[$idx]}"
+        if wait "${pid}"; then
+            echo "[done] ${version} finished on gpu=${gpu} shard=${shard_id}"
+        else
+            echo "[fail] ${version} failed on gpu=${gpu} shard=${shard_id}"
+            EXIT_CODE=1
+        fi
+    done
+    WORKER_PIDS=()
+    WORKER_GPUS=()
+    WORKER_SHARDS=()
+}
+
+for version in "${VERSIONS[@]}"; do
+    echo ""
+    echo "-------------------- version=${version} --------------------"
+    mapfile -t SHARD_FILES < <(prepare_missing_shards "${version}")
+    if (( ${#SHARD_FILES[@]} == 0 )); then
+        echo "[skip] version=${version} has no missing cases in ${PROMPT_START}-${PROMPT_END}"
+        continue
+    fi
+
+    for worker_idx in "${!SHARD_FILES[@]}"; do
+        launch_job "${version}" "${GPUS[$worker_idx]}" "${SHARD_FILES[$worker_idx]}"
+    done
+    wait_for_current_version "${version}"
+done
+
+echo ""
+echo "Done. Per-shard timing reports are under ${OUTPUT_ROOT}/timing_<version>_shard_<id>.txt"
+
+exit ${EXIT_CODE:-0}

Helios/temp.sh

@@ -0,0 +1,12 @@
+for i in $(seq 1 10000); do
+    CUDA_VISIBLE_DEVICES=0 python infer_helios.py \
+        --base_model_path "./checkpoints/Helios-Base" \
+        --transformer_path "./checkpoints/Helios-Base" \
+        --sample_type "t2v" \
+        --num_frames 99 \
+        --fps 24 \
+        --prompt "A woman dancing." \
+        --guidance_scale 5.0 \
+        --enable_compile \
+        --output_folder "./temp/run_${i}"
+done