[evidence]: RL (DiffusionNFT) + VideoAlign + dataloader gates PASS — goldens, ledger, report

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

.gitignore

@@ -1,17 +1,12 @@
-ucf101_stride4x4x4
 __pycache__
-*.mp4
 .ipynb_checkpoints
 *.pth
 UCF-101/
 results/
-build/
-fastvideo.egg-info/
 wandb/
-.idea
 *.ipynb
 *.jpg
-*.mp3
+!examples/dataset/lingbotworld2/image.jpg
 *.safetensors
 *.mp4
 *.png
@@ -20,35 +15,123 @@ wandb/
 *.pt
 cache_dir/
 wandb/
-test*
-sample_video*
-sample_image*
-512*
-720*
-1024*
-debug*
-private*
-caption*
-*deepspeed*
-revised*
-129f*
-all*
-read*
-YSH*
-*pick*
-*ysh*
-hw*
-257f*
-513f*
-taming*
-221hw*
-65x512x512
+venv/
+.venv/
 runs/
 samples/
+Miniconda3-latest-Linux-x86_64.sh
 *validation/
 data/
 outputs/
 outputs_video
+checkpoints/
 sbatch.sh
 *.out
 env
+*.o
+**/build/
+**.pyc
+**.txt
+*.log
+weights/
+logs/
+/Z-Image/
+official_weights/
+converted_weights/
+
+# SSIM test outputs
+fastvideo/tests/ssim/generated_videos/
+**/.cache/**
+
+
+# Distribution / packaging
+build/
+dist/
+*.egg-info/
+*.egg
+eggs/
+.eggs/
+
+# MkDocs documentation
+site/
+docs/getting_started/examples/
+docs/examples/
+docs/inference/examples/
+docs/training/examples/
+docs/distillation/examples/
+!requirements-mkdocs.txt
+
+# VSCode
+.vscode/
+
+# DS Store
+.DS_Store
+
+# vim swap files
+*.swo
+*.swp
+
+# Python pickle files
+*.pkl
+
+# Reference videos (negations must come after the catch-all on line below)
+
+# Static images
+!docs/assets/images/**/*.png
+!comfyui/assets/**/*.png
+!comfyui/assets/**/*.gif
+!assets/images/**/*.png
+!assets/images/**/*.jpg
+!assets/images/**/*.jpeg
+!assets/images/**/*.gif
+!assets/videos/**/*.mp4
+
+dmd_t2v_output/
+preprocess_output_text/
+
+# SvelteKit / Node artifacts under apps/fastvideo_studio/: see apps/fastvideo_studio/.gitignore
+
+# Next.js / Node artifacts under apps/dreamverse/web/
+apps/dreamverse/web/node_modules/
+apps/dreamverse/web/.next/
+apps/dreamverse/web/out/
+apps/dreamverse/web/coverage/
+apps/dreamverse/web/test-results/
+apps/dreamverse/web/playwright-report/
+apps/dreamverse/web/.env.local
+apps/dreamverse/web/.env.development.local
+apps/dreamverse/web/.env.test.local
+
+# Generated by apps/dreamverse/scripts/install_native_ffmpeg.sh — host-specific
+apps/dreamverse/scripts/ffmpeg-env.sh
+apps/dreamverse/web/.env.production.local
+
+# Unignore migrated Dreamverse product assets — root .gitignore globally
+# ignores *.png/*.jpg/*.mp4/*.gif, but apps/dreamverse/web/public/ MUST
+# be tracked (logo, icons, k2.png, etc.).
+!apps/dreamverse/web/public/**/*.png
+!apps/dreamverse/web/public/**/*.jpg
+!apps/dreamverse/web/public/**/*.jpeg
+!apps/dreamverse/web/public/**/*.mp4
+!apps/dreamverse/web/public/**/*.gif
+!apps/dreamverse/web/prompts/**/*.png
+!apps/dreamverse/web/prompts/**/*.jpg
+!apps/dreamverse/web/prompts/**/*.jpeg
+!apps/dreamverse/web/prompts/**/*.mp4
+!apps/dreamverse/web/prompts/**/*.gif
+!apps/dreamverse/gpu-pool.svg
+!apps/dreamverse/gpu-pool.drawio
+
+.claude/
+.codex/
+.agents/tmp/
+.sisyphus/
+openspec/
+fastvideo/tests/ssim/reference_videos/**
+!fastvideo/tests/ssim/reference_videos/**/*.mp4
+!fastvideo/tests/ssim/reference_videos/**/*.png
+
+# Editor logs and local Python version pins (accidentally committed)
+*.nvimlog
+.nvimlog
+.python-version

.pre-commit-config.yaml

@@ -0,0 +1,10 @@
+# fastvideo2/rl_rewards is vendored byte-identical from upstream (gated by
+# sha256 in tests) — formatters must not touch it
+exclude: ^fastvideo2/rl_rewards/
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-merge-conflict

AGENTS.md

@@ -0,0 +1,89 @@
+# Repository guidelines (branch `will/v2.1`)
+
+This branch is the fastvideo2 MVP — one package, one model (Wan2.1), four
+surfaces. Read `README.md` first.
+
+## Layout
+
+| Path | Role |
+|---|---|
+| `fastvideo2/card.py` | Frozen data cards, `derive()`, digest, validation (stdlib-only) |
+| `fastvideo2/loop.py` | Driven-loop protocol + `LoopRunner` (stdlib; NVTX lazily) |
+| `fastvideo2/pipeline.py` | Stage list with enforced `reads`/`writes` (stdlib-only) |
+| `fastvideo2/loading.py` | Checkpoint → modules, standalone; component fingerprints |
+| `fastvideo2/layers/` | Shared model layers (norms, MLP, rotary, attention) — torch-only, checkpoint-key compatible, cast semantics preserved (anchor-proven) |
+| `fastvideo2/engine.py` | One-shot runner: request → outputs + identity-chained trace |
+| `fastvideo2/verify.py` | Gates T0–T3 + evidence ledger |
+| `fastvideo2/registry.py` | The only catalog: name → (card, pipeline builder) |
+| `fastvideo2/wan21/` | The family's logic: card constant, loop, pipeline, vendored `model.py`, `reference.py` (the executable spec) |
+| `fastvideo2/wan21/gates/` | The family's measurement side: goldens, anchor adapters, official capture shim, comparison CLI, diagnostics — never imported by logic code |
+| `fastvideo2/evidence/` | Append-only ledger + blessed baselines (see its README) |
+| `fastvideo2/tests/` | T0 contract tests — CPU, no torch, no weights |
+
+## Invariants (enforced by review; violating them is the bug)
+
+1. **Cards are pure data.** No callables, no live objects, no deploy-local
+   paths. If it can't round-trip through JSON, it doesn't belong on a card.
+2. **Import direction is one-way:** `card` → `loop`/`pipeline` → `engine` →
+   `verify`. Family packages depend on core, never the reverse.
+   `wan21/reference.py` imports only the vendored official model file
+   (`wan21/model.py`, itself standalone) — never core/runtime modules — and
+   nothing outside `verify.py` may import the reference.
+3. **Loop modules import torch-free** (torch inside methods) so contracts
+   validate anywhere; `import fastvideo2` must work without torch installed.
+4. **Model-specific inputs are typed** (`WanForwardInputs`); never add an
+   untyped passthrough kwarg to a forward call.
+5. **Evidence is append-only and human-owned.** Agents run `verify` and commit
+   the records; agents do not edit tolerances, re-bless baselines, or touch
+   `reference.py` to make a failing gate pass — say so instead.
+6. **One catalog.** New servable ⇒ card constant + registry entry. No parallel
+   model lists.
+7. **Official implementations are the numerics authority.** Where fidelity is
+   the requirement, run the authors' modeling code: the Wan DiT is vendored
+   from the pinned official commit (`wan21/model.py`, provenance in its
+   header). Restructuring vendored code (e.g. extracting `layers/`) is
+   allowed ONLY when the anchor stays bitwise 0.0 — the gate, not "verbatim",
+   is the equivalence guarantee. Two invariants for any extraction:
+   checkpoint keys unchanged (Sequential indices preserved) and cast/dtype
+   semantics unchanged (fp32 islands, promotion order, fp64 RoPE). Ports
+   (diffusers, etc.) may serve components only with anchor certification,
+   never on trust; the official repo never becomes a dependency or submodule;
+   when conventions conflict, official wins.
+8. **One environment for goldens and gates.** The supported env is python 3.12
+   + torch 2.12 (the fastvideo cluster venv). Goldens are captured with that
+   same env — official code rides `PYTHONPATH`, its extra deps go to a pip
+   `--target` dir — so anchor deltas measure implementation differences, never
+   torch/kernel version differences.
+
+## Commands
+
+```bash
+pytest                                             # T0, runs on a laptop
+python -m fastvideo2 verify <model> --tier N       # gates; appends evidence
+python -m fastvideo2 describe <model>              # card JSON + digest
+python -m fastvideo2 generate <model> --prompt ... # one request
+```
+
+GPU work runs on dlcluster via the `run-fastvideo-dlcluster` skill from the
+main FastVideo checkout (sync this branch with `git push origin HEAD`, then
+run inside the branch clone at `/mnt/fv21` — do not disturb `/mnt/FastVideo`'s
+checkout). One-time per environment, install the package editable with no
+dependency changes (torch etc. already live in the venv) — after this,
+scripts and `fastvideo2 <cmd>` work from any directory, no PYTHONPATH:
+
+```bash
+/mnt/FastVideo/.venv/bin/pip install -e /mnt/fv21 --no-deps -q
+```
+
+Cluster runs append to `fastvideo2/evidence/` and those files get
+fetched and committed locally, so before every cluster `git pull`, reset that
+tree or the pull conflicts:
+
+```bash
+git checkout -- fastvideo2/evidence; git clean -qfd fastvideo2/evidence; git pull
+```
+
+## Commit style
+
+Short subject with a tag prefix (`[feat]: ...`, `[fix]: ...`, `[docs]: ...`).
+Do not add AI co-author trailers.

LICENSE

@@ -184,18 +184,4 @@
       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 [2023] Lightning AI
-
-   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.
+      identification within third-party archives.

README.md

@@ -1,162 +1,72 @@
-# FastVideo
+# fastvideo2 — the v2.1 MVP (branch `will/v2.1`)
 
-<div align="center">
-  <a href=""><img src="https://img.shields.io/static/v1?label=API:H100&message=Replicate&color=pink"></a> &ensp;
-  <a href=""><img src="https://img.shields.io/static/v1?label=Discuss&message=Discord&color=purple&logo=discord"></a> &ensp;
-</div>
-<br>
-<div align="center">
-<img src=assets/logo.png width="50%"/>
-</div>
+A from-scratch, deliberately small substrate for the FastVideo big bet:
+**post-training → inference-optimized serving**, designed so that both kinds of
+agents — the ones that *build* the framework and the ones that will *operate*
+video models inside products — get inspectable contracts, a ground-truth
+oracle, machine-readable verification, and an identity-chained runtime.
 
-FastVideo is a scalable framework for post-training video diffusion models, addressing the growing challenges of fine-tuning, distillation, and inference as model sizes and sequence lengths increase. As a first step, it provides an efficient script for distilling and fine-tuning the 10B Mochi model, with plans to expand features and support for more models.
+This branch is a clean slate: everything except `LICENSE` was removed, and the
+MVP supports exactly one model, **Wan2.1-T2V-1.3B**, end to end.
 
-### Features
+## The four surfaces
 
-- FastMochi, a distilled Mochi model that can generate videos with merely 8 sampling steps.
-- Finetuning with FSDP (both master weight and ema weight), sequence parallelism, and selective gradient checkpointing.
-- LoRA coupled with pecomputed the latents and text embedding for minumum memory consumption.
-- Finetuning with both image and videos.
+| Surface | Where | What it guarantees |
+|---|---|---|
+| **Contracts** | `fastvideo2/card.py`, `pipeline.py`, `loop.py` | Cards are frozen *data* (no callables): JSON round-trip, stable content digest — the identity used by deploy configs, trainers, and RL environment manifests alike. Pipeline stage edges (`reads`/`writes`) are enforced at run time. Loop classes carry a `semantics` id and provenance pins it: distilled weights cannot silently run under a base sampler. |
+| **Reference** | `fastvideo2/wan21/reference.py` | The complete model in one standalone eager file — the textbook an agent copies, and the oracle the production path is measured against. Never imported by production code. |
+| **Verifier** | `fastvideo2/verify.py`, `fastvideo2/evidence/` | Tiered gates: T0 contracts (CPU, seconds) → T1 component fingerprints vs a blessed baseline → T2 trajectory parity vs the reference, with tolerance calibrated by measured run-to-run self-noise (the determinism contract) → T3 decoded-output parity + anti-degeneracy anchors. Every run appends typed records (card digest + env fingerprint) to the evidence ledger. |
+| **Trace** | `fastvideo2/engine.py`, `loop.py` | Every unit of work is named `request/stage/loop.step`; the same identity chain lands in the returned trace (typed timings) and in nested NVTX ranges, so Nsight correlates kernels to model-level identity for free. |
 
-## Change Log
-
-
-- ```2024/12/06```: `FastMochi` v0.0.1 is released.
-
-
-## Fast and High-Quality Text-to-video Generation
-
-### 8-Step Results of FastMochi
-
-<table class="center">
-  <td><img src=assets/8steps/1.gif width="320"></td></td>
-  <td><img src=assets/8steps/2.gif width="320"></td></td></td>
-  <tr>
-  <td style="text-align:center;" width="320">tmp</td>
-  <td style="text-align:center;" width="320">tmp</td>
-  <tr>
-</table >
-
-
-## Table of Contents
-
-Jump to a specific section:
-
-- [🔧 Installation](#-installation)
-- [🚀 Inference](#-inference)
-- [🎯 Distill](#-distill)
-- [⚡ Finetune](#-lora-finetune)
-
-
-## 🔧 Installation
-
-```
-conda create -n fastmochi python=3.10.0 -y && conda activate fastmochi
-pip3 install torch==2.5.0 torchvision --index-url https://download.pytorch.org/whl/cu121
-pip install packaging ninja && pip install flash-attn==2.7.0.post2 --no-build-isolation 
-pip install "git+https://github.com/huggingface/diffusers.git@bf64b32652a63a1865a0528a73a13652b201698b"
-git clone https://github.com/hao-ai-lab/FastVideo.git
-cd FastVideo && pip install -e .
-```
-
-
-
-
-## 🚀 Inference
-
-Use [scripts/download_hf.py](scripts/download_hf.py) to download the hugging-face style model to a local directory. Use it like this:
-```bash
-python scripts/download_hf.py --repo_id=FastVideo/FastMochi --local_dir=data/FastMochi --repo_type=model
-```
-
-
-Start the gradio UI with
-```
-python fastvideo/demo/gradio_web_demo.py --model_path data/FastMochi
-```
-
-We also provide CLI inference script featured with sequence parallelism.
-
-```
-export NUM_GPUS=4
-
-torchrun --nnodes=1 --nproc_per_node=$NUM_GPUS \
-    fastvideo/sample/sample_t2v_mochi.py \
-    --model_path data/FastMochi \
-    --prompt_path assets/prompt.txt \
-    --num_frames 163 \
-    --height 480 \
-    --width 848 \
-    --num_inference_steps 8 \
-    --guidance_scale 1.5 \
-    --output_path outputs_video/demo_video \
-    --seed 12345 \
-    --scheduler_type "pcm_linear_quadratic" \
-    --linear_threshold 0.1 \
-    --linear_range 0.75
-```
-
-For the mochi style, simply following the scripts list in mochi repo.
-
-```
-git clone https://github.com/genmoai/mochi.git
-cd mochi
-
-# install env
-...
-
-python3 ./demos/cli.py --model_dir weights/ --cpu_offload
-```
-
-
-## 🎯 Distill
-
-## 💰Hardware requirement
-
--  VRAM is required for both distill 10B mochi model
-
-To launch distillation, you will first need to prepare data in the following formats
+## Quickstart
 
 ```bash
-asset/example_data
-├── AAA.txt
-├── AAA.png
-├── BCC.txt
-├── BCC.png
-├── ......
-├── CCC.txt
-└── CCC.png
+# machine-readable capability discovery
+python -m fastvideo2 describe wan2.1-t2v-1.3b
+
+# contracts only — CPU, no weights, no torch
+python -m fastvideo2 verify wan2.1-t2v-1.3b --tier 0
+pytest                                        # the same contracts, as tests
+
+# GPU: bless the component baseline once, then gate against it
+python -m fastvideo2 verify wan2.1-t2v-1.3b --tier 1 --bless
+python -m fastvideo2 verify wan2.1-t2v-1.3b --tier 3
+
+# generate — CLI or the SDK (the handle is the loaded card, modality-neutral)
+python -m fastvideo2 generate wan2.1-t2v-1.3b --prompt "a cat surfing a wave" --out cat.mp4
+python -c '
+import fastvideo2 as fv2
+model = fv2.load("wan2.1-t2v-1.3b")          # -> Model (capabilities from the card)
+model.generate("a cat surfing a wave", seed=7).save("cat.mp4")'
+
+# the oracle, standalone (this file works copied out of the repo)
+python -m fastvideo2.wan21.reference --prompt "a cat surfing a wave" --out ref.mp4
 ```
 
-We provide a dataset example here. First download testing data. Use [scripts/download_hf.py](scripts/download_hf.py) to download the data to a local directory. Use it like this:
-```bash
-python scripts/download_hf.py --repo_id=Stealths-Video/Merge-425-Data --local_dir=data/Merge-425-Data --repo_type=dataset
-python scripts/download_hf.py --repo_id=Stealths-Video/validation_embeddings --local_dir=data/validation_embeddings --repo_type=dataset
-```
+Weights resolve from the HF cache (`Wan-AI/Wan2.1-T2V-1.3B-Diffusers`) or an
+explicit `--root`; components are stock diffusers/transformers modules, so
+there is no conversion step and `load_component()` works standalone in a REPL.
 
-Then the distillation can be launched by:
+## Design lineage (what this MVP encodes)
 
-```
-bash scripts/distill_t2v.sh
-```
+- **Cards as declared constants; variants as `derive()` diffs** — no builder
+  functions, no factory bags, no toy backends welded into production cards.
+- **The card digest is the axle artifact**: the same identity a deploy config
+  points at, a trainer stamps provenance into, and an RL environment manifest
+  pins (`substitution: exact | bounded | quality-changing` is already on
+  `Provenance` for the post-training flywheel).
+- **Typed conditioning** (`WanForwardInputs`): a new control channel is a new
+  field the forward must consume — never a silently dropped kwarg.
+- **Verification is the product**: gates fail closed, evidence is append-only
+  data, baselines and tolerances are human-owned.
+- **One loop, runtime-visible**: the driven-loop contract is what sessions,
+  interleaved serving, and RL rollout branching will consume next; the engine
+  stays a deliberately dumb one-shot runner until those consumers land.
 
+## Scope and non-goals (MVP)
 
-## ⚡ Lora Finetune
-
-
-## 💰Hardware requirement
-
--  VRAM is required for both distill 10B mochi model
-
-To launch finetuning, you will first need to prepare data in the following formats.
-
-
-
-Then the finetuning can be launched by:
-
-```
-bash scripts/lora_finetune.sh
-```
-
-## Acknowledgement
-We learned from and reused code from the following projects: [PCM](https://github.com/G-U-N/Phased-Consistency-Model), [diffusers](https://github.com/huggingface/diffusers), and [OpenSoraPlan](https://github.com/PKU-YuanGroup/Open-Sora-Plan).
+In: Wan2.1 T2V, bidirectional, single GPU, one-shot generation, tiers T0–T3.
+Out (next, in order): causal/self-forcing students + sessions with forkable
+state, the post-training flywheel emitting derived cards + evidence, the RL
+environment server (`reset/step/branch`) over the same contracts, additional
+model families via `derive()` and new recipe packages.

assets/prompt.txt

@@ -1,9 +0,0 @@
-A hand enters the frame, pulling a sheet of plastic wrap over three balls of dough placed on a wooden surface. The plastic wrap is stretched to cover the dough more securely. The hand adjusts the wrap, ensuring that it is tight and smooth over the dough. The scene focuses on the hand's movements as it secures the edges of the plastic wrap. No new objects appear, and the camera remains stationary, focusing on the action of covering the dough.
-A vintage train snakes through the mountains, its plume of white steam rising dramatically against the jagged peaks. The cars glint in the late afternoon sun, their deep crimson and gold accents lending a touch of elegance. The tracks carve a precarious path along the cliffside, revealing glimpses of a roaring river far below. Inside, passengers peer out the large windows, their faces lit with awe as the landscape unfolds.
-A crowded rooftop bar buzzes with energy, the city skyline twinkling like a field of stars in the background. Strings of fairy lights hang above, casting a warm, golden glow over the scene. Groups of people gather around high tables, their laughter blending with the soft rhythm of live jazz. The aroma of freshly mixed cocktails and charred appetizers wafts through the air, mingling with the cool night breeze.
-En "The Matrix", Neo, interpretado por Keanu Reeves, personifica la lucha contra un sistema opresor a través de su icónica imagen, que incluye unos anteojos oscuros. Estos lentes no son solo un accesorio de moda; representan una barrera entre la realidad y la percepción. Al usar estos anteojos, Neo se sumerge en un mundo donde la verdad se oculta detrás de ilusiones y engaños. La oscuridad de los lentes simboliza la ignorancia y el control que las máquinas tienen sobre la humanidad, mientras que su propia búsqueda de la verdad lo lleva a descubrir sus auténticos poderes. La escena en que se los pone se convierte en un momento crucial, marcando su transformación de un simple programador a "El Elegido". Esta imagen se ha convertido en un ícono cultural, encapsulando el mensaje de que, al enfrentar la oscuridad, podemos encontrar la luz que nos guía hacia la libertad. Así, los anteojos de Neo se convierten en un símbolo de resistencia y autoconocimiento en un mundo manipulado.
-Medium close up. Low-angle shot. A woman in a 1950s retro dress sits in a diner bathed in neon light, surrounded by classic decor and lively chatter. The camera starts with a medium shot of her sitting at the counter, then slowly zooms in as she blows a shiny pink bubblegum bubble. The bubble swells dramatically before popping with a soft, playful burst. The scene is vibrant and nostalgic, evoking the fun and carefree spirit of the 1950s.
-Will Smith eats noodles.
-A short clip of the blonde woman taking a sip from her whiskey glass, her eyes locking with the camera as she smirks playfully. The background shows a group of people laughing and enjoying the party, with vibrant neon signs illuminating the space. The shot is taken in a way that conveys the feeling of a tipsy, carefree night out. The camera then zooms in on her face as she winks, creating a cheeky, flirtatious vibe.
-A superintelligent humanoid robot waking up. The robot has a sleek metallic body with futuristic design features. Its glowing red eyes are the focal point, emanating a sharp, intense light as it powers on. The scene is set in a dimly lit, high-tech laboratory filled with glowing control panels, robotic arms, and holographic screens. The setting emphasizes advanced technology and an atmosphere of mystery. The ambiance is eerie and dramatic, highlighting the moment of awakening and the robot's immense intelligence. Photorealistic style with a cinematic, dark sci-fi aesthetic. Aspect ratio: 16:9 --v 6.1
-A chimpanzee lead vocalist singing into a microphone on stage. The camera zooms in to show him singing. There is a spotlight on him.

examples/README.md

@@ -0,0 +1,10 @@
+# Examples
+
+- `generate_t2v.py` — text-to-video via the SDK (`fv2.load(...)` →
+  `model.generate(...)` → `result.save(...)`). Card defaults, everything
+  overridable by flag. The standalone reference implementation (no SDK, no
+  runtime) lives at `fastvideo2/wan21/reference.py`.
+
+The `--model` flag takes any catalog id — e.g. the 3-step FastWan students
+(`fastwan-qad-fp8-1.3b`, `fastwan-t2v-1.3b`); their step count, sampler, and
+sparsity/quant recipe come from the card, so no other flags change.

examples/generate_t2v.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+"""Text-to-video with the fastvideo2 SDK — the canonical example.
+
+    python examples/generate_t2v.py --prompt "a cat surfing a wave" --out cat.mp4
+
+Loads the card resident once, generates with card defaults (50 steps, 81
+frames, 480x832 — override anything via flags), saves an mp4. Requires a CUDA
+box; weights resolve from the HF cache on first use.
+"""
+from __future__ import annotations
+
+import argparse
+
+import fastvideo2 as fv2
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("--prompt",
+                   default="a golden retriever puppy running through a sprinkler "
+                           "on a sunny lawn, water droplets sparkling, slow motion, cinematic")
+    p.add_argument("--model", default="wan2.1-t2v-1.3b",
+                   help="a model id from the catalog (see `python -m fastvideo2 describe`)")
+    p.add_argument("--out", default="out.mp4")
+    p.add_argument("--seed", type=int, default=42)
+    p.add_argument("--num-steps", dest="num_steps", type=int, default=None,
+                   help="unset -> the card's default")
+    p.add_argument("--num-frames", dest="num_frames", type=int, default=None)
+    p.add_argument("--guidance-scale", dest="guidance_scale", type=float, default=None)
+    args = p.parse_args()
+
+    model = fv2.load(args.model)
+    print(model)
+
+    overrides = {k: getattr(args, k) for k in ("seed", "num_steps", "num_frames", "guidance_scale")
+                 if getattr(args, k) is not None}
+    result = model.generate(args.prompt, **overrides)
+
+    steps = [t for t in result.trace if "/denoise." in t["label"]]
+    print(f"video {result.video.shape} | {len(steps)} denoise steps, "
+          f"{sum(t['seconds'] for t in steps) / max(len(steps), 1):.2f}s/step, "
+          f"{result.seconds:.1f}s total")
+    print(f"saved -> {result.save(args.out)}")
+
+
+if __name__ == "__main__":
+    main()

fastvideo/dataset/__init__.py

@@ -1,111 +0,0 @@
-from transformers import AutoTokenizer
-
-from torchvision import transforms
-from torchvision.transforms import Lambda
-from fastvideo.dataset.t2v_datasets import T2V_dataset
-from fastvideo.dataset.latent_datasets import LatentDataset
-from fastvideo.dataset.transform import (
-    Normalize255,
-    TemporalRandomCrop,
-    CenterCropResizeVideo,
-)
-
-
-def getdataset(args):
-    temporal_sample = TemporalRandomCrop(args.num_frames)  # 16 x
-    norm_fun = Lambda(lambda x: 2.0 * x - 1.0)
-    resize_topcrop = [
-        CenterCropResizeVideo((args.max_height, args.max_width), top_crop=True),
-    ]
-    resize = [
-        CenterCropResizeVideo((args.max_height, args.max_width)),
-    ]
-    transform = transforms.Compose(
-        [
-            # Normalize255(),
-            *resize,
-            # RandomHorizontalFlipVideo(p=0.5),  # in case their caption have position decription
-            # norm_fun
-        ]
-    )
-    transform_topcrop = transforms.Compose(
-        [
-            Normalize255(),
-            *resize_topcrop,
-            # RandomHorizontalFlipVideo(p=0.5),  # in case their caption have position decription
-            norm_fun,
-        ]
-    )
-    # tokenizer = AutoTokenizer.from_pretrained("/storage/ongoing/new/Open-Sora-Plan/cache_dir/mt5-xxl", cache_dir=args.cache_dir)
-    tokenizer = AutoTokenizer.from_pretrained(
-        args.text_encoder_name, cache_dir=args.cache_dir
-    )
-    if args.dataset == "t2v":
-        return T2V_dataset(
-            args,
-            transform=transform,
-            temporal_sample=temporal_sample,
-            tokenizer=tokenizer,
-            transform_topcrop=transform_topcrop,
-        )
-
-    raise NotImplementedError(args.dataset)
-
-
-if __name__ == "__main__":
-    from accelerate import Accelerator
-    from fastvideo.dataset.t2v_datasets import dataset_prog
-    import random
-    from tqdm import tqdm
-
-    args = type(
-        "args",
-        (),
-        {
-            "ae": "CausalVAEModel_4x8x8",
-            "dataset": "t2v",
-            "attention_mode": "xformers",
-            "use_rope": True,
-            "text_max_length": 300,
-            "max_height": 320,
-            "max_width": 240,
-            "num_frames": 1,
-            "use_image_num": 0,
-            "interpolation_scale_t": 1,
-            "interpolation_scale_h": 1,
-            "interpolation_scale_w": 1,
-            "cache_dir": "../cache_dir",
-            "image_data": "/storage/ongoing/new/Open-Sora-Plan-bak/7.14bak/scripts/train_data/image_data.txt",
-            "video_data": "1",
-            "train_fps": 24,
-            "drop_short_ratio": 1.0,
-            "use_img_from_vid": False,
-            "speed_factor": 1.0,
-            "cfg": 0.1,
-            "text_encoder_name": "google/mt5-xxl",
-            "dataloader_num_workers": 10,
-        },
-    )
-    accelerator = Accelerator()
-    dataset = getdataset(args)
-    num = len(dataset_prog.img_cap_list)
-    zero = 0
-    for idx in tqdm(range(num)):
-        image_data = dataset_prog.img_cap_list[idx]
-        caps = [
-            i["cap"] if isinstance(i["cap"], list) else [i["cap"]] for i in image_data
-        ]
-        try:
-            caps = [[random.choice(i)] for i in caps]
-        except Exception as e:
-            print(e)
-            # import ipdb;ipdb.set_trace()
-            print(image_data)
-            zero += 1
-            continue
-        assert caps[0] is not None and len(caps[0]) > 0
-    print(num, zero)
-    import ipdb
-
-    ipdb.set_trace()
-    print("end")

fastvideo/dataset/latent_datasets.py

@@ -1,126 +0,0 @@
-import torch
-from torch.utils.data import Dataset
-import json
-import os
-import random
-
-
-class LatentDataset(Dataset):
-    def __init__(
-        self,
-        json_path,
-        num_latent_t,
-        cfg_rate,
-    ):
-        # data_merge_path: video_dir, latent_dir, prompt_embed_dir, json_path
-        self.json_path = json_path
-        self.cfg_rate = cfg_rate
-        self.datase_dir_path = os.path.dirname(json_path)
-        self.video_dir = os.path.join(self.datase_dir_path, "video")
-        self.latent_dir = os.path.join(self.datase_dir_path, "latent")
-        self.prompt_embed_dir = os.path.join(self.datase_dir_path, "prompt_embed")
-        self.prompt_attention_mask_dir = os.path.join(
-            self.datase_dir_path, "prompt_attention_mask"
-        )
-        with open(self.json_path, "r") as f:
-            self.data_anno = json.load(f)
-        # json.load(f) already keeps the order
-        # self.data_anno = sorted(self.data_anno, key=lambda x: x['latent_path'])
-        self.num_latent_t = num_latent_t
-        # just zero embeddings [256, 4096]
-        self.uncond_prompt_embed = torch.zeros(256, 4096).to(torch.float32)
-        # 256 zeros
-        self.uncond_prompt_mask = torch.zeros(256).bool()
-        self.lengths = [
-            data_item["length"] if "length" in data_item else 1
-            for data_item in self.data_anno
-        ]
-
-    def __getitem__(self, idx):
-        latent_file = self.data_anno[idx]["latent_path"]
-        prompt_embed_file = self.data_anno[idx]["prompt_embed_path"]
-        prompt_attention_mask_file = self.data_anno[idx]["prompt_attention_mask"]
-        # load
-        latent = torch.load(
-            os.path.join(self.latent_dir, latent_file),
-            map_location="cpu",
-            weights_only=True,
-        )
-        latent = latent.squeeze(0)[:, -self.num_latent_t :]
-        if random.random() < self.cfg_rate:
-            prompt_embed = self.uncond_prompt_embed
-            prompt_attention_mask = self.uncond_prompt_mask
-        else:
-            prompt_embed = torch.load(
-                os.path.join(self.prompt_embed_dir, prompt_embed_file),
-                map_location="cpu",
-                weights_only=True,
-            )
-            prompt_attention_mask = torch.load(
-                os.path.join(
-                    self.prompt_attention_mask_dir, prompt_attention_mask_file
-                ),
-                map_location="cpu",
-                weights_only=True,
-            )
-        return latent, prompt_embed, prompt_attention_mask
-
-    def __len__(self):
-        return len(self.data_anno)
-
-
-def latent_collate_function(batch):
-    # return latent, prompt, latent_attn_mask, text_attn_mask
-    # latent_attn_mask: # b t h w
-    # text_attn_mask: b 1 l
-    # needs to check if the latent/prompt' size and apply padding & attn mask
-    latents, prompt_embeds, prompt_attention_masks = zip(*batch)
-    # calculate max shape
-    max_t = max([latent.shape[1] for latent in latents])
-    max_h = max([latent.shape[2] for latent in latents])
-    max_w = max([latent.shape[3] for latent in latents])
-
-    # padding
-    latents = [
-        torch.nn.functional.pad(
-            latent,
-            (
-                0,
-                max_t - latent.shape[1],
-                0,
-                max_h - latent.shape[2],
-                0,
-                max_w - latent.shape[3],
-            ),
-        )
-        for latent in latents
-    ]
-    # attn mask
-    latent_attn_mask = torch.ones(len(latents), max_t, max_h, max_w)
-    # set to 0 if padding
-    for i, latent in enumerate(latents):
-        latent_attn_mask[i, latent.shape[1] :, :, :] = 0
-        latent_attn_mask[i, :, latent.shape[2] :, :] = 0
-        latent_attn_mask[i, :, :, latent.shape[3] :] = 0
-
-    prompt_embeds = torch.stack(prompt_embeds, dim=0)
-    prompt_attention_masks = torch.stack(prompt_attention_masks, dim=0)
-    latents = torch.stack(latents, dim=0)
-    return latents, prompt_embeds, latent_attn_mask, prompt_attention_masks
-
-
-if __name__ == "__main__":
-    dataset = LatentDataset("data/Mochi-Synthetic-Data/merge.txt", num_latent_t=28)
-    dataloader = torch.utils.data.DataLoader(
-        dataset, batch_size=2, shuffle=False, collate_fn=latent_collate_function
-    )
-    for latent, prompt_embed, latent_attn_mask, prompt_attention_mask in dataloader:
-        print(
-            latent.shape,
-            prompt_embed.shape,
-            latent_attn_mask.shape,
-            prompt_attention_mask.shape,
-        )
-        import pdb
-
-        pdb.set_trace()

fastvideo/dataset/t2v_datasets.py

@@ -1,357 +0,0 @@
-import json
-import os, io, csv, math, random
-import numpy as np
-from einops import rearrange
-from decord import VideoReader
-from os.path import join as opj
-from collections import Counter
-
-import torch
-from torch.utils.data.dataset import Dataset
-from torch.utils.data import DataLoader, Dataset, get_worker_info
-from tqdm import tqdm
-from PIL import Image
-from accelerate.logging import get_logger
-from fastvideo.utils.dataset_utils import DecordInit
-import torchvision
-
-logger = get_logger(__name__)
-
-
-class SingletonMeta(type):
-    _instances = {}
-
-    def __call__(cls, *args, **kwargs):
-        if cls not in cls._instances:
-            instance = super().__call__(*args, **kwargs)
-            cls._instances[cls] = instance
-        return cls._instances[cls]
-
-
-class DataSetProg(metaclass=SingletonMeta):
-    def __init__(self):
-        self.cap_list = []
-        self.elements = []
-        self.num_workers = 1
-        self.n_elements = 0
-        self.worker_elements = dict()
-        self.n_used_elements = dict()
-
-    def set_cap_list(self, num_workers, cap_list, n_elements):
-        self.num_workers = num_workers
-        self.cap_list = cap_list
-        self.n_elements = n_elements
-        self.elements = list(range(n_elements))
-        random.shuffle(self.elements)
-        print(f"n_elements: {len(self.elements)}", flush=True)
-
-        for i in range(self.num_workers):
-            self.n_used_elements[i] = 0
-            per_worker = int(math.ceil(len(self.elements) / float(self.num_workers)))
-            start = i * per_worker
-            end = min(start + per_worker, len(self.elements))
-            self.worker_elements[i] = self.elements[start:end]
-
-    def get_item(self, work_info):
-        if work_info is None:
-            worker_id = 0
-        else:
-            worker_id = work_info.id
-
-        idx = self.worker_elements[worker_id][
-            self.n_used_elements[worker_id] % len(self.worker_elements[worker_id])
-        ]
-        self.n_used_elements[worker_id] += 1
-        return idx
-
-
-dataset_prog = DataSetProg()
-
-
-def filter_resolution(h, w, max_h_div_w_ratio=17 / 16, min_h_div_w_ratio=8 / 16):
-    if h / w <= max_h_div_w_ratio and h / w >= min_h_div_w_ratio:
-        return True
-    return False
-
-
-class T2V_dataset(Dataset):
-    def __init__(self, args, transform, temporal_sample, tokenizer, transform_topcrop):
-        self.data = args.data_merge_path
-        self.num_frames = args.num_frames
-        self.train_fps = args.train_fps
-        self.use_image_num = args.use_image_num
-        self.transform = transform
-        self.transform_topcrop = transform_topcrop
-        self.temporal_sample = temporal_sample
-        self.tokenizer = tokenizer
-        self.text_max_length = args.text_max_length
-        self.cfg = args.cfg
-        self.speed_factor = args.speed_factor
-        self.max_height = args.max_height
-        self.max_width = args.max_width
-        self.drop_short_ratio = args.drop_short_ratio
-        assert self.speed_factor >= 1
-        self.v_decoder = DecordInit()
-        self.video_length_tolerance_range = args.video_length_tolerance_range
-        self.support_Chinese = True
-        if not ("mt5" in args.text_encoder_name):
-            self.support_Chinese = False
-
-        cap_list = self.get_cap_list()
-
-        assert len(cap_list) > 0
-        cap_list, self.sample_num_frames = self.define_frame_index(cap_list)
-        self.lengths = self.sample_num_frames
-
-        n_elements = len(cap_list)
-        dataset_prog.set_cap_list(args.dataloader_num_workers, cap_list, n_elements)
-
-        print(f"video length: {len(dataset_prog.cap_list)}", flush=True)
-
-    def set_checkpoint(self, n_used_elements):
-        for i in range(len(dataset_prog.n_used_elements)):
-            dataset_prog.n_used_elements[i] = n_used_elements
-
-    def __len__(self):
-        return dataset_prog.n_elements
-
-    def __getitem__(self, idx):
-        try:
-            data = self.get_data(idx)
-            return data
-        except Exception as e:
-            logger.info(f"Error with {e}")
-            if idx in dataset_prog.cap_list:
-                logger.info(f"Caught an exception! {dataset_prog.cap_list[idx]}")
-            return self.__getitem__(random.randint(0, self.__len__() - 1))
-
-    def get_data(self, idx):
-        path = dataset_prog.cap_list[idx]["path"]
-        if path.endswith(".mp4"):
-            return self.get_video(idx)
-        else:
-            return self.get_image(idx)
-
-    def get_video(self, idx):
-        video_path = dataset_prog.cap_list[idx]["path"]
-        assert os.path.exists(video_path), f"file {video_path} do not exist!"
-        frame_indices = dataset_prog.cap_list[idx]["sample_frame_index"]
-        torchvision_video, _, metadata = torchvision.io.read_video(
-            video_path, output_format="TCHW"
-        )
-        video = torchvision_video[frame_indices]
-        video = self.transform(video)
-        video = rearrange(video, "t c h w -> c t h w")
-        video = video.to(torch.uint8)
-        assert video.dtype == torch.uint8
-
-        h, w = video.shape[-2:]
-        assert (
-            h / w <= 17 / 16 and h / w >= 8 / 16
-        ), f"Only videos with a ratio (h/w) less than 17/16 and more than 8/16 are supported. But video ({video_path}) found ratio is {round(h / w, 2)} with the shape of {video.shape}"
-
-        video = video.float() / 127.5 - 1.0
-
-        text = dataset_prog.cap_list[idx]["cap"]
-        if not isinstance(text, list):
-            text = [text]
-        text = [random.choice(text)]
-
-        text = text[0] if random.random() > self.cfg else ""
-        text_tokens_and_mask = self.tokenizer(
-            text,
-            max_length=self.text_max_length,
-            padding="max_length",
-            truncation=True,
-            return_attention_mask=True,
-            add_special_tokens=True,
-            return_tensors="pt",
-        )
-        input_ids = text_tokens_and_mask["input_ids"]
-        cond_mask = text_tokens_and_mask["attention_mask"]
-        return dict(
-            pixel_values=video,
-            text=text,
-            input_ids=input_ids,
-            cond_mask=cond_mask,
-            path=video_path,
-        )
-
-    def get_image(self, idx):
-        image_data = dataset_prog.cap_list[idx]  # [{'path': path, 'cap': cap}, ...]
-
-        image = Image.open(image_data["path"]).convert("RGB")  # [h, w, c]
-        image = torch.from_numpy(np.array(image))  # [h, w, c]
-        image = rearrange(image, "h w c -> c h w").unsqueeze(0)  #  [1 c h w]
-        # for i in image:
-        #     h, w = i.shape[-2:]
-        #     assert h / w <= 17 / 16 and h / w >= 8 / 16, f'Only image with a ratio (h/w) less than 17/16 and more than 8/16 are supported. But found ratio is {round(h / w, 2)} with the shape of {i.shape}'
-
-        image = (
-            self.transform_topcrop(image)
-            if "human_images" in image_data["path"]
-            else self.transform(image)
-        )  #  [1 C H W] -> num_img [1 C H W]
-        image = image.transpose(0, 1)  # [1 C H W] -> [C 1 H W]
-
-        image = image.float() / 127.5 - 1.0
-
-        caps = (
-            image_data["cap"]
-            if isinstance(image_data["cap"], list)
-            else [image_data["cap"]]
-        )
-        caps = [random.choice(caps)]
-        text = caps
-        input_ids, cond_mask = [], []
-        text = text if random.random() > self.cfg else ""
-        text_tokens_and_mask = self.tokenizer(
-            text,
-            max_length=self.text_max_length,
-            padding="max_length",
-            truncation=True,
-            return_attention_mask=True,
-            add_special_tokens=True,
-            return_tensors="pt",
-        )
-        input_ids = text_tokens_and_mask["input_ids"]  # 1, l
-        cond_mask = text_tokens_and_mask["attention_mask"]  # 1, l
-        return dict(
-            pixel_values=image,
-            text=text,
-            input_ids=input_ids,
-            cond_mask=cond_mask,
-            path=image_data["path"],
-        )
-
-    def define_frame_index(self, cap_list):
-        new_cap_list = []
-        sample_num_frames = []
-        cnt_too_long = 0
-        cnt_too_short = 0
-        cnt_no_cap = 0
-        cnt_no_resolution = 0
-        cnt_resolution_mismatch = 0
-        cnt_movie = 0
-        cnt_img = 0
-        for i in cap_list:
-            path = i["path"]
-            cap = i.get("cap", None)
-            # ======no caption=====
-            if cap is None:
-                cnt_no_cap += 1
-                continue
-            if path.endswith(".mp4"):
-                # ======no fps and duration=====
-                duration = i.get("duration", None)
-                fps = i.get("fps", None)
-                if fps is None or duration is None:
-                    continue
-
-                # ======resolution mismatch=====
-                resolution = i.get("resolution", None)
-                if resolution is None:
-                    cnt_no_resolution += 1
-                    continue
-                else:
-                    if (
-                        resolution.get("height", None) is None
-                        or resolution.get("width", None) is None
-                    ):
-                        cnt_no_resolution += 1
-                        continue
-                    height, width = i["resolution"]["height"], i["resolution"]["width"]
-                    aspect = self.max_height / self.max_width
-                    hw_aspect_thr = 1.5
-                    is_pick = filter_resolution(
-                        height,
-                        width,
-                        max_h_div_w_ratio=hw_aspect_thr * aspect,
-                        min_h_div_w_ratio=1 / hw_aspect_thr * aspect,
-                    )
-                    if not is_pick:
-                        print("resolution mismatch")
-                        cnt_resolution_mismatch += 1
-                        continue
-
-                # import ipdb;ipdb.set_trace()
-                i["num_frames"] = math.ceil(fps * duration)
-                # max 5.0 and min 1.0 are just thresholds to filter some videos which have suitable duration.
-                if (
-                    i["num_frames"] / fps
-                    > self.video_length_tolerance_range
-                    * (self.num_frames / self.train_fps * self.speed_factor)
-                ):  # too long video is not suitable for this training stage (self.num_frames)
-                    cnt_too_long += 1
-                    continue
-
-                # resample in case high fps, such as 50/60/90/144 -> train_fps(e.g, 24)
-                frame_interval = fps / self.train_fps
-                start_frame_idx = 0
-                frame_indices = np.arange(
-                    start_frame_idx, i["num_frames"], frame_interval
-                ).astype(int)
-
-                # comment out it to enable dynamic frames training
-                if (
-                    len(frame_indices) < self.num_frames
-                    and random.random() < self.drop_short_ratio
-                ):
-                    cnt_too_short += 1
-                    continue
-
-                #  too long video will be temporal-crop randomly
-                if len(frame_indices) > self.num_frames:
-                    begin_index, end_index = self.temporal_sample(len(frame_indices))
-                    frame_indices = frame_indices[begin_index:end_index]
-                    # frame_indices = frame_indices[:self.num_frames]  # head crop
-                i["sample_frame_index"] = frame_indices.tolist()
-                new_cap_list.append(i)
-                i["sample_num_frames"] = len(
-                    i["sample_frame_index"]
-                )  # will use in dataloader(group sampler)
-                sample_num_frames.append(i["sample_num_frames"])
-            elif path.endswith(".jpg"):  # image
-                cnt_img += 1
-                new_cap_list.append(i)
-                i["sample_num_frames"] = 1
-                sample_num_frames.append(i["sample_num_frames"])
-            else:
-                raise NameError(
-                    f"Unknown file extention {path.split('.')[-1]}, only support .mp4 for video and .jpg for image"
-                )
-        # import ipdb;ipdb.set_trace()
-        logger.info(
-            f"no_cap: {cnt_no_cap}, too_long: {cnt_too_long}, too_short: {cnt_too_short}, "
-            f"no_resolution: {cnt_no_resolution}, resolution_mismatch: {cnt_resolution_mismatch}, "
-            f"Counter(sample_num_frames): {Counter(sample_num_frames)}, cnt_movie: {cnt_movie}, cnt_img: {cnt_img}, "
-            f"before filter: {len(cap_list)}, after filter: {len(new_cap_list)}"
-        )
-        return new_cap_list, sample_num_frames
-
-    def decord_read(self, path, frame_indices):
-        decord_vr = self.v_decoder(path)
-        video_data = decord_vr.get_batch(frame_indices).asnumpy()
-        video_data = torch.from_numpy(video_data)
-        video_data = video_data.permute(0, 3, 1, 2)  # (T, H, W, C) -> (T C H W)
-        return video_data
-
-    def read_jsons(self, data):
-        cap_lists = []
-        with open(data, "r") as f:
-            folder_anno = [
-                i.strip().split(",") for i in f.readlines() if len(i.strip()) > 0
-            ]
-        print(folder_anno)
-        for folder, anno in folder_anno:
-            with open(anno, "r") as f:
-                sub_list = json.load(f)
-            logger.info(f"Building {anno}...")
-            for i in range(len(sub_list)):
-                sub_list[i]["path"] = opj(folder, sub_list[i]["path"])
-            cap_lists += sub_list
-        return cap_lists
-
-    def get_cap_list(self):
-        cap_lists = self.read_jsons(self.data)
-        return cap_lists

fastvideo/dataset/transform.py

@@ -1,645 +0,0 @@
-import torch
-import random
-import numbers
-from torchvision.transforms import RandomCrop, RandomResizedCrop
-
-
-def _is_tensor_video_clip(clip):
-    if not torch.is_tensor(clip):
-        raise TypeError("clip should be Tensor. Got %s" % type(clip))
-
-    if not clip.ndimension() == 4:
-        raise ValueError("clip should be 4D. Got %dD" % clip.dim())
-
-    return True
-
-
-def center_crop_arr(pil_image, image_size):
-    """
-    Center cropping implementation from ADM.
-    https://github.com/openai/guided-diffusion/blob/8fb3ad9197f16bbc40620447b2742e13458d2831/guided_diffusion/image_datasets.py#L126
-    """
-    while min(*pil_image.size) >= 2 * image_size:
-        pil_image = pil_image.resize(
-            tuple(x // 2 for x in pil_image.size), resample=Image.BOX
-        )
-
-    scale = image_size / min(*pil_image.size)
-    pil_image = pil_image.resize(
-        tuple(round(x * scale) for x in pil_image.size), resample=Image.BICUBIC
-    )
-
-    arr = np.array(pil_image)
-    crop_y = (arr.shape[0] - image_size) // 2
-    crop_x = (arr.shape[1] - image_size) // 2
-    return Image.fromarray(
-        arr[crop_y : crop_y + image_size, crop_x : crop_x + image_size]
-    )
-
-
-def crop(clip, i, j, h, w):
-    """
-    Args:
-        clip (torch.tensor): Video clip to be cropped. Size is (T, C, H, W)
-    """
-    if len(clip.size()) != 4:
-        raise ValueError("clip should be a 4D tensor")
-    return clip[..., i : i + h, j : j + w]
-
-
-def resize(clip, target_size, interpolation_mode):
-    if len(target_size) != 2:
-        raise ValueError(
-            f"target size should be tuple (height, width), instead got {target_size}"
-        )
-    return torch.nn.functional.interpolate(
-        clip,
-        size=target_size,
-        mode=interpolation_mode,
-        align_corners=True,
-        antialias=True,
-    )
-
-
-def resize_scale(clip, target_size, interpolation_mode):
-    if len(target_size) != 2:
-        raise ValueError(
-            f"target size should be tuple (height, width), instead got {target_size}"
-        )
-    H, W = clip.size(-2), clip.size(-1)
-    scale_ = target_size[0] / min(H, W)
-    return torch.nn.functional.interpolate(
-        clip,
-        scale_factor=scale_,
-        mode=interpolation_mode,
-        align_corners=True,
-        antialias=True,
-    )
-
-
-def resized_crop(clip, i, j, h, w, size, interpolation_mode="bilinear"):
-    """
-    Do spatial cropping and resizing to the video clip
-    Args:
-        clip (torch.tensor): Video clip to be cropped. Size is (T, C, H, W)
-        i (int): i in (i,j) i.e coordinates of the upper left corner.
-        j (int): j in (i,j) i.e coordinates of the upper left corner.
-        h (int): Height of the cropped region.
-        w (int): Width of the cropped region.
-        size (tuple(int, int)): height and width of resized clip
-    Returns:
-        clip (torch.tensor): Resized and cropped clip. Size is (T, C, H, W)
-    """
-    if not _is_tensor_video_clip(clip):
-        raise ValueError("clip should be a 4D torch.tensor")
-    clip = crop(clip, i, j, h, w)
-    clip = resize(clip, size, interpolation_mode)
-    return clip
-
-
-def center_crop(clip, crop_size):
-    if not _is_tensor_video_clip(clip):
-        raise ValueError("clip should be a 4D torch.tensor")
-    h, w = clip.size(-2), clip.size(-1)
-    th, tw = crop_size
-    if h < th or w < tw:
-        raise ValueError("height and width must be no smaller than crop_size")
-
-    i = int(round((h - th) / 2.0))
-    j = int(round((w - tw) / 2.0))
-    return crop(clip, i, j, th, tw)
-
-
-def center_crop_using_short_edge(clip):
-    if not _is_tensor_video_clip(clip):
-        raise ValueError("clip should be a 4D torch.tensor")
-    h, w = clip.size(-2), clip.size(-1)
-    if h < w:
-        th, tw = h, h
-        i = 0
-        j = int(round((w - tw) / 2.0))
-    else:
-        th, tw = w, w
-        i = int(round((h - th) / 2.0))
-        j = 0
-    return crop(clip, i, j, th, tw)
-
-
-def center_crop_th_tw(clip, th, tw, top_crop):
-    if not _is_tensor_video_clip(clip):
-        raise ValueError("clip should be a 4D torch.tensor")
-
-    # import ipdb;ipdb.set_trace()
-    h, w = clip.size(-2), clip.size(-1)
-    tr = th / tw
-    if h / w > tr:
-        new_h = int(w * tr)
-        new_w = w
-    else:
-        new_h = h
-        new_w = int(h / tr)
-
-    i = 0 if top_crop else int(round((h - new_h) / 2.0))
-    j = int(round((w - new_w) / 2.0))
-    return crop(clip, i, j, new_h, new_w)
-
-
-def random_shift_crop(clip):
-    """
-    Slide along the long edge, with the short edge as crop size
-    """
-    if not _is_tensor_video_clip(clip):
-        raise ValueError("clip should be a 4D torch.tensor")
-    h, w = clip.size(-2), clip.size(-1)
-
-    if h <= w:
-        long_edge = w
-        short_edge = h
-    else:
-        long_edge = h
-        short_edge = w
-
-    th, tw = short_edge, short_edge
-
-    i = torch.randint(0, h - th + 1, size=(1,)).item()
-    j = torch.randint(0, w - tw + 1, size=(1,)).item()
-    return crop(clip, i, j, th, tw)
-
-
-def normalize_video(clip):
-    """
-    Convert tensor data type from uint8 to float, divide value by 255.0 and
-    permute the dimensions of clip tensor
-    Args:
-        clip (torch.tensor, dtype=torch.uint8): Size is (T, C, H, W)
-    Return:
-        clip (torch.tensor, dtype=torch.float): Size is (T, C, H, W)
-    """
-    _is_tensor_video_clip(clip)
-    if not clip.dtype == torch.uint8:
-        raise TypeError(
-            "clip tensor should have data type uint8. Got %s" % str(clip.dtype)
-        )
-    # return clip.float().permute(3, 0, 1, 2) / 255.0
-    return clip.float() / 255.0
-
-
-def normalize(clip, mean, std, inplace=False):
-    """
-    Args:
-        clip (torch.tensor): Video clip to be normalized. Size is (T, C, H, W)
-        mean (tuple): pixel RGB mean. Size is (3)
-        std (tuple): pixel standard deviation. Size is (3)
-    Returns:
-        normalized clip (torch.tensor): Size is (T, C, H, W)
-    """
-    if not _is_tensor_video_clip(clip):
-        raise ValueError("clip should be a 4D torch.tensor")
-    if not inplace:
-        clip = clip.clone()
-    mean = torch.as_tensor(mean, dtype=clip.dtype, device=clip.device)
-    # print(mean)
-    std = torch.as_tensor(std, dtype=clip.dtype, device=clip.device)
-    clip.sub_(mean[:, None, None, None]).div_(std[:, None, None, None])
-    return clip
-
-
-def hflip(clip):
-    """
-    Args:
-        clip (torch.tensor): Video clip to be normalized. Size is (T, C, H, W)
-    Returns:
-        flipped clip (torch.tensor): Size is (T, C, H, W)
-    """
-    if not _is_tensor_video_clip(clip):
-        raise ValueError("clip should be a 4D torch.tensor")
-    return clip.flip(-1)
-
-
-class RandomCropVideo:
-    def __init__(self, size):
-        if isinstance(size, numbers.Number):
-            self.size = (int(size), int(size))
-        else:
-            self.size = size
-
-    def __call__(self, clip):
-        """
-        Args:
-            clip (torch.tensor): Video clip to be cropped. Size is (T, C, H, W)
-        Returns:
-            torch.tensor: randomly cropped video clip.
-                size is (T, C, OH, OW)
-        """
-        i, j, h, w = self.get_params(clip)
-        return crop(clip, i, j, h, w)
-
-    def get_params(self, clip):
-        h, w = clip.shape[-2:]
-        th, tw = self.size
-
-        if h < th or w < tw:
-            raise ValueError(
-                f"Required crop size {(th, tw)} is larger than input image size {(h, w)}"
-            )
-
-        if w == tw and h == th:
-            return 0, 0, h, w
-
-        i = torch.randint(0, h - th + 1, size=(1,)).item()
-        j = torch.randint(0, w - tw + 1, size=(1,)).item()
-
-        return i, j, th, tw
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(size={self.size})"
-
-
-class SpatialStrideCropVideo:
-    def __init__(self, stride):
-        self.stride = stride
-
-    def __call__(self, clip):
-        """
-        Args:
-            clip (torch.tensor): Video clip to be cropped. Size is (T, C, H, W)
-        Returns:
-            torch.tensor: cropped video clip by stride.
-                size is (T, C, OH, OW)
-        """
-        i, j, h, w = self.get_params(clip)
-        return crop(clip, i, j, h, w)
-
-    def get_params(self, clip):
-        h, w = clip.shape[-2:]
-
-        th, tw = h // self.stride * self.stride, w // self.stride * self.stride
-
-        return 0, 0, th, tw  # from top-left
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(size={self.size})"
-
-
-class LongSideResizeVideo:
-    """
-    First use the long side,
-    then resize to the specified size
-    """
-
-    def __init__(
-        self,
-        size,
-        skip_low_resolution=False,
-        interpolation_mode="bilinear",
-    ):
-        self.size = size
-        self.skip_low_resolution = skip_low_resolution
-        self.interpolation_mode = interpolation_mode
-
-    def __call__(self, clip):
-        """
-        Args:
-            clip (torch.tensor): Video clip to be cropped. Size is (T, C, H, W)
-        Returns:
-            torch.tensor: scale resized video clip.
-                size is (T, C, 512, *) or (T, C, *, 512)
-        """
-        _, _, h, w = clip.shape
-        if self.skip_low_resolution and max(h, w) <= self.size:
-            return clip
-        if h > w:
-            w = int(w * self.size / h)
-            h = self.size
-        else:
-            h = int(h * self.size / w)
-            w = self.size
-        resize_clip = resize(
-            clip, target_size=(h, w), interpolation_mode=self.interpolation_mode
-        )
-        return resize_clip
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(size={self.size}, interpolation_mode={self.interpolation_mode}"
-
-
-class CenterCropResizeVideo:
-    """
-    First use the short side for cropping length,
-    center crop video, then resize to the specified size
-    """
-
-    def __init__(
-        self,
-        size,
-        top_crop=False,
-        interpolation_mode="bilinear",
-    ):
-        if len(size) != 2:
-            raise ValueError(
-                f"size should be tuple (height, width), instead got {size}"
-            )
-        self.size = size
-        self.top_crop = top_crop
-        self.interpolation_mode = interpolation_mode
-
-    def __call__(self, clip):
-        """
-        Args:
-            clip (torch.tensor): Video clip to be cropped. Size is (T, C, H, W)
-        Returns:
-            torch.tensor: scale resized / center cropped video clip.
-                size is (T, C, crop_size, crop_size)
-        """
-        # clip_center_crop = center_crop_using_short_edge(clip)
-        clip_center_crop = center_crop_th_tw(
-            clip, self.size[0], self.size[1], top_crop=self.top_crop
-        )
-        # import ipdb;ipdb.set_trace()
-        clip_center_crop_resize = resize(
-            clip_center_crop,
-            target_size=self.size,
-            interpolation_mode=self.interpolation_mode,
-        )
-        return clip_center_crop_resize
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(size={self.size}, interpolation_mode={self.interpolation_mode}"
-
-
-class UCFCenterCropVideo:
-    """
-    First scale to the specified size in equal proportion to the short edge,
-    then center cropping
-    """
-
-    def __init__(
-        self,
-        size,
-        interpolation_mode="bilinear",
-    ):
-        if isinstance(size, tuple):
-            if len(size) != 2:
-                raise ValueError(
-                    f"size should be tuple (height, width), instead got {size}"
-                )
-            self.size = size
-        else:
-            self.size = (size, size)
-
-        self.interpolation_mode = interpolation_mode
-
-    def __call__(self, clip):
-        """
-        Args:
-            clip (torch.tensor): Video clip to be cropped. Size is (T, C, H, W)
-        Returns:
-            torch.tensor: scale resized / center cropped video clip.
-                size is (T, C, crop_size, crop_size)
-        """
-        clip_resize = resize_scale(
-            clip=clip, target_size=self.size, interpolation_mode=self.interpolation_mode
-        )
-        clip_center_crop = center_crop(clip_resize, self.size)
-        return clip_center_crop
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(size={self.size}, interpolation_mode={self.interpolation_mode}"
-
-
-class KineticsRandomCropResizeVideo:
-    """
-    Slide along the long edge, with the short edge as crop size. And resie to the desired size.
-    """
-
-    def __init__(
-        self,
-        size,
-        interpolation_mode="bilinear",
-    ):
-        if isinstance(size, tuple):
-            if len(size) != 2:
-                raise ValueError(
-                    f"size should be tuple (height, width), instead got {size}"
-                )
-            self.size = size
-        else:
-            self.size = (size, size)
-
-        self.interpolation_mode = interpolation_mode
-
-    def __call__(self, clip):
-        clip_random_crop = random_shift_crop(clip)
-        clip_resize = resize(clip_random_crop, self.size, self.interpolation_mode)
-        return clip_resize
-
-
-class CenterCropVideo:
-    def __init__(
-        self,
-        size,
-        interpolation_mode="bilinear",
-    ):
-        if isinstance(size, tuple):
-            if len(size) != 2:
-                raise ValueError(
-                    f"size should be tuple (height, width), instead got {size}"
-                )
-            self.size = size
-        else:
-            self.size = (size, size)
-
-        self.interpolation_mode = interpolation_mode
-
-    def __call__(self, clip):
-        """
-        Args:
-            clip (torch.tensor): Video clip to be cropped. Size is (T, C, H, W)
-        Returns:
-            torch.tensor: center cropped video clip.
-                size is (T, C, crop_size, crop_size)
-        """
-        clip_center_crop = center_crop(clip, self.size)
-        return clip_center_crop
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(size={self.size}, interpolation_mode={self.interpolation_mode}"
-
-
-class Normalize:
-    """
-    Normalize the video clip by mean subtraction and division by standard deviation
-    Args:
-        mean (3-tuple): pixel RGB mean
-        std (3-tuple): pixel RGB standard deviation
-        inplace (boolean): whether do in-place normalization
-    """
-
-    def __init__(self, mean, std, inplace=False):
-        self.mean = mean
-        self.std = std
-        self.inplace = inplace
-
-    def __call__(self, clip):
-        """
-        Args:
-            clip (torch.tensor): video clip must be normalized. Size is (C, T, H, W)
-        """
-        return normalize(clip, self.mean, self.std, self.inplace)
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(mean={self.mean}, std={self.std}, inplace={self.inplace})"
-
-
-class Normalize255:
-    """
-    Convert tensor data type from uint8 to float, divide value by 255.0 and
-    """
-
-    def __init__(self):
-        pass
-
-    def __call__(self, clip):
-        """
-        Args:
-            clip (torch.tensor, dtype=torch.uint8): Size is (T, C, H, W)
-        Return:
-            clip (torch.tensor, dtype=torch.float): Size is (T, C, H, W)
-        """
-        return normalize_video(clip)
-
-    def __repr__(self) -> str:
-        return self.__class__.__name__
-
-
-class RandomHorizontalFlipVideo:
-    """
-    Flip the video clip along the horizontal direction with a given probability
-    Args:
-        p (float): probability of the clip being flipped. Default value is 0.5
-    """
-
-    def __init__(self, p=0.5):
-        self.p = p
-
-    def __call__(self, clip):
-        """
-        Args:
-            clip (torch.tensor): Size is (T, C, H, W)
-        Return:
-            clip (torch.tensor): Size is (T, C, H, W)
-        """
-        if random.random() < self.p:
-            clip = hflip(clip)
-        return clip
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}(p={self.p})"
-
-
-#  ------------------------------------------------------------
-#  ---------------------  Sampling  ---------------------------
-#  ------------------------------------------------------------
-class TemporalRandomCrop(object):
-    """Temporally crop the given frame indices at a random location.
-
-    Args:
-        size (int): Desired length of frames will be seen in the model.
-    """
-
-    def __init__(self, size):
-        self.size = size
-
-    def __call__(self, total_frames):
-        rand_end = max(0, total_frames - self.size - 1)
-        begin_index = random.randint(0, rand_end)
-        end_index = min(begin_index + self.size, total_frames)
-        return begin_index, end_index
-
-
-class DynamicSampleDuration(object):
-    """Temporally crop the given frame indices at a random location.
-
-    Args:
-        size (int): Desired length of frames will be seen in the model.
-    """
-
-    def __init__(self, t_stride, extra_1):
-        self.t_stride = t_stride
-        self.extra_1 = extra_1
-
-    def __call__(self, t, h, w):
-        if self.extra_1:
-            t = t - 1
-        truncate_t_list = list(range(t + 1))[t // 2 :][
-            :: self.t_stride
-        ]  # need half at least
-        truncate_t = random.choice(truncate_t_list)
-        if self.extra_1:
-            truncate_t = truncate_t + 1
-        return 0, truncate_t
-
-
-if __name__ == "__main__":
-    from torchvision import transforms
-    import torchvision.io as io
-    import numpy as np
-    from torchvision.utils import save_image
-    import os
-
-    vframes, aframes, info = io.read_video(
-        filename="./v_Archery_g01_c03.avi", pts_unit="sec", output_format="TCHW"
-    )
-
-    trans = transforms.Compose(
-        [
-            Normalize255(),
-            RandomHorizontalFlipVideo(),
-            UCFCenterCropVideo(512),
-            # NormalizeVideo(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True),
-            transforms.Normalize(
-                mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5], inplace=True
-            ),
-        ]
-    )
-
-    target_video_len = 32
-    frame_interval = 1
-    total_frames = len(vframes)
-    print(total_frames)
-
-    temporal_sample = TemporalRandomCrop(target_video_len * frame_interval)
-
-    # Sampling video frames
-    start_frame_ind, end_frame_ind = temporal_sample(total_frames)
-    # print(start_frame_ind)
-    # print(end_frame_ind)
-    assert end_frame_ind - start_frame_ind >= target_video_len
-    frame_indice = np.linspace(
-        start_frame_ind, end_frame_ind - 1, target_video_len, dtype=int
-    )
-    print(frame_indice)
-
-    select_vframes = vframes[frame_indice]
-    print(select_vframes.shape)
-    print(select_vframes.dtype)
-
-    select_vframes_trans = trans(select_vframes)
-    print(select_vframes_trans.shape)
-    print(select_vframes_trans.dtype)
-
-    select_vframes_trans_int = ((select_vframes_trans * 0.5 + 0.5) * 255).to(
-        dtype=torch.uint8
-    )
-    print(select_vframes_trans_int.dtype)
-    print(select_vframes_trans_int.permute(0, 2, 3, 1).shape)
-
-    io.write_video("./test.avi", select_vframes_trans_int.permute(0, 2, 3, 1), fps=8)
-
-    for i in range(target_video_len):
-        save_image(
-            select_vframes_trans[i],
-            os.path.join("./test000", "%04d.png" % i),
-            normalize=True,
-            value_range=(-1, 1),
-        )

fastvideo/demo/gradio_web_demo.py

@@ -1,142 +0,0 @@
-import gradio as gr
-import torch
-from fastvideo.model.pipeline_mochi import MochiPipeline
-from fastvideo.model.modeling_mochi import MochiTransformer3DModel
-from diffusers import FlowMatchEulerDiscreteScheduler
-from diffusers.utils import export_to_video
-from fastvideo.distill.solver import PCMFMScheduler
-import tempfile
-import os
-import argparse
-
-def init_args():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--prompts", nargs='+', default=[])
-    parser.add_argument("--num_frames", type=int, default=163)
-    parser.add_argument("--height", type=int, default=480)
-    parser.add_argument("--width", type=int, default=848)
-    parser.add_argument("--num_inference_steps", type=int, default=64)
-    parser.add_argument("--guidance_scale", type=float, default=4.5)
-    parser.add_argument("--model_path", type=str, default="data/mochi")
-    parser.add_argument("--seed", type=int, default=42)
-    parser.add_argument("--transformer_path", type=str, default=None)
-    parser.add_argument("--scheduler_type", type=str, default="euler")
-    parser.add_argument("--lora_checkpoint_dir", type=str, default=None)
-    parser.add_argument("--shift", type=float, default=8.0)
-    parser.add_argument("--num_euler_timesteps", type=int, default=100)
-    parser.add_argument("--linear_threshold", type=float, default=0.025)
-    parser.add_argument("--linear_range", type=float, default=0.5)
-    parser.add_argument("--cpu_offload", action="store_true")
-    return parser.parse_args()
-
-def load_model(args):
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-    if args.scheduler_type == "euler":
-        scheduler = FlowMatchEulerDiscreteScheduler()
-    else:
-        scheduler = PCMFMScheduler(1000, args.shift, args.num_euler_timesteps, False, args.linear_threshold, args.linear_range)
-    
-    if args.transformer_path:
-        transformer = MochiTransformer3DModel.from_pretrained(args.transformer_path)
-    else:
-        transformer = MochiTransformer3DModel.from_pretrained(args.model_path, subfolder='transformer/')
-    
-    pipe = MochiPipeline.from_pretrained(args.model_path, transformer=transformer, scheduler=scheduler)
-    pipe.enable_vae_tiling()
-    pipe.to(device)
-    if args.cpu_offload:
-        pipe.enable_model_cpu_offload()
-    return pipe
-
-def generate_video(prompt, negative_prompt, use_negative_prompt, seed, guidance_scale, 
-                  num_frames, height, width, num_inference_steps, randomize_seed=False):
-    if randomize_seed:
-        seed = torch.randint(0, 1000000, (1,)).item()
-    
-    pipe = load_model(args)
-    print("load model successfully")
-    generator = torch.Generator(device="cuda").manual_seed(seed)
-    
-    if not use_negative_prompt:
-        negative_prompt = None
-    
-    with torch.autocast("cuda", dtype=torch.bfloat16):
-        output = pipe(
-            prompt=[prompt],
-            negative_prompt=negative_prompt,
-            height=height,
-            width=width,
-            num_frames=num_frames,
-            num_inference_steps=num_inference_steps,
-            guidance_scale=guidance_scale,
-            generator=generator,
-        ).frames[0]
-    
-    output_path = os.path.join(tempfile.mkdtemp(), "output.mp4")
-    export_to_video(output, output_path, fps=30)
-    return output_path, seed
-
-examples = [
-    "A hand enters the frame, pulling a sheet of plastic wrap over three balls of dough placed on a wooden surface. The plastic wrap is stretched to cover the dough more securely. The hand adjusts the wrap, ensuring that it is tight and smooth over the dough. The scene focuses on the hand’s movements as it secures the edges of the plastic wrap. No new objects appear, and the camera remains stationary, focusing on the action of covering the dough.",
-    "A vintage train snakes through the mountains, its plume of white steam rising dramatically against the jagged peaks. The cars glint in the late afternoon sun, their deep crimson and gold accents lending a touch of elegance. The tracks carve a precarious path along the cliffside, revealing glimpses of a roaring river far below. Inside, passengers peer out the large windows, their faces lit with awe as the landscape unfolds.",
-    "A crowded rooftop bar buzzes with energy, the city skyline twinkling like a field of stars in the background. Strings of fairy lights hang above, casting a warm, golden glow over the scene. Groups of people gather around high tables, their laughter blending with the soft rhythm of live jazz. The aroma of freshly mixed cocktails and charred appetizers wafts through the air, mingling with the cool night breeze."
-]
-
-args = init_args()
-
-with gr.Blocks() as demo:
-    gr.Markdown("# Mochi Video Generation Demo")
-    
-    with gr.Group():
-        with gr.Row():
-            prompt = gr.Text(
-                label="Prompt",
-                show_label=False,
-                max_lines=1,
-                placeholder="Enter your prompt",
-                container=False,
-            )
-            run_button = gr.Button("Run", scale=0)
-        result = gr.Video(label="Result", show_label=False)
-    
-    with gr.Accordion("Advanced options", open=False):
-        with gr.Group():
-            with gr.Row():
-                height = gr.Slider(label="Height", minimum=256, maximum=1024, step=32, value=args.height)
-                width = gr.Slider(label="Width", minimum=256, maximum=1024, step=32, value=args.width)
-            
-            with gr.Row():
-                num_frames = gr.Slider(label="Number of Frames", minimum=8, maximum=256, value=args.num_frames)
-                guidance_scale = gr.Slider(label="Guidance Scale", minimum=1, maximum=20, value=args.guidance_scale)
-                num_inference_steps = gr.Slider(label="Inference Steps", minimum=10, maximum=100, value=args.num_inference_steps)
-            
-            with gr.Row():
-                use_negative_prompt = gr.Checkbox(label="Use negative prompt", value=False)
-            negative_prompt = gr.Text(
-                label="Negative prompt",
-                max_lines=1,
-                placeholder="Enter a negative prompt",
-                visible=False
-            )
-            
-            seed = gr.Slider(label="Seed", minimum=0, maximum=1000000, step=1, value=args.seed)
-            randomize_seed = gr.Checkbox(label="Randomize seed", value=True)
-            seed_output = gr.Number(label="Used Seed")
-    
-    gr.Examples(examples=examples, inputs=prompt)
-    
-    use_negative_prompt.change(
-        fn=lambda x: gr.update(visible=x),
-        inputs=use_negative_prompt,
-        outputs=negative_prompt,
-    )
-
-    run_button.click(
-        fn=generate_video,
-        inputs=[prompt, negative_prompt, use_negative_prompt, seed, guidance_scale, 
-                num_frames, height, width, num_inference_steps, randomize_seed],
-        outputs=[result, seed_output]
-    )
-
-if __name__ == "__main__":
-    demo.queue(max_size=20).launch(server_name="0.0.0.0", server_port=7860)

fastvideo/distill.py

@@ -1,901 +0,0 @@
-import argparse
-import math
-import os
-from fastvideo.utils.parallel_states import (
-    initialize_sequence_parallel_state,
-    destroy_sequence_parallel_group,
-    get_sequence_parallel_state,
-    nccl_info,
-)
-from fastvideo.utils.communications import sp_parallel_dataloader_wrapper, broadcast
-from fastvideo.models.mochi_hf.mochi_latents_utils import normalize_mochi_dit_input
-from fastvideo.utils.validation import log_validation
-import time
-from torch.utils.data import DataLoader
-import torch
-from torch.distributed.fsdp import ShardingStrategy
-from torch.distributed.fsdp import (
-    FullyShardedDataParallel as FSDP,
-    StateDictType,
-    FullStateDictConfig,
-)
-from fastvideo.models.mochi_hf.pipeline_mochi import linear_quadratic_schedule
-import json
-from torch.utils.data.distributed import DistributedSampler
-from fastvideo.utils.dataset_utils import LengthGroupedSampler
-import wandb
-from accelerate.utils import set_seed
-from tqdm.auto import tqdm
-from fastvideo.fsdp_util import get_dit_fsdp_kwargs, apply_fsdp_checkpointing
-from diffusers import (
-    FlowMatchEulerDiscreteScheduler,
-)
-from fastvideo.distill.solver import EulerSolver, extract_into_tensor
-from copy import deepcopy
-from diffusers.optimization import get_scheduler
-from fastvideo.models.mochi_hf.modeling_mochi import MochiTransformer3DModel
-from diffusers.utils import check_min_version
-from fastvideo.dataset.latent_datasets import LatentDataset, latent_collate_function
-import torch.distributed as dist
-from safetensors.torch import save_file
-from peft import LoraConfig
-from torch.distributed.fsdp import (
-    FullyShardedDataParallel as FSDP,
-)
-from fastvideo.utils.checkpoint import (
-    save_checkpoint,
-    save_lora_checkpoint,
-    resume_lora_optimizer,
-)
-
-# Will error if the minimal version of diffusers is not installed. Remove at your own risks.
-check_min_version("0.31.0")
-import time
-from collections import deque
-
-def main_print(content):
-    if int(os.environ["LOCAL_RANK"]) <= 0:
-        print(content)
-
-
-def save_checkpoint(transformer: MochiTransformer3DModel, rank, output_dir, step):
-    main_print(f"--> saving checkpoint at step {step}")
-    with FSDP.state_dict_type(
-        transformer,
-        StateDictType.FULL_STATE_DICT,
-        FullStateDictConfig(offload_to_cpu=True, rank0_only=True),
-    ):
-        cpu_state = transformer.state_dict()
-    # todo move to get_state_dict
-    if rank <= 0:
-        save_dir = os.path.join(output_dir, f"checkpoint-{step}")
-        os.makedirs(save_dir, exist_ok=True)
-        # save using safetensors
-        weight_path = os.path.join(save_dir, "diffusion_pytorch_model.safetensors")
-        save_file(cpu_state, weight_path)
-        config_dict = dict(transformer.config)
-        config_path = os.path.join(save_dir, "config.json")
-        # save dict as json
-        with open(config_path, "w") as f:
-            json.dump(config_dict, f, indent=4)
-    main_print(f"--> checkpoint saved at step {step}")
-
-
-def reshard_fsdp(model):
-    for m in FSDP.fsdp_modules(model):
-        if m._has_params and m.sharding_strategy is not ShardingStrategy.NO_SHARD:
-            torch.distributed.fsdp._runtime_utils._reshard(m, m._handle, True)
-
-
-def get_norm(model_pred, norms, gradient_accumulation_steps):
-    fro_norm = (
-        torch.linalg.matrix_norm(model_pred, ord="fro") / gradient_accumulation_steps
-    )
-    largest_singular_value = (
-        torch.linalg.matrix_norm(model_pred, ord=2) / gradient_accumulation_steps
-    )
-    absolute_mean = torch.mean(torch.abs(model_pred)) / gradient_accumulation_steps
-    absolute_max = torch.max(torch.abs(model_pred)) / gradient_accumulation_steps
-    dist.all_reduce(fro_norm, op=dist.ReduceOp.AVG)
-    dist.all_reduce(largest_singular_value, op=dist.ReduceOp.AVG)
-    dist.all_reduce(absolute_mean, op=dist.ReduceOp.AVG)
-    norms["fro"] += torch.mean(fro_norm).item()
-    norms["largest singular value"] += torch.mean(largest_singular_value).item()
-    norms["absolute mean"] += absolute_mean.item()
-    norms["absolute max"] += absolute_max.item()
-
-
-def train_one_step_mochi(
-    transformer,
-    teacher_transformer,
-    ema_transformer,
-    optimizer,
-    lr_scheduler,
-    loader,
-    noise_scheduler,
-    solver,
-    noise_random_generator,
-    gradient_accumulation_steps,
-    sp_size,
-    max_grad_norm,
-    uncond_prompt_embed,
-    uncond_prompt_mask,
-    num_euler_timesteps,
-    multiphase,
-    not_apply_cfg_solver,
-    distill_cfg,
-    ema_decay,
-    pred_decay_weight,
-    pred_decay_type,
-):
-    total_loss = 0.0
-    optimizer.zero_grad()
-    model_pred_norm = {
-        "fro": 0.0,
-        "largest singular value": 0.0,
-        "absolute mean": 0.0,
-        "absolute max": 0.0,
-    }
-    for _ in range(gradient_accumulation_steps):
-        (
-            latents,
-            encoder_hidden_states,
-            latents_attention_mask,
-            encoder_attention_mask,
-        ) = next(loader)
-        model_input = normalize_mochi_dit_input(latents)
-        noise = torch.randn_like(model_input)
-        bsz = model_input.shape[0]
-        index = torch.randint(
-            0, num_euler_timesteps, (bsz,), device=model_input.device
-        ).long()
-        if sp_size > 1:
-            broadcast(index)
-        # Add noise according to flow matching.
-        # sigmas = get_sigmas(start_timesteps, n_dim=model_input.ndim, dtype=model_input.dtype)
-        sigmas = extract_into_tensor(solver.sigmas, index, model_input.shape)
-        sigmas_prev = extract_into_tensor(solver.sigmas_prev, index, model_input.shape)
-
-        timesteps = (sigmas * noise_scheduler.config.num_train_timesteps).view(-1)
-        # if squeeze to [], unsqueeze to [1]
-
-        timesteps_prev = (
-            sigmas_prev * noise_scheduler.config.num_train_timesteps
-        ).view(-1)
-        noisy_model_input = sigmas * noise + (1.0 - sigmas) * model_input
-
-        # Predict the noise residual
-        with torch.autocast("cuda", dtype=torch.bfloat16):
-            model_pred = transformer(
-                noisy_model_input,
-                encoder_hidden_states,
-                timesteps,
-                encoder_attention_mask,  # B, L
-                return_dict=False,
-            )[0]
-
-        # if accelerator.is_main_process:
-        model_pred, end_index = solver.euler_style_multiphase_pred(
-            noisy_model_input, model_pred, index, multiphase
-        )
-        with torch.no_grad():
-            w = distill_cfg
-            with torch.autocast("cuda", dtype=torch.bfloat16):
-                cond_teacher_output = teacher_transformer(
-                    noisy_model_input,
-                    encoder_hidden_states,
-                    timesteps,
-                    encoder_attention_mask,  # B, L
-                    return_dict=False,
-                )[0].float()
-            if not_apply_cfg_solver:
-                uncond_teacher_output = cond_teacher_output
-            else:
-                # Get teacher model prediction on noisy_latents and unconditional embedding
-                with torch.autocast("cuda", dtype=torch.bfloat16):
-                    uncond_teacher_output = teacher_transformer(
-                        noisy_model_input,
-                        uncond_prompt_embed.unsqueeze(0).expand(bsz, -1, -1),
-                        timesteps,
-                        uncond_prompt_mask.unsqueeze(0).expand(bsz, -1),
-                        return_dict=False,
-                    )[0].float()
-            teacher_output = cond_teacher_output + w * (
-                cond_teacher_output - uncond_teacher_output
-            )
-            x_prev = solver.euler_step(noisy_model_input, teacher_output, index)
-
-        # 20.4.12. Get target LCM prediction on x_prev, w, c, t_n
-        with torch.no_grad():
-            with torch.autocast("cuda", dtype=torch.bfloat16):
-                if ema_transformer is not None:
-                    target_pred = ema_transformer(
-                        x_prev.float(),
-                        encoder_hidden_states,
-                        timesteps_prev,
-                        encoder_attention_mask,  # B, L
-                        return_dict=False,
-                    )[0]
-                else:
-                    target_pred = transformer(
-                        x_prev.float(),
-                        encoder_hidden_states,
-                        timesteps_prev,
-                        encoder_attention_mask,  # B, L
-                        return_dict=False,
-                    )[0]
-
-            target, end_index = solver.euler_style_multiphase_pred(
-                x_prev, target_pred, index, multiphase, True
-            )
-
-        huber_c = 0.001
-        # loss = loss.mean()
-        loss = (
-            torch.mean(
-                torch.sqrt((model_pred.float() - target.float()) ** 2 + huber_c**2)
-                - huber_c
-            )
-            / gradient_accumulation_steps
-        )
-        if pred_decay_weight > 0:
-            if pred_decay_type == "l1":
-                pred_decay_loss = (
-                    torch.mean(torch.sqrt(model_pred.float() ** 2))
-                    * pred_decay_weight
-                    / gradient_accumulation_steps
-                )
-                loss += pred_decay_loss
-            elif pred_decay_type == "l2":
-                # essnetially k2?
-                pred_decay_loss = (
-                    torch.mean(model_pred.float() ** 2)
-                    * pred_decay_weight
-                    / gradient_accumulation_steps
-                )
-                loss += pred_decay_loss
-            else:
-                assert NotImplementedError("pred_decay_type is not implemented")
-
-        # calculate model_pred norm and mean
-        get_norm(
-            model_pred.detach().float(), model_pred_norm, gradient_accumulation_steps
-        )
-        loss.backward()
-
-        avg_loss = loss.detach().clone()
-        dist.all_reduce(avg_loss, op=dist.ReduceOp.AVG)
-        dist.all_reduce(pred_decay_loss.detach(), op=dist.ReduceOp.AVG)
-        total_loss += avg_loss.item()
-
-    # update ema
-    if ema_transformer is not None:
-        reshard_fsdp(ema_transformer)
-        for p_averaged, p_model in zip(
-            ema_transformer.parameters(), transformer.parameters()
-        ):
-            with torch.no_grad():
-                p_averaged.copy_(
-                    torch.lerp(p_averaged.detach(), p_model.detach(), 1 - ema_decay)
-                )
-
-    grad_norm = transformer.clip_grad_norm_(max_grad_norm)
-    optimizer.step()
-    lr_scheduler.step()
-
-    return total_loss, grad_norm.item(), model_pred_norm, pred_decay_loss.item()
-
-
-def main(args):
-    torch.backends.cuda.matmul.allow_tf32 = True
-
-    local_rank = int(os.environ["LOCAL_RANK"])
-    rank = int(os.environ["RANK"])
-    world_size = int(os.environ["WORLD_SIZE"])
-    dist.init_process_group("nccl")
-    torch.cuda.set_device(local_rank)
-    device = torch.cuda.current_device()
-    initialize_sequence_parallel_state(args.sp_size)
-
-    # If passed along, set the training seed now. On GPU...
-    if args.seed is not None:
-        # TODO: t within the same seq parallel group should be the same. Noise should be different.
-        set_seed(args.seed + rank)
-    # We use different seeds for the noise generation in each process to ensure that the noise is different in a batch.
-    noise_random_generator = None
-
-    # Handle the repository creation
-    if rank <= 0 and args.output_dir is not None:
-        os.makedirs(args.output_dir, exist_ok=True)
-
-    # For mixed precision training we cast all non-trainable weigths to half-precision
-    # as these weights are only used for inference, keeping weights in full precision is not required.
-
-    # Create model:
-
-    main_print(f"--> loading model from {args.pretrained_model_name_or_path}")
-    # keep the master weight to float32
-    if args.dit_model_name_or_path:
-        transformer = transformer = MochiTransformer3DModel.from_pretrained(
-            args.dit_model_name_or_path,
-            torch_dtype=torch.float32,
-            # torch_dtype=torch.bfloat16 if args.use_lora else torch.float32,
-        )
-    else:
-        transformer = MochiTransformer3DModel.from_pretrained(
-            args.pretrained_model_name_or_path,
-            subfolder="transformer",
-            torch_dtype=torch.float32,
-            # torch_dtype=torch.bfloat16 if args.use_lora else torch.float32,
-        )
-    teacher_transformer = deepcopy(transformer)
-    if args.use_ema:
-        ema_transformer = deepcopy(transformer)
-    else:
-        ema_transformer = None
-
-    if args.use_lora:
-        transformer.requires_grad_(False)
-        transformer_lora_config = LoraConfig(
-            r=args.lora_rank,
-            lora_alpha=args.lora_alpha,
-            init_lora_weights=True,
-            target_modules=["to_k", "to_q", "to_v", "to_out.0"],
-        )
-        transformer.add_adapter(transformer_lora_config)
-
-    main_print(
-        f"  Total training parameters = {sum(p.numel() for p in transformer.parameters() if p.requires_grad) / 1e6} M"
-    )
-    main_print(
-        f"--> Initializing FSDP with sharding strategy: {args.fsdp_sharding_startegy}"
-    )
-    fsdp_kwargs = get_dit_fsdp_kwargs(
-        args.fsdp_sharding_startegy,
-        args.use_lora,
-        args.use_cpu_offload,
-        args.master_weight_type,
-    )
-
-    if args.use_lora:
-        transformer.config.lora_rank = args.lora_rank
-        transformer.config.lora_alpha = args.lora_alpha
-        transformer.config.lora_target_modules = ["to_k", "to_q", "to_v", "to_out.0"]
-        transformer._no_split_modules = ["MochiTransformerBlock"]
-        fsdp_kwargs["auto_wrap_policy"] = fsdp_kwargs["auto_wrap_policy"](transformer)
-
-    transformer = FSDP(
-        transformer,
-        **fsdp_kwargs,
-    )
-    teacher_transformer = FSDP(
-        teacher_transformer,
-        **fsdp_kwargs,
-    )
-    if args.use_ema:
-        ema_transformer = FSDP(
-            ema_transformer,
-            **fsdp_kwargs,
-        )
-    main_print(f"--> model loaded")
-
-    if args.gradient_checkpointing:
-        apply_fsdp_checkpointing(transformer, args.selective_checkpointing)
-        apply_fsdp_checkpointing(teacher_transformer, args.selective_checkpointing)
-        if args.use_ema:
-            apply_fsdp_checkpointing(ema_transformer, args.selective_checkpointing)
-    # Set model as trainable.
-    transformer.train()
-    teacher_transformer.requires_grad_(False)
-    if args.use_ema:
-        ema_transformer.requires_grad_(False)
-    noise_scheduler = FlowMatchEulerDiscreteScheduler(shift=args.shift)
-    if args.scheduler_type == "pcm_linear_quadratic":
-        linear_steps = int(
-            noise_scheduler.config.num_train_timesteps * args.linear_range
-        )
-        sigmas = linear_quadratic_schedule(
-            noise_scheduler.config.num_train_timesteps,
-            args.linear_quadratic_threshold,
-            linear_steps,
-        )
-        sigmas = torch.tensor(sigmas).to(dtype=torch.float32)
-    else:
-        sigmas = noise_scheduler.sigmas
-    solver = EulerSolver(
-        sigmas.numpy()[::-1],
-        noise_scheduler.config.num_train_timesteps,
-        euler_timesteps=args.num_euler_timesteps,
-    )
-    solver.to(device)
-    params_to_optimize = transformer.parameters()
-    params_to_optimize = list(filter(lambda p: p.requires_grad, params_to_optimize))
-
-    optimizer = torch.optim.AdamW(
-        params_to_optimize,
-        lr=args.learning_rate,
-        betas=(0.9, 0.999),
-        weight_decay=args.weight_decay,
-        eps=1e-8,
-    )
-
-    init_steps = 0
-    if args.resume_from_lora_checkpoint:
-        transformer, optimizer, init_steps = resume_lora_optimizer(
-            transformer, args.resume_from_lora_checkpoint, optimizer
-        )
-    main_print(f"optimizer: {optimizer}")
-
-    # todo add lr scheduler
-    lr_scheduler = get_scheduler(
-        args.lr_scheduler,
-        optimizer=optimizer,
-        num_warmup_steps=args.lr_warmup_steps * world_size,
-        num_training_steps=args.max_train_steps * world_size,
-        num_cycles=args.lr_num_cycles,
-        power=args.lr_power,
-        last_epoch=init_steps - 1,
-    )
-
-    train_dataset = LatentDataset(args.data_json_path, args.num_latent_t, args.cfg)
-    uncond_prompt_embed = train_dataset.uncond_prompt_embed
-    uncond_prompt_mask = train_dataset.uncond_prompt_mask
-    sampler = (
-        LengthGroupedSampler(
-            args.train_batch_size,
-            rank=rank,
-            world_size=world_size,
-            lengths=train_dataset.lengths,
-            group_frame=args.group_frame,
-            group_resolution=args.group_resolution,
-        )
-        if (args.group_frame or args.group_resolution)
-        else DistributedSampler(
-            train_dataset, rank=rank, num_replicas=world_size, shuffle=False
-        )
-    )
-
-    train_dataloader = DataLoader(
-        train_dataset,
-        sampler=sampler,
-        collate_fn=latent_collate_function,
-        pin_memory=True,
-        batch_size=args.train_batch_size,
-        num_workers=args.dataloader_num_workers,
-        drop_last=True,
-    )
-
-    num_update_steps_per_epoch = math.ceil(
-        len(train_dataloader)
-        / args.gradient_accumulation_steps
-        * args.sp_size
-        / args.train_sp_batch_size
-    )
-    args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
-
-    if rank <= 0:
-        project = args.tracker_project_name or "fastvideo"
-        wandb.init(project=project, config=args)
-
-    # Train!
-    total_batch_size = (
-        args.train_batch_size
-        * world_size
-        * args.gradient_accumulation_steps
-        / args.sp_size
-        * args.train_sp_batch_size
-    )
-    main_print("***** Running training *****")
-    main_print(f"  Num examples = {len(train_dataset)}")
-    main_print(f"  Dataloader size = {len(train_dataloader)}")
-    main_print(f"  Num Epochs = {args.num_train_epochs}")
-    main_print(f"  Resume training from step {init_steps}")
-    main_print(f"  Instantaneous batch size per device = {args.train_batch_size}")
-    main_print(
-        f"  Total train batch size (w. data & sequence parallel, accumulation) = {total_batch_size}"
-    )
-    main_print(f"  Gradient Accumulation steps = {args.gradient_accumulation_steps}")
-    main_print(f"  Total optimization steps = {args.max_train_steps}")
-    main_print(
-        f"  Total training parameters per FSDP shard = {sum(p.numel() for p in transformer.parameters() if p.requires_grad) / 1e9} B"
-    )
-    # print dtype
-    main_print(f"  Master weight dtype: {transformer.parameters().__next__().dtype}")
-
-    # Potentially load in the weights and states from a previous save
-    if args.resume_from_checkpoint:
-        assert NotImplementedError("resume_from_checkpoint is not supported now.")
-        # TODO
-
-    progress_bar = tqdm(
-        range(0, args.max_train_steps),
-        initial=init_steps,
-        desc="Steps",
-        # Only show the progress bar once on each machine.
-        disable=local_rank > 0,
-    )
-
-    loader = sp_parallel_dataloader_wrapper(
-        train_dataloader,
-        device,
-        args.train_batch_size,
-        args.sp_size,
-        args.train_sp_batch_size,
-    )
-
-    step_times = deque(maxlen=100)
-
-    # todo future
-    for i in range(init_steps):
-        next(loader)
-
-    # log_validation(args, transformer, device,
-    #             torch.bfloat16, 0, scheduler_type=args.scheduler_type, shift=args.shift, num_euler_timesteps=args.num_euler_timesteps, linear_quadratic_threshold=args.linear_quadratic_threshold,ema=False)
-    def get_num_phases(multi_phased_distill_schedule, step):
-        # step-phase,step-phase
-        multi_phases = multi_phased_distill_schedule.split(",")
-        phase = multi_phases[-1].split("-")[-1]
-        for step_phases in multi_phases:
-            phase_step, phase = step_phases.split("-")
-            if step <= int(phase_step):
-                return int(phase)
-        return phase
-
-    for step in range(init_steps + 1, args.max_train_steps + 1):
-        start_time = time.time()
-        assert args.multi_phased_distill_schedule is not None
-        num_phases = get_num_phases(args.multi_phased_distill_schedule, step)
-
-        loss, grad_norm, pred_norm, aux_loss = train_one_step_mochi(
-            transformer,
-            teacher_transformer,
-            ema_transformer,
-            optimizer,
-            lr_scheduler,
-            loader,
-            noise_scheduler,
-            solver,
-            noise_random_generator,
-            args.gradient_accumulation_steps,
-            args.sp_size,
-            args.max_grad_norm,
-            uncond_prompt_embed,
-            uncond_prompt_mask,
-            args.num_euler_timesteps,
-            num_phases,
-            args.not_apply_cfg_solver,
-            args.distill_cfg,
-            args.ema_decay,
-            args.pred_decay_weight,
-            args.pred_decay_type,
-        )
-
-        step_time = time.time() - start_time
-        step_times.append(step_time)
-        avg_step_time = sum(step_times) / len(step_times)
-
-        progress_bar.set_postfix(
-            {
-                "loss": f"{loss:.4f}",
-                "step_time": f"{step_time:.2f}s",
-                "grad_norm": grad_norm,
-                "phases": num_phases,
-            }
-        )
-        progress_bar.update(1)
-        if rank <= 0:
-            wandb.log(
-                {
-                    "train_loss": loss,
-                    "learning_rate": lr_scheduler.get_last_lr()[0],
-                    "step_time": step_time,
-                    "avg_step_time": avg_step_time,
-                    "grad_norm": grad_norm,
-                    "pred_fro_norm": pred_norm["fro"],
-                    "pred_largest_singular_value": pred_norm["largest singular value"],
-                    "pred_absolute_mean": pred_norm["absolute mean"],
-                    "pred_absolute_max": pred_norm["absolute max"],
-                    "aux_loss": aux_loss,
-                },
-                step=step,
-            )
-        if step % args.checkpointing_steps == 0:
-            if args.use_lora:
-                # Save LoRA weights
-                save_lora_checkpoint(
-                    transformer, optimizer, rank, args.output_dir, step
-                )
-            else:
-                # Your existing checkpoint saving code
-                if args.use_ema:
-                    save_checkpoint(ema_transformer, rank, args.output_dir, step)
-                else:
-                    save_checkpoint(transformer, rank, args.output_dir, step)
-            dist.barrier()
-        if args.log_validation and step % args.validation_steps == 0:
-            log_validation(
-                args,
-                transformer,
-                device,
-                torch.bfloat16,
-                step,
-                scheduler_type=args.scheduler_type,
-                shift=args.shift,
-                num_euler_timesteps=args.num_euler_timesteps,
-                linear_quadratic_threshold=args.linear_quadratic_threshold,
-                linear_range=args.linear_range,
-                ema=False,
-            )
-            if args.use_ema:
-                log_validation(
-                    args,
-                    ema_transformer,
-                    device,
-                    torch.bfloat16,
-                    step,
-                    scheduler_type=args.scheduler_type,
-                    shift=args.shift,
-                    num_euler_timesteps=args.num_euler_timesteps,
-                    linear_quadratic_threshold=args.linear_quadratic_threshold,
-                    linear_range=args.linear_range,
-                    ema=True,
-                )
-
-    if args.use_lora:
-        save_lora_checkpoint(
-            transformer, optimizer, rank, args.output_dir, args.max_train_steps
-        )
-    else:
-        save_checkpoint(transformer, rank, args.output_dir, args.max_train_steps)
-
-    if get_sequence_parallel_state():
-        destroy_sequence_parallel_group()
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    # dataset & dataloader
-    parser.add_argument("--data_json_path", type=str, required=True)
-    parser.add_argument("--num_frames", type=int, default=163)
-    parser.add_argument(
-        "--dataloader_num_workers",
-        type=int,
-        default=10,
-        help="Number of subprocesses to use for data loading. 0 means that the data will be loaded in the main process.",
-    )
-    parser.add_argument(
-        "--train_batch_size",
-        type=int,
-        default=16,
-        help="Batch size (per device) for the training dataloader.",
-    )
-    parser.add_argument(
-        "--num_latent_t", type=int, default=28, help="Number of latent timesteps."
-    )
-    parser.add_argument("--group_frame", action="store_true")  # TODO
-    parser.add_argument("--group_resolution", action="store_true")  # TODO
-
-    # text encoder & vae & diffusion model
-    parser.add_argument("--pretrained_model_name_or_path", type=str)
-    parser.add_argument("--dit_model_name_or_path", type=str)
-    parser.add_argument("--cache_dir", type=str, default="./cache_dir")
-
-    # diffusion setting
-    parser.add_argument("--ema_decay", type=float, default=0.95)
-    parser.add_argument("--ema_start_step", type=int, default=0)
-    parser.add_argument("--cfg", type=float, default=0.1)
-
-    # validation & logs
-    parser.add_argument("--validation_prompt_dir", type=str)
-    parser.add_argument("--validation_sampling_steps", type=str, default="64")
-    parser.add_argument("--validation_guidance_scale", type=str, default="4.5")
-
-    parser.add_argument("--validation_steps", type=float, default=64)
-    parser.add_argument("--log_validation", action="store_true")
-    parser.add_argument("--tracker_project_name", type=str, default=None)
-    parser.add_argument(
-        "--seed", type=int, default=None, help="A seed for reproducible training."
-    )
-    parser.add_argument(
-        "--output_dir",
-        type=str,
-        default=None,
-        help="The output directory where the model predictions and checkpoints will be written.",
-    )
-    parser.add_argument(
-        "--checkpoints_total_limit",
-        type=int,
-        default=None,
-        help=("Max number of checkpoints to store."),
-    )
-    parser.add_argument(
-        "--checkpointing_steps",
-        type=int,
-        default=500,
-        help=(
-            "Save a checkpoint of the training state every X updates. These checkpoints can be used both as final"
-            " checkpoints in case they are better than the last checkpoint, and are also suitable for resuming"
-            " training using `--resume_from_checkpoint`."
-        ),
-    )
-    parser.add_argument("--shift", type=float, default=1.0)
-    parser.add_argument(
-        "--resume_from_checkpoint",
-        type=str,
-        default=None,
-        help=(
-            "Whether training should be resumed from a previous checkpoint. Use a path saved by"
-            ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.'
-        ),
-    )
-    parser.add_argument(
-        "--resume_from_lora_checkpoint",
-        type=str,
-        default=None,
-        help=(
-            "Whether training should be resumed from a previous lora checkpoint. Use a path saved by"
-            ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.'
-        ),
-    )
-    parser.add_argument(
-        "--logging_dir",
-        type=str,
-        default="logs",
-        help=(
-            "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to"
-            " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***."
-        ),
-    )
-
-    # optimizer & scheduler & Training
-    parser.add_argument("--num_train_epochs", type=int, default=100)
-    parser.add_argument(
-        "--max_train_steps",
-        type=int,
-        default=None,
-        help="Total number of training steps to perform.  If provided, overrides num_train_epochs.",
-    )
-    parser.add_argument(
-        "--gradient_accumulation_steps",
-        type=int,
-        default=1,
-        help="Number of updates steps to accumulate before performing a backward/update pass.",
-    )
-    parser.add_argument(
-        "--learning_rate",
-        type=float,
-        default=1e-4,
-        help="Initial learning rate (after the potential warmup period) to use.",
-    )
-    parser.add_argument(
-        "--scale_lr",
-        action="store_true",
-        default=False,
-        help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.",
-    )
-    parser.add_argument(
-        "--lr_warmup_steps",
-        type=int,
-        default=10,
-        help="Number of steps for the warmup in the lr scheduler.",
-    )
-    parser.add_argument(
-        "--max_grad_norm", default=1.0, type=float, help="Max gradient norm."
-    )
-    parser.add_argument(
-        "--gradient_checkpointing",
-        action="store_true",
-        help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.",
-    )
-    parser.add_argument("--selective_checkpointing", type=float, default=1.0)
-    parser.add_argument(
-        "--allow_tf32",
-        action="store_true",
-        help=(
-            "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see"
-            " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices"
-        ),
-    )
-    parser.add_argument(
-        "--mixed_precision",
-        type=str,
-        default=None,
-        choices=["no", "fp16", "bf16"],
-        help=(
-            "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >="
-            " 1.10.and an Nvidia Ampere GPU.  Default to the value of accelerate config of the current system or the"
-            " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config."
-        ),
-    )
-    parser.add_argument(
-        "--use_cpu_offload",
-        action="store_true",
-        help="Whether to use CPU offload for param & gradient & optimizer states.",
-    )
-
-    parser.add_argument("--sp_size", type=int, default=1, help="For sequence parallel")
-    parser.add_argument(
-        "--train_sp_batch_size",
-        type=int,
-        default=1,
-        help="Batch size for sequence parallel training",
-    )
-
-    parser.add_argument(
-        "--use_lora",
-        action="store_true",
-        default=False,
-        help="Whether to use LoRA for finetuning.",
-    )
-    parser.add_argument(
-        "--lora_alpha", type=int, default=256, help="Alpha parameter for LoRA."
-    )
-    parser.add_argument(
-        "--lora_rank", type=int, default=128, help="LoRA rank parameter. "
-    )
-    parser.add_argument("--fsdp_sharding_startegy", default="full")
-
-    # lr_scheduler
-    parser.add_argument(
-        "--lr_scheduler",
-        type=str,
-        default="constant",
-        help=(
-            'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",'
-            ' "constant", "constant_with_warmup"]'
-        ),
-    )
-    parser.add_argument("--num_euler_timesteps", type=int, default=100)
-    parser.add_argument(
-        "--lr_num_cycles",
-        type=int,
-        default=1,
-        help="Number of cycles in the learning rate scheduler.",
-    )
-    parser.add_argument(
-        "--lr_power",
-        type=float,
-        default=1.0,
-        help="Power factor of the polynomial scheduler.",
-    )
-    parser.add_argument(
-        "--not_apply_cfg_solver",
-        action="store_true",
-        help="Whether to apply the cfg_solver.",
-    )
-    parser.add_argument(
-        "--distill_cfg", type=float, default=3.0, help="Distillation coefficient."
-    )
-    # ["euler_linear_quadratic", "pcm", "pcm_linear_qudratic"]
-    parser.add_argument(
-        "--scheduler_type", type=str, default="pcm", help="The scheduler type to use."
-    )
-    parser.add_argument(
-        "--linear_quadratic_threshold",
-        type=float,
-        default=0.025,
-        help="Threshold for linear quadratic scheduler.",
-    )
-    parser.add_argument(
-        "--linear_range",
-        type=float,
-        default=0.5,
-        help="Range for linear quadratic scheduler.",
-    )
-    parser.add_argument(
-        "--weight_decay", type=float, default=0.001, help="Weight decay to apply."
-    )
-    parser.add_argument("--use_ema", action="store_true", help="Whether to use EMA.")
-    parser.add_argument("--multi_phased_distill_schedule", type=str, default=None)
-    parser.add_argument("--finetune_weight", type=float, default=0.0)
-    parser.add_argument("--pred_decay_weight", type=float, default=0.0)
-    parser.add_argument("--pred_decay_type", default="l1")
-    parser.add_argument(
-        "--master_weight_type",
-        type=str,
-        default="fp32",
-        help="Weight type to use - fp32 or bf16.",
-    )
-    args = parser.parse_args()
-    main(args)

fastvideo/distill/discriminator.py

@@ -1,102 +0,0 @@
-from typing import Any, Dict, Optional, Union
-
-import torch
-import torch.nn as nn
-
-from diffusers.configuration_utils import ConfigMixin, register_to_config
-from diffusers.loaders import FromOriginalModelMixin, PeftAdapterMixin
-from diffusers.models.attention import JointTransformerBlock
-from diffusers.models.attention_processor import Attention, AttentionProcessor
-from diffusers.models.modeling_utils import ModelMixin
-from diffusers.models.normalization import AdaLayerNormContinuous
-from diffusers.utils import (
-    USE_PEFT_BACKEND,
-    is_torch_version,
-    logging,
-    scale_lora_layers,
-    unscale_lora_layers,
-)
-from diffusers.models.embeddings import CombinedTimestepTextProjEmbeddings, PatchEmbed
-from diffusers.models.transformers.transformer_2d import Transformer2DModelOutput
-from diffusers.models.transformers.transformer_sd3 import SD3Transformer2DModel
-
-logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
-
-
-class DiscriminatorHead(nn.Module):
-    def __init__(self, input_channel, output_channel=1):
-        super().__init__()
-        inner_channel = 1024
-        self.conv1 = nn.Sequential(
-            nn.Conv2d(input_channel, inner_channel, 1, 1, 0),
-            nn.GroupNorm(32, inner_channel),
-            nn.LeakyReLU(
-                inplace=True
-            ),  # use LeakyReLu instead of GELU shown in the paper to save memory
-        )
-        self.conv2 = nn.Sequential(
-            nn.Conv2d(inner_channel, inner_channel, 1, 1, 0),
-            nn.GroupNorm(32, inner_channel),
-            nn.LeakyReLU(
-                inplace=True
-            ),  # use LeakyReLu instead of GELU shown in the paper to save memory
-        )
-
-        self.conv_out = nn.Conv2d(inner_channel, output_channel, 1, 1, 0)
-
-    def forward(self, x):
-        b, twh, c = x.shape
-        t = twh // (30 * 53)
-        x = x.view(-1, 30 * 53, c)
-        x = x.permute(0, 2, 1)
-        x = x.view(b * t, c, 30, 53)
-        x = self.conv1(x)
-        x = self.conv2(x) + x
-        x = self.conv_out(x)
-        return x
-
-
-class Discriminator(nn.Module):
-    def __init__(
-        self,
-        stride=8,
-        num_h_per_head=1,
-        adapter_channel_dims=[3072],
-    ):
-        super().__init__()
-        adapter_channel_dims = adapter_channel_dims * (48 // stride)
-        self.stride = stride
-        self.num_h_per_head = num_h_per_head
-        self.head_num = len(adapter_channel_dims)
-        self.heads = nn.ModuleList(
-            [
-                nn.ModuleList(
-                    [
-                        DiscriminatorHead(adapter_channel)
-                        for _ in range(self.num_h_per_head)
-                    ]
-                )
-                for adapter_channel in adapter_channel_dims
-            ]
-        )
-
-    def forward(self, features):
-        outputs = []
-
-        def create_custom_forward(module):
-            def custom_forward(*inputs):
-                return module(*inputs)
-
-            return custom_forward
-
-        assert len(features) // self.stride == len(self.heads)
-        for i in range(0, len(features), self.stride):
-            for h in self.heads[i // self.stride]:
-                # out = torch.utils.checkpoint.checkpoint(
-                #     create_custom_forward(h),
-                #     features[i],
-                #     use_reentrant=False
-                # )
-                out = h(features[i])
-                outputs.append(out)
-        return outputs

fastvideo/distill/solver.py

@@ -1,309 +0,0 @@
-from dataclasses import dataclass
-from typing import Optional, Tuple, Union
-
-import numpy as np
-import torch
-
-from diffusers.configuration_utils import ConfigMixin, register_to_config
-from diffusers.utils import BaseOutput, logging
-from diffusers.utils.torch_utils import randn_tensor
-from diffusers.schedulers.scheduling_utils import SchedulerMixin
-from fastvideo.models.mochi_hf.pipeline_mochi import linear_quadratic_schedule
-
-logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
-
-
-@dataclass
-class PCMFMSchedulerOutput(BaseOutput):
-    prev_sample: torch.FloatTensor
-
-
-def extract_into_tensor(a, t, x_shape):
-    b, *_ = t.shape
-    out = a.gather(-1, t)
-    return out.reshape(b, *((1,) * (len(x_shape) - 1)))
-
-
-class PCMFMScheduler(SchedulerMixin, ConfigMixin):
-    _compatibles = []
-    order = 1
-
-    @register_to_config
-    def __init__(
-        self,
-        num_train_timesteps: int = 1000,
-        shift: float = 1.0,
-        pcm_timesteps: int = 50,
-        linear_quadratic=False,
-        linear_quadratic_threshold=0.025,
-        linear_range=0.5,
-    ):
-        if linear_quadratic:
-            linear_steps = int(num_train_timesteps * linear_range)
-            sigmas = linear_quadratic_schedule(
-                num_train_timesteps, linear_quadratic_threshold, linear_steps
-            )
-            sigmas = torch.tensor(sigmas).to(dtype=torch.float32)
-        else:
-            timesteps = np.linspace(
-                1, num_train_timesteps, num_train_timesteps, dtype=np.float32
-            )[::-1].copy()
-            timesteps = torch.from_numpy(timesteps).to(dtype=torch.float32)
-            sigmas = timesteps / num_train_timesteps
-            sigmas = shift * sigmas / (1 + (shift - 1) * sigmas)
-        self.euler_timesteps = (
-            np.arange(1, pcm_timesteps + 1) * (num_train_timesteps // pcm_timesteps)
-        ).round().astype(np.int64) - 1
-        self.sigmas = sigmas.numpy()[::-1][self.euler_timesteps]
-        self.sigmas = torch.from_numpy((self.sigmas[::-1].copy()))
-        self.timesteps = self.sigmas * num_train_timesteps
-        self._step_index = None
-        self._begin_index = None
-        self.sigmas = self.sigmas.to("cpu")  # to avoid too much CPU/GPU communication
-        self.sigma_min = self.sigmas[-1].item()
-        self.sigma_max = self.sigmas[0].item()
-
-    @property
-    def step_index(self):
-        """
-        The index counter for current timestep. It will increase 1 after each scheduler step.
-        """
-        return self._step_index
-
-    @property
-    def begin_index(self):
-        """
-        The index for the first timestep. It should be set from pipeline with `set_begin_index` method.
-        """
-        return self._begin_index
-
-    # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.set_begin_index
-    def set_begin_index(self, begin_index: int = 0):
-        """
-        Sets the begin index for the scheduler. This function should be run from pipeline before the inference.
-
-        Args:
-            begin_index (`int`):
-                The begin index for the scheduler.
-        """
-        self._begin_index = begin_index
-
-    def scale_noise(
-        self,
-        sample: torch.FloatTensor,
-        timestep: Union[float, torch.FloatTensor],
-        noise: Optional[torch.FloatTensor] = None,
-    ) -> torch.FloatTensor:
-        """
-        Forward process in flow-matching
-
-        Args:
-            sample (`torch.FloatTensor`):
-                The input sample.
-            timestep (`int`, *optional*):
-                The current timestep in the diffusion chain.
-
-        Returns:
-            `torch.FloatTensor`:
-                A scaled input sample.
-        """
-        if self.step_index is None:
-            self._init_step_index(timestep)
-
-        sigma = self.sigmas[self.step_index]
-        sample = sigma * noise + (1.0 - sigma) * sample
-
-        return sample
-
-    def _sigma_to_t(self, sigma):
-        return sigma * self.config.num_train_timesteps
-
-    def set_timesteps(
-        self, num_inference_steps: int, device: Union[str, torch.device] = None
-    ):
-        """
-        Sets the discrete timesteps used for the diffusion chain (to be run before inference).
-
-        Args:
-            num_inference_steps (`int`):
-                The number of diffusion steps used when generating samples with a pre-trained model.
-            device (`str` or `torch.device`, *optional*):
-                The device to which the timesteps should be moved to. If `None`, the timesteps are not moved.
-        """
-        self.num_inference_steps = num_inference_steps
-        inference_indices = np.linspace(
-            0, self.config.pcm_timesteps, num=num_inference_steps, endpoint=False
-        )
-        inference_indices = np.floor(inference_indices).astype(np.int64)
-        inference_indices = torch.from_numpy(inference_indices).long()
-
-        self.sigmas_ = self.sigmas[inference_indices]
-        timesteps = self.sigmas_ * self.config.num_train_timesteps
-        self.timesteps = timesteps.to(device=device)
-        self.sigmas_ = torch.cat(
-            [self.sigmas_, torch.zeros(1, device=self.sigmas_.device)]
-        )
-        self._step_index = None
-        self._begin_index = None
-
-    def index_for_timestep(self, timestep, schedule_timesteps=None):
-        if schedule_timesteps is None:
-            schedule_timesteps = self.timesteps
-
-        indices = (schedule_timesteps == timestep).nonzero()
-
-        # The sigma index that is taken for the **very** first `step`
-        # is always the second index (or the last index if there is only 1)
-        # This way we can ensure we don't accidentally skip a sigma in
-        # case we start in the middle of the denoising schedule (e.g. for image-to-image)
-        pos = 1 if len(indices) > 1 else 0
-
-        return indices[pos].item()
-
-    def _init_step_index(self, timestep):
-        if self.begin_index is None:
-            if isinstance(timestep, torch.Tensor):
-                timestep = timestep.to(self.timesteps.device)
-            self._step_index = self.index_for_timestep(timestep)
-        else:
-            self._step_index = self._begin_index
-
-    def step(
-        self,
-        model_output: torch.FloatTensor,
-        timestep: Union[float, torch.FloatTensor],
-        sample: torch.FloatTensor,
-        generator: Optional[torch.Generator] = None,
-        return_dict: bool = True,
-    ) -> Union[PCMFMSchedulerOutput, Tuple]:
-        """
-        Predict the sample from the previous timestep by reversing the SDE. This function propagates the diffusion
-        process from the learned model outputs (most often the predicted noise).
-
-        Args:
-            model_output (`torch.FloatTensor`):
-                The direct output from learned diffusion model.
-            timestep (`float`):
-                The current discrete timestep in the diffusion chain.
-            sample (`torch.FloatTensor`):
-                A current instance of a sample created by the diffusion process.
-            s_churn (`float`):
-            s_tmin  (`float`):
-            s_tmax  (`float`):
-            s_noise (`float`, defaults to 1.0):
-                Scaling factor for noise added to the sample.
-            generator (`torch.Generator`, *optional*):
-                A random number generator.
-            return_dict (`bool`):
-                Whether or not to return a [`~schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput`] or
-                tuple.
-
-        Returns:
-            [`~schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput`] or `tuple`:
-                If return_dict is `True`, [`~schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput`] is
-                returned, otherwise a tuple is returned where the first element is the sample tensor.
-        """
-
-        if (
-            isinstance(timestep, int)
-            or isinstance(timestep, torch.IntTensor)
-            or isinstance(timestep, torch.LongTensor)
-        ):
-            raise ValueError(
-                (
-                    "Passing integer indices (e.g. from `enumerate(timesteps)`) as timesteps to"
-                    " `EulerDiscreteScheduler.step()` is not supported. Make sure to pass"
-                    " one of the `scheduler.timesteps` as a timestep."
-                ),
-            )
-
-        if self.step_index is None:
-            self._init_step_index(timestep)
-
-        sample = sample.to(torch.float32)
-
-        sigma = self.sigmas_[self.step_index]
-
-        denoised = sample - model_output * sigma
-        derivative = (sample - denoised) / sigma
-
-        dt = self.sigmas_[self.step_index + 1] - sigma
-        prev_sample = sample + derivative * dt
-        prev_sample = prev_sample.to(model_output.dtype)
-        self._step_index += 1
-
-        if not return_dict:
-            return (prev_sample,)
-
-        return PCMFMSchedulerOutput(prev_sample=prev_sample)
-
-    def __len__(self):
-        return self.config.num_train_timesteps
-
-
-class EulerSolver:
-    def __init__(self, sigmas, timesteps=1000, euler_timesteps=50):
-        self.step_ratio = timesteps // euler_timesteps
-        self.euler_timesteps = (
-            np.arange(1, euler_timesteps + 1) * self.step_ratio
-        ).round().astype(np.int64) - 1
-        self.euler_timesteps_prev = np.asarray([0] + self.euler_timesteps[:-1].tolist())
-        self.sigmas = sigmas[self.euler_timesteps]
-        self.sigmas_prev = np.asarray(
-            [sigmas[0]] + sigmas[self.euler_timesteps[:-1]].tolist()
-        )  # either use sigma0 or 0
-
-        self.euler_timesteps = torch.from_numpy(self.euler_timesteps).long()
-        self.euler_timesteps_prev = torch.from_numpy(self.euler_timesteps_prev).long()
-        self.sigmas = torch.from_numpy(self.sigmas)
-        self.sigmas_prev = torch.from_numpy(self.sigmas_prev)
-
-    def to(self, device):
-        self.euler_timesteps = self.euler_timesteps.to(device)
-        self.euler_timesteps_prev = self.euler_timesteps_prev.to(device)
-
-        self.sigmas = self.sigmas.to(device)
-        self.sigmas_prev = self.sigmas_prev.to(device)
-        return self
-
-    def euler_step(self, sample, model_pred, timestep_index):
-        sigma = extract_into_tensor(self.sigmas, timestep_index, model_pred.shape)
-        sigma_prev = extract_into_tensor(
-            self.sigmas_prev, timestep_index, model_pred.shape
-        )
-        x_prev = sample + (sigma_prev - sigma) * model_pred
-        return x_prev
-
-    def euler_style_multiphase_pred(
-        self,
-        sample,
-        model_pred,
-        timestep_index,
-        multiphase,
-        is_target=False,
-    ):
-        inference_indices = np.linspace(
-            0, len(self.euler_timesteps), num=multiphase, endpoint=False
-        )
-        inference_indices = np.floor(inference_indices).astype(np.int64)
-        inference_indices = (
-            torch.from_numpy(inference_indices).long().to(self.euler_timesteps.device)
-        )
-        expanded_timestep_index = timestep_index.unsqueeze(1).expand(
-            -1, inference_indices.size(0)
-        )
-        valid_indices_mask = expanded_timestep_index >= inference_indices
-        last_valid_index = valid_indices_mask.flip(dims=[1]).long().argmax(dim=1)
-        last_valid_index = inference_indices.size(0) - 1 - last_valid_index
-        timestep_index_end = inference_indices[last_valid_index]
-
-        if is_target:
-            sigma = extract_into_tensor(self.sigmas_prev, timestep_index, sample.shape)
-        else:
-            sigma = extract_into_tensor(self.sigmas, timestep_index, sample.shape)
-        sigma_prev = extract_into_tensor(
-            self.sigmas_prev, timestep_index_end, sample.shape
-        )
-        x_prev = sample + (sigma_prev - sigma) * model_pred
-
-        return x_prev, timestep_index_end

fastvideo/distill_adv.py

@@ -1,936 +0,0 @@
-import argparse
-from email.policy import strict
-import logging
-import math
-import os
-import shutil
-from pathlib import Path
-from fastvideo.utils.parallel_states import (
-    initialize_sequence_parallel_state,
-    destroy_sequence_parallel_group,
-    get_sequence_parallel_state,
-    nccl_info,
-)
-from fastvideo.utils.communications import sp_parallel_dataloader_wrapper, broadcast
-from fastvideo.models.mochi_hf.mochi_latents_utils import normalize_mochi_dit_input
-from fastvideo.utils.validation import log_validation
-import time
-from torch.utils.data import DataLoader
-import torch
-from torch.distributed.fsdp import (
-    FullyShardedDataParallel as FSDP,
-    StateDictType,
-    FullStateDictConfig,
-)
-
-from fastvideo.models.mochi_hf.pipeline_mochi import linear_quadratic_schedule
-import json
-from torch.utils.data.distributed import DistributedSampler
-from fastvideo.utils.dataset_utils import LengthGroupedSampler
-import wandb
-from accelerate.utils import set_seed
-from tqdm.auto import tqdm
-from fastvideo.fsdp_util import (
-    get_dit_fsdp_kwargs,
-    apply_fsdp_checkpointing,
-    get_discriminator_fsdp_kwargs,
-)
-import diffusers
-from diffusers import (
-    FlowMatchEulerDiscreteScheduler,
-)
-from fastvideo.distill.discriminator import Discriminator
-from fastvideo.distill.solver import EulerSolver, extract_into_tensor
-from copy import deepcopy
-from diffusers.optimization import get_scheduler
-from fastvideo.models.mochi_hf.modeling_mochi import MochiTransformer3DModel
-from diffusers.utils import check_min_version
-from fastvideo.dataset.latent_datasets import LatentDataset, latent_collate_function
-import torch.distributed as dist
-from peft import LoraConfig
-from torch.distributed.fsdp import (
-    FullyShardedDataParallel as FSDP,
-)
-from fastvideo.utils.checkpoint import (
-    save_checkpoint,
-    save_lora_checkpoint,
-    resume_lora_optimizer,
-    resume_training,
-    save_checkpoint_generator_discriminator,
-    resume_training_generator_discriminator,
-)
-from fastvideo.utils.logging import main_print
-
-# Will error if the minimal version of diffusers is not installed. Remove at your own risks.
-check_min_version("0.31.0")
-import time
-from collections import deque
-
-
-def gan_d_loss(
-    discriminator,
-    teacher_transformer,
-    sample_fake,
-    sample_real,
-    timestep,
-    encoder_hidden_states,
-    encoder_attention_mask,
-    weight,
-):
-    loss = 0.0
-    # collate sample_fake and sample_real
-    with torch.no_grad():
-        fake_features = teacher_transformer(
-            sample_fake,
-            encoder_hidden_states,
-            timestep,
-            encoder_attention_mask,
-            output_attn=True,
-            return_dict=False,
-        )[1]
-        real_features = teacher_transformer(
-            sample_real,
-            encoder_hidden_states,
-            timestep,
-            encoder_attention_mask,
-            output_attn=True,
-            return_dict=False,
-        )[1]
-
-    fake_outputs = discriminator(fake_features)
-    real_outputs = discriminator(real_features)
-    for fake_output, real_output in zip(fake_outputs, real_outputs):
-        loss += (
-            torch.mean(weight * torch.relu(fake_output.float() + 1))
-            + torch.mean(weight * torch.relu(1 - real_output.float()))
-        ) / (discriminator.head_num * discriminator.num_h_per_head)
-    return loss
-
-
-def gan_g_loss(
-    discriminator,
-    teacher_transformer,
-    sample_fake,
-    timestep,
-    encoder_hidden_states,
-    encoder_attention_mask,
-    weight,
-):
-    loss = 0.0
-    features = teacher_transformer(
-        sample_fake,
-        encoder_hidden_states,
-        timestep,
-        encoder_attention_mask,
-        output_attn=True,
-        return_dict=False,
-    )[1]
-    fake_outputs = discriminator(
-        features,
-    )
-    for fake_output in fake_outputs:
-        loss += torch.mean(weight * torch.relu(1 - fake_output.float())) / (
-            discriminator.head_num * discriminator.num_h_per_head
-        )
-    return loss
-
-
-def train_one_step_mochi(
-    transformer,
-    teacher_transformer,
-    optimizer,
-    discriminator,
-    discriminator_optimizer,
-    global_step,
-    lr_scheduler,
-    loader,
-    noise_scheduler,
-    solver,
-    noise_random_generator,
-    sp_size,
-    precondition_outputs,
-    max_grad_norm,
-    uncond_prompt_embed,
-    uncond_prompt_mask,
-    num_euler_timesteps,
-    multiphase,
-    not_apply_cfg_solver,
-    distill_cfg,
-    adv_weight,
-):
-    optimizer.zero_grad()
-    discriminator_optimizer.zero_grad()
-
-    (
-        latents,
-        encoder_hidden_states,
-        latents_attention_mask,
-        encoder_attention_mask,
-    ) = next(loader)
-    model_input = normalize_mochi_dit_input(latents)
-    noise = torch.randn_like(model_input)
-    bsz = model_input.shape[0]
-    index = torch.randint(
-        0, num_euler_timesteps, (bsz,), device=model_input.device
-    ).long()
-    if sp_size > 1:
-        broadcast(index)
-    # Add noise according to flow matching.
-    # sigmas = get_sigmas(start_timesteps, n_dim=model_input.ndim, dtype=model_input.dtype)
-    sigmas = extract_into_tensor(solver.sigmas, index, model_input.shape)
-    sigmas_prev = extract_into_tensor(solver.sigmas_prev, index, model_input.shape)
-
-    timesteps = (sigmas * noise_scheduler.config.num_train_timesteps).view(-1)
-    # if squeeze to [], unsqueeze to [1]
-
-    timesteps_prev = (sigmas_prev * noise_scheduler.config.num_train_timesteps).view(-1)
-    noisy_model_input = sigmas * noise + (1.0 - sigmas) * model_input
-
-    # Predict the noise residual
-    with torch.autocast("cuda", dtype=torch.bfloat16):
-        model_pred = transformer(
-            noisy_model_input,
-            encoder_hidden_states,
-            timesteps,
-            encoder_attention_mask,  # B, L
-            return_dict=False,
-        )[0]
-
-    # if accelerator.is_main_process:
-    model_pred, end_index = solver.euler_style_multiphase_pred(
-        noisy_model_input, model_pred, index, multiphase
-    )
-
-    weighting = 1.0
-    # # simplified flow matching aka 0-rectified flow matching loss
-    # # target = model_input - noise
-    # target = model_input
-    adv_index = torch.empty_like(end_index)
-    for i in range(end_index.size(0)):
-        adv_index[i] = torch.randint(
-            end_index[i].item(),
-            end_index[i].item() + num_euler_timesteps // multiphase,
-            (1,),
-            dtype=end_index.dtype,
-            device=end_index.device,
-        )
-
-    sigmas_end = extract_into_tensor(solver.sigmas_prev, end_index, model_input.shape)
-    sigmas_adv = extract_into_tensor(solver.sigmas_prev, adv_index, model_input.shape)
-    timesteps_end = (sigmas_end * noise_scheduler.config.num_train_timesteps).view(-1)
-    timesteps_adv = (sigmas_adv * noise_scheduler.config.num_train_timesteps).view(-1)
-
-    with torch.no_grad():
-        w = distill_cfg
-        with torch.autocast("cuda", dtype=torch.bfloat16):
-            cond_teacher_output = teacher_transformer(
-                noisy_model_input,
-                encoder_hidden_states,
-                timesteps,
-                encoder_attention_mask,  # B, L
-                return_dict=False,
-            )[0].float()
-        if not_apply_cfg_solver:
-            uncond_teacher_output = cond_teacher_output
-        else:
-            # Get teacher model prediction on noisy_latents and unconditional embedding
-            with torch.autocast("cuda", dtype=torch.bfloat16):
-                uncond_teacher_output = teacher_transformer(
-                    noisy_model_input,
-                    uncond_prompt_embed.unsqueeze(0).expand(bsz, -1, -1),
-                    timesteps,
-                    uncond_prompt_mask.unsqueeze(0).expand(bsz, -1),
-                    return_dict=False,
-                )[0].float()
-        teacher_output = cond_teacher_output + w * (
-            cond_teacher_output - uncond_teacher_output
-        )
-        x_prev = solver.euler_step(noisy_model_input, teacher_output, index)
-
-    # 20.4.12. Get target LCM prediction on x_prev, w, c, t_n
-    with torch.no_grad():
-        with torch.autocast("cuda", dtype=torch.bfloat16):
-            target_pred = transformer(
-                x_prev.float(),
-                encoder_hidden_states,
-                timesteps_prev,
-                encoder_attention_mask,  # B, L
-                return_dict=False,
-            )[0]
-
-        target, end_index = solver.euler_style_multiphase_pred(
-            x_prev, target_pred, index, multiphase, True
-        )
-
-    real_adv = (
-        (1 - sigmas_adv) * target + (sigmas_adv - sigmas_end) * torch.randn_like(target)
-    ) / (1 - sigmas_end)
-    fake_adv = (
-        (1 - sigmas_adv) * model_pred
-        + (sigmas_adv - sigmas_end) * torch.randn_like(model_pred)
-    ) / (1 - sigmas_end)
-
-    huber_c = 0.001
-    g_loss = torch.mean(
-        torch.sqrt((model_pred.float() - target.float()) ** 2 + huber_c**2) - huber_c
-    )
-    discriminator.requires_grad_(False)
-    with torch.autocast("cuda", dtype=torch.bfloat16):
-        g_gan_loss = adv_weight * gan_g_loss(
-            discriminator,
-            teacher_transformer,
-            fake_adv.float(),
-            timesteps_adv,
-            encoder_hidden_states.float(),
-            encoder_attention_mask,
-            1.0,
-        )
-    g_loss += g_gan_loss
-    g_loss.backward()
-
-    g_loss = g_loss.detach().clone()
-    dist.all_reduce(g_loss, op=dist.ReduceOp.AVG)
-
-    g_grad_norm = transformer.clip_grad_norm_(max_grad_norm).item()
-    optimizer.step()
-    lr_scheduler.step()
-    optimizer.zero_grad()
-
-    discriminator_optimizer.zero_grad()
-    discriminator.requires_grad_(True)
-    with torch.autocast("cuda", dtype=torch.bfloat16):
-        d_loss = gan_d_loss(
-            discriminator,
-            teacher_transformer,
-            fake_adv.detach(),
-            real_adv.detach(),
-            timesteps_adv,
-            encoder_hidden_states,
-            encoder_attention_mask,
-            1.0,
-        )
-
-    d_loss.backward()
-    d_grad_norm = discriminator.clip_grad_norm_(max_grad_norm).item()
-    discriminator_optimizer.step()
-    discriminator_optimizer.zero_grad()
-
-    return g_loss, g_grad_norm, d_loss, d_grad_norm
-
-
-def main(args):
-    torch.backends.cuda.matmul.allow_tf32 = True
-
-    local_rank = int(os.environ["LOCAL_RANK"])
-    rank = int(os.environ["RANK"])
-    world_size = int(os.environ["WORLD_SIZE"])
-    dist.init_process_group("nccl")
-    torch.cuda.set_device(local_rank)
-    device = torch.cuda.current_device()
-    initialize_sequence_parallel_state(args.sp_size)
-
-    # If passed along, set the training seed now. On GPU...
-    if args.seed is not None:
-        # TODO: t within the same seq parallel group should be the same. Noise should be different.
-        set_seed(args.seed + rank)
-    # We use different seeds for the noise generation in each process to ensure that the noise is different in a batch.
-    noise_random_generator = None
-
-    # Handle the repository creation
-    if rank <= 0 and args.output_dir is not None:
-        os.makedirs(args.output_dir, exist_ok=True)
-
-    # For mixed precision training we cast all non-trainable weigths to half-precision
-    # as these weights are only used for inference, keeping weights in full precision is not required.
-
-    # Create model:
-
-    main_print(f"--> loading model from {args.pretrained_model_name_or_path}")
-    # keep the master weight to float32
-    if args.dit_model_name_or_path:
-        transformer = transformer = MochiTransformer3DModel.from_pretrained(
-            args.dit_model_name_or_path,
-            torch_dtype=torch.float32,
-            # torch_dtype=torch.bfloat16 if args.use_lora else torch.float32,
-        )
-    else:
-        transformer = MochiTransformer3DModel.from_pretrained(
-            args.pretrained_model_name_or_path,
-            subfolder="transformer",
-            torch_dtype=torch.float32,
-            # torch_dtype=torch.bfloat16 if args.use_lora else torch.float32,
-        )
-    teacher_transformer = deepcopy(transformer)
-    discriminator = Discriminator(args.discriminator_head_stride)
-
-    if args.use_lora:
-        transformer.requires_grad_(False)
-        transformer_lora_config = LoraConfig(
-            r=args.lora_rank,
-            lora_alpha=args.lora_alpha,
-            init_lora_weights=True,
-            target_modules=["to_k", "to_q", "to_v", "to_out.0"],
-        )
-        transformer.add_adapter(transformer_lora_config)
-
-    main_print(
-        f"  Total transformer parameters = {sum(p.numel() for p in transformer.parameters() if p.requires_grad) / 1e6} M"
-    )
-    # discriminator
-    main_print(
-        f"  Total discriminator parameters = {sum(p.numel() for p in discriminator.parameters() if p.requires_grad) / 1e6} M"
-    )
-    main_print(
-        f"--> Initializing FSDP with sharding strategy: {args.fsdp_sharding_startegy}"
-    )
-    fsdp_kwargs = get_dit_fsdp_kwargs(
-        args.fsdp_sharding_startegy, args.use_lora, args.use_cpu_offload
-    )
-    discriminator_fsdp_kwargs = get_discriminator_fsdp_kwargs(args.master_weight_type)
-    if args.use_lora:
-        transformer.config.lora_rank = args.lora_rank
-        transformer.config.lora_alpha = args.lora_alpha
-        transformer.config.lora_target_modules = ["to_k", "to_q", "to_v", "to_out.0"]
-        transformer._no_split_modules = ["MochiTransformerBlock"]
-        fsdp_kwargs["auto_wrap_policy"] = fsdp_kwargs["auto_wrap_policy"](transformer)
-
-    transformer = FSDP(
-        transformer,
-        **fsdp_kwargs,
-    )
-    teacher_transformer = FSDP(
-        teacher_transformer,
-        **fsdp_kwargs,
-    )
-    discriminator = FSDP(
-        discriminator,
-        **discriminator_fsdp_kwargs,
-    )
-    main_print(f"--> model loaded")
-
-    if args.gradient_checkpointing:
-        apply_fsdp_checkpointing(transformer, args.selective_checkpointing)
-        apply_fsdp_checkpointing(teacher_transformer, args.selective_checkpointing)
-    # Set model as trainable.
-    transformer.train()
-    teacher_transformer.requires_grad_(False)
-    noise_scheduler = FlowMatchEulerDiscreteScheduler(shift=args.shift)
-    if args.scheduler_type == "pcm_linear_quadratic":
-        sigmas = linear_quadratic_schedule(
-            noise_scheduler.config.num_train_timesteps, args.linear_quadratic_threshold
-        )
-        sigmas = torch.tensor(sigmas).to(dtype=torch.float32)
-    else:
-        sigmas = noise_scheduler.sigmas
-    solver = EulerSolver(
-        sigmas.numpy()[::-1],
-        noise_scheduler.config.num_train_timesteps,
-        euler_timesteps=args.num_euler_timesteps,
-    )
-    solver.to(device)
-    params_to_optimize = transformer.parameters()
-    params_to_optimize = list(filter(lambda p: p.requires_grad, params_to_optimize))
-
-    optimizer = torch.optim.AdamW(
-        params_to_optimize,
-        lr=args.learning_rate,
-        betas=(0.9, 0.999),
-        weight_decay=1e-3,
-        eps=1e-8,
-    )
-
-    discriminator_optimizer = torch.optim.AdamW(
-        discriminator.parameters(),
-        lr=args.discriminator_learning_rate,
-        betas=(0, 0.999),
-        weight_decay=1e-3,
-        eps=1e-8,
-    )
-
-    init_steps = 0
-    if args.resume_from_lora_checkpoint:
-        transformer, optimizer, init_steps = resume_lora_optimizer(
-            transformer, args.resume_from_lora_checkpoint, optimizer
-        )
-    elif args.resume_from_checkpoint:
-        (
-            transformer,
-            optimizer,
-            discriminator,
-            discriminator_optimizer,
-            init_steps,
-        ) = resume_training_generator_discriminator(
-            transformer,
-            optimizer,
-            discriminator,
-            discriminator_optimizer,
-            args.resume_from_checkpoint,
-            rank,
-        )
-
-    main_print(f"optimizer: {optimizer}")
-
-    lr_scheduler = get_scheduler(
-        args.lr_scheduler,
-        optimizer=optimizer,
-        num_warmup_steps=args.lr_warmup_steps * world_size,
-        num_training_steps=args.max_train_steps * world_size,
-        num_cycles=args.lr_num_cycles,
-        power=args.lr_power,
-        last_epoch=init_steps - 1,
-    )
-
-    train_dataset = LatentDataset(args.data_json_path, args.num_latent_t, args.cfg)
-    uncond_prompt_embed = train_dataset.uncond_prompt_embed
-    uncond_prompt_mask = train_dataset.uncond_prompt_mask
-    sampler = (
-        LengthGroupedSampler(
-            args.train_batch_size,
-            rank=rank,
-            world_size=world_size,
-            lengths=train_dataset.lengths,
-            group_frame=args.group_frame,
-            group_resolution=args.group_resolution,
-        )
-        if (args.group_frame or args.group_resolution)
-        else DistributedSampler(
-            train_dataset, rank=rank, num_replicas=world_size, shuffle=False
-        )
-    )
-
-    train_dataloader = DataLoader(
-        train_dataset,
-        sampler=sampler,
-        collate_fn=latent_collate_function,
-        pin_memory=True,
-        batch_size=args.train_batch_size,
-        num_workers=args.dataloader_num_workers,
-        drop_last=True,
-    )
-    assert args.gradient_accumulation_steps == 1
-    num_update_steps_per_epoch = math.ceil(
-        len(train_dataloader)
-        / args.gradient_accumulation_steps
-        * args.sp_size
-        / args.train_sp_batch_size
-    )
-    args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
-
-    if rank <= 0:
-        project = args.tracker_project_name or "fastvideo"
-        wandb.init(project=project, config=args)
-
-    # Train!
-    total_batch_size = (
-        args.train_batch_size
-        * world_size
-        * args.gradient_accumulation_steps
-        / args.sp_size
-        * args.train_sp_batch_size
-    )
-    main_print("***** Running training *****")
-    main_print(f"  Num examples = {len(train_dataset)}")
-    main_print(f"  Dataloader size = {len(train_dataloader)}")
-    main_print(f"  Num Epochs = {args.num_train_epochs}")
-    main_print(f"  Resume training from step {init_steps}")
-    main_print(f"  Instantaneous batch size per device = {args.train_batch_size}")
-    main_print(
-        f"  Total train batch size (w. data & sequence parallel, accumulation) = {total_batch_size}"
-    )
-    main_print(f"  Gradient Accumulation steps = {args.gradient_accumulation_steps}")
-    main_print(f"  Total optimization steps = {args.max_train_steps}")
-    main_print(
-        f"  Total training parameters per FSDP shard = {sum(p.numel() for p in transformer.parameters() if p.requires_grad) / 1e9} B"
-    )
-    # print dtype
-    main_print(f"  Master weight dtype: {transformer.parameters().__next__().dtype}")
-
-    progress_bar = tqdm(
-        range(0, args.max_train_steps),
-        initial=init_steps,
-        desc="Steps",
-        # Only show the progress bar once on each machine.
-        disable=local_rank > 0,
-    )
-    loader = sp_parallel_dataloader_wrapper(
-        train_dataloader,
-        device,
-        args.train_batch_size,
-        args.sp_size,
-        args.train_sp_batch_size,
-    )
-
-    step_times = deque(maxlen=100)
-    # log_validation(args, transformer, device,
-    #         torch.bfloat16, init_steps, scheduler_type=args.scheduler_type, shift=args.shift, num_euler_timesteps=args.num_euler_timesteps, linear_quadratic_threshold=args.linear_quadratic_threshold, ema=False)
-
-    for i in range(init_steps):
-        _ = next(loader)
-    for step in range(init_steps + 1, args.max_train_steps + 1):
-        start_time = time.time()
-        (
-            generator_loss,
-            generator_grad_norm,
-            discriminator_loss,
-            discriminator_grad_norm,
-        ) = train_one_step_mochi(
-            transformer,
-            teacher_transformer,
-            optimizer,
-            discriminator,
-            discriminator_optimizer,
-            step,
-            lr_scheduler,
-            loader,
-            noise_scheduler,
-            solver,
-            noise_random_generator,
-            args.sp_size,
-            args.precondition_outputs,
-            args.max_grad_norm,
-            uncond_prompt_embed,
-            uncond_prompt_mask,
-            args.num_euler_timesteps,
-            args.validation_sampling_steps,
-            args.not_apply_cfg_solver,
-            args.distill_cfg,
-            args.adv_weight,
-        )
-
-        step_time = time.time() - start_time
-        step_times.append(step_time)
-        avg_step_time = sum(step_times) / len(step_times)
-
-        progress_bar.set_postfix(
-            {
-                "g_loss": f"{generator_loss:.4f}",
-                "d_loss": f"{discriminator_loss:.4f}",
-                "g_grad_norm": generator_grad_norm,
-                "d_grad_norm": discriminator_grad_norm,
-                "step_time": f"{step_time:.2f}s",
-            }
-        )
-        progress_bar.update(1)
-        if rank <= 0:
-            wandb.log(
-                {
-                    "generator_loss": generator_loss,
-                    "discriminator_loss": discriminator_loss,
-                    "generator_grad_norm": generator_grad_norm,
-                    "discriminator_grad_norm": discriminator_grad_norm,
-                    "learning_rate": lr_scheduler.get_last_lr()[0],
-                    "step_time": step_time,
-                    "avg_step_time": avg_step_time,
-                },
-                step=step,
-            )
-        if step % args.checkpointing_steps == 0:
-            main_print(f"--> saving checkpoint at step {step}")
-            if args.use_lora:
-                # Save LoRA weights
-                save_lora_checkpoint(
-                    transformer, optimizer, rank, args.output_dir, step
-                )
-            else:
-                # Your existing checkpoint saving code
-                save_checkpoint_generator_discriminator(
-                    transformer,
-                    optimizer,
-                    discriminator,
-                    discriminator_optimizer,
-                    rank,
-                    args.output_dir,
-                    step,
-                )
-            main_print(f"--> checkpoint saved at step {step}")
-            dist.barrier()
-        if args.log_validation and step % args.validation_steps == 0:
-            log_validation(
-                args,
-                transformer,
-                device,
-                torch.bfloat16,
-                step,
-                scheduler_type=args.scheduler_type,
-                shift=args.shift,
-                num_euler_timesteps=args.num_euler_timesteps,
-                linear_quadratic_threshold=args.linear_quadratic_threshold,
-                ema=False,
-            )
-
-    if args.use_lora:
-        save_lora_checkpoint(
-            transformer, optimizer, rank, args.output_dir, args.max_train_steps
-        )
-    else:
-        save_checkpoint(
-            transformer, optimizer, rank, args.output_dir, args.max_train_steps
-        )
-        save_checkpoint(
-            discriminator,
-            discriminator_optimizer,
-            rank,
-            args.output_dir,
-            step,
-            discriminator=True,
-        )
-
-    if get_sequence_parallel_state():
-        destroy_sequence_parallel_group()
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    # dataset & dataloader
-    parser.add_argument("--data_json_path", type=str, required=True)
-    parser.add_argument("--num_frames", type=int, default=163)
-    parser.add_argument(
-        "--dataloader_num_workers",
-        type=int,
-        default=10,
-        help="Number of subprocesses to use for data loading. 0 means that the data will be loaded in the main process.",
-    )
-    parser.add_argument(
-        "--train_batch_size",
-        type=int,
-        default=16,
-        help="Batch size (per device) for the training dataloader.",
-    )
-    parser.add_argument(
-        "--num_latent_t", type=int, default=28, help="Number of latent timesteps."
-    )
-    parser.add_argument("--group_frame", action="store_true")  # TODO
-    parser.add_argument("--group_resolution", action="store_true")  # TODO
-
-    # text encoder & vae & diffusion model
-    parser.add_argument("--pretrained_model_name_or_path", type=str)
-    parser.add_argument("--dit_model_name_or_path", type=str)
-    parser.add_argument("--cache_dir", type=str, default="./cache_dir")
-
-    # diffusion setting
-    parser.add_argument("--ema_decay", type=float, default=0.999)
-    parser.add_argument("--ema_start_step", type=int, default=0)
-    parser.add_argument("--cfg", type=float, default=0.1)
-    parser.add_argument(
-        "--precondition_outputs",
-        action="store_true",
-        help="Whether to precondition the outputs of the model.",
-    )
-
-    # validation & logs
-    parser.add_argument("--validation_prompt_dir", type=str)
-    parser.add_argument("--validation_sampling_steps", type=int, default=64)
-    parser.add_argument("--validation_guidance_scale", type=float, default=4.5)
-    parser.add_argument("--validation_steps", type=float, default=64)
-    parser.add_argument("--log_validation", action="store_true")
-    parser.add_argument("--tracker_project_name", type=str, default=None)
-    parser.add_argument(
-        "--seed", type=int, default=None, help="A seed for reproducible training."
-    )
-    parser.add_argument(
-        "--output_dir",
-        type=str,
-        default=None,
-        help="The output directory where the model predictions and checkpoints will be written.",
-    )
-    parser.add_argument(
-        "--checkpoints_total_limit",
-        type=int,
-        default=None,
-        help=("Max number of checkpoints to store."),
-    )
-    parser.add_argument(
-        "--checkpointing_steps",
-        type=int,
-        default=500,
-        help=(
-            "Save a checkpoint of the training state every X updates. These checkpoints can be used both as final"
-            " checkpoints in case they are better than the last checkpoint, and are also suitable for resuming"
-            " training using `--resume_from_checkpoint`."
-        ),
-    )
-    parser.add_argument("--shift", type=float, default=1.0)
-    parser.add_argument(
-        "--resume_from_checkpoint",
-        type=str,
-        default=None,
-        help=(
-            "Whether training should be resumed from a previous checkpoint. Use a path saved by"
-            ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.'
-        ),
-    )
-    parser.add_argument(
-        "--resume_from_lora_checkpoint",
-        type=str,
-        default=None,
-        help=(
-            "Whether training should be resumed from a previous lora checkpoint. Use a path saved by"
-            ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.'
-        ),
-    )
-    parser.add_argument(
-        "--logging_dir",
-        type=str,
-        default="logs",
-        help=(
-            "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to"
-            " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***."
-        ),
-    )
-
-    # optimizer & scheduler & Training
-    parser.add_argument("--num_train_epochs", type=int, default=100)
-    parser.add_argument(
-        "--max_train_steps",
-        type=int,
-        default=None,
-        help="Total number of training steps to perform.  If provided, overrides num_train_epochs.",
-    )
-    parser.add_argument(
-        "--learning_rate",
-        type=float,
-        default=1e-4,
-        help="Initial learning rate (after the potential warmup period) to use.",
-    )
-    parser.add_argument(
-        "--discriminator_learning_rate",
-        type=float,
-        default=1e-5,
-        help="Initial learning rate (after the potential warmup period) to use.",
-    )
-    parser.add_argument(
-        "--scale_lr",
-        action="store_true",
-        default=False,
-        help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.",
-    )
-    parser.add_argument(
-        "--lr_warmup_steps",
-        type=int,
-        default=10,
-        help="Number of steps for the warmup in the lr scheduler.",
-    )
-    parser.add_argument(
-        "--max_grad_norm", default=1.0, type=float, help="Max gradient norm."
-    )
-    parser.add_argument(
-        "--gradient_checkpointing",
-        action="store_true",
-        help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.",
-    )
-    parser.add_argument("--selective_checkpointing", type=float, default=1.0)
-    parser.add_argument(
-        "--allow_tf32",
-        action="store_true",
-        help=(
-            "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see"
-            " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices"
-        ),
-    )
-    parser.add_argument(
-        "--mixed_precision",
-        type=str,
-        default=None,
-        choices=["no", "fp16", "bf16"],
-        help=(
-            "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >="
-            " 1.10.and an Nvidia Ampere GPU.  Default to the value of accelerate config of the current system or the"
-            " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config."
-        ),
-    )
-    parser.add_argument(
-        "--use_cpu_offload",
-        action="store_true",
-        help="Whether to use CPU offload for param & gradient & optimizer states.",
-    )
-
-    parser.add_argument("--sp_size", type=int, default=1, help="For sequence parallel")
-    parser.add_argument(
-        "--train_sp_batch_size",
-        type=int,
-        default=1,
-        help="Batch size for sequence parallel training",
-    )
-
-    parser.add_argument(
-        "--use_lora",
-        action="store_true",
-        default=False,
-        help="Whether to use LoRA for finetuning.",
-    )
-    parser.add_argument(
-        "--lora_alpha", type=int, default=256, help="Alpha parameter for LoRA."
-    )
-    parser.add_argument(
-        "--lora_rank", type=int, default=128, help="LoRA rank parameter. "
-    )
-    parser.add_argument("--fsdp_sharding_startegy", default="full")
-    parser.add_argument(
-        "--gradient_accumulation_steps",
-        type=int,
-        default=1,
-        help="Number of updates steps to accumulate before performing a backward/update pass.",
-    )
-
-    # lr_scheduler
-    parser.add_argument(
-        "--lr_scheduler",
-        type=str,
-        default="constant",
-        help=(
-            'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",'
-            ' "constant", "constant_with_warmup"]'
-        ),
-    )
-    parser.add_argument("--num_euler_timesteps", type=int, default=100)
-    parser.add_argument(
-        "--lr_num_cycles",
-        type=int,
-        default=1,
-        help="Number of cycles in the learning rate scheduler.",
-    )
-    parser.add_argument(
-        "--lr_power",
-        type=float,
-        default=1.0,
-        help="Power factor of the polynomial scheduler.",
-    )
-    parser.add_argument(
-        "--not_apply_cfg_solver",
-        action="store_true",
-        help="Whether to apply the cfg_solver.",
-    )
-    parser.add_argument(
-        "--distill_cfg", type=float, default=3.0, help="Distillation coefficient."
-    )
-    # ["euler_linear_quadratic", "pcm", "pcm_linear_qudratic"]
-    parser.add_argument(
-        "--scheduler_type", type=str, default="pcm", help="The scheduler type to use."
-    )
-    parser.add_argument(
-        "--adv_weight",
-        type=float,
-        default=0.1,
-        help="The weight of the adversarial loss.",
-    )
-    parser.add_argument(
-        "--discriminator_head_stride",
-        type=int,
-        default=2,
-        help="The stride of the discriminator head.",
-    )
-    parser.add_argument(
-        "--linear_quadratic_threshold",
-        type=float,
-        default=0.025,
-        help="The threshold of the linear quadratic scheduler.",
-    )
-    parser.add_argument(
-        "--master_weight_type",
-        type=str,
-        default="fp32",
-        help="Weight type to use - fp32 or bf16.",
-    )
-    args = parser.parse_args()
-    main(args)

fastvideo/fsdp_util.py

@@ -1,149 +0,0 @@
-from sympy import use
-import torch
-import os
-import torch.distributed as dist
-from torch.distributed.algorithms._checkpoint.checkpoint_wrapper import (
-    checkpoint_wrapper,
-    CheckpointImpl,
-    apply_activation_checkpointing,
-)
-from peft.utils.other import fsdp_auto_wrap_policy
-
-from torch.distributed.fsdp import (
-    FullyShardedDataParallel as FSDP,
-    StateDictType,
-    FullStateDictConfig,  # general model non-sharded, non-flattened params
-    LocalStateDictConfig,  # flattened params, usable only by FSDP
-    # ShardedStateDictConfig, # un-flattened param but shards, usable by other parallel schemes.
-)
-
-from fastvideo.models.mochi_hf.modeling_mochi import MochiTransformerBlock
-
-from functools import partial
-
-from torch.distributed.fsdp.wrap import transformer_auto_wrap_policy
-
-from torch.distributed.fsdp import MixedPrecision, ShardingStrategy
-import functools
-
-
-non_reentrant_wrapper = partial(
-    checkpoint_wrapper,
-    checkpoint_impl=CheckpointImpl.NO_REENTRANT,
-)
-
-check_fn = lambda submodule: isinstance(submodule, MochiTransformerBlock)
-
-
-def apply_fsdp_checkpointing(model, p=1):
-    # https://github.com/foundation-model-stack/fms-fsdp/blob/408c7516d69ea9b6bcd4c0f5efab26c0f64b3c2d/fms_fsdp/policies/ac_handler.py#L16
-    """apply activation checkpointing to model
-    returns None as model is updated directly
-    """
-    print(f"--> applying fdsp activation checkpointing...")
-
-    block_idx = 0
-    cut_off = 1 / 2
-    # when passing p as a fraction number (e.g. 1/3), it will be interpreted
-    # as a string in argv, thus we need eval("1/3") here for fractions.
-    p = eval(p) if isinstance(p, str) else p
-
-    def selective_checkpointing(submodule):
-        nonlocal block_idx
-        nonlocal cut_off
-
-        if isinstance(submodule, MochiTransformerBlock):
-            block_idx += 1
-            if block_idx * p >= cut_off:
-                cut_off += 1
-                return True
-        return False
-
-    apply_activation_checkpointing(
-        model,
-        checkpoint_wrapper_fn=non_reentrant_wrapper,
-        check_fn=selective_checkpointing,
-    )
-
-
-def get_mixed_precision(master_weight_type="fp32"):
-    weight_type = torch.float32 if master_weight_type == "fp32" else torch.bfloat16
-    mixed_precision = MixedPrecision(
-        param_dtype=weight_type,
-        # Gradient communication precision.
-        reduce_dtype=weight_type,
-        # Buffer precision.
-        buffer_dtype=weight_type,
-        cast_forward_inputs=False,
-    )
-    return mixed_precision
-
-
-def get_dit_fsdp_kwargs(
-    sharding_strategy, use_lora=False, cpu_offload=False, master_weight_type="fp32"
-):
-    if use_lora:
-        auto_wrap_policy = fsdp_auto_wrap_policy
-    else:
-        auto_wrap_policy = functools.partial(
-            transformer_auto_wrap_policy,
-            transformer_layer_cls={
-                MochiTransformerBlock,
-            },
-        )
-
-    # we use float32 for fsdp but autocast during training
-    mixed_precision = get_mixed_precision(master_weight_type)
-
-    if sharding_strategy == "full":
-        sharding_strategy = ShardingStrategy.FULL_SHARD
-    elif sharding_strategy == "hybrid_full":
-        sharding_strategy = ShardingStrategy.HYBRID_SHARD
-    elif sharding_strategy == "none":
-        sharding_strategy = ShardingStrategy.NO_SHARD
-        auto_wrap_policy = None
-    elif sharding_strategy == "hybrid_zero2":
-        sharding_strategy = ShardingStrategy._HYBRID_SHARD_ZERO2
-
-    device_id = torch.cuda.current_device()
-    cpu_offload = (
-        torch.distributed.fsdp.CPUOffload(offload_params=True) if cpu_offload else None
-    )
-    fsdp_kwargs = {
-        "auto_wrap_policy": auto_wrap_policy,
-        "mixed_precision": mixed_precision,
-        "sharding_strategy": sharding_strategy,
-        "device_id": device_id,
-        "limit_all_gathers": True,
-        "cpu_offload": cpu_offload,
-    }
-
-    # Add LoRA-specific settings when LoRA is enabled
-    if use_lora:
-        fsdp_kwargs.update(
-            {
-                "use_orig_params": False,  # Required for LoRA memory savings
-                "sync_module_states": True,
-            }
-        )
-
-    return fsdp_kwargs
-
-
-def get_discriminator_fsdp_kwargs(master_weight_type="fp32"):
-    auto_wrap_policy = None
-
-    # Use existing mixed precision settings
-
-    mixed_precision = get_mixed_precision(master_weight_type)
-    sharding_strategy = ShardingStrategy.NO_SHARD
-    device_id = torch.cuda.current_device()
-    fsdp_kwargs = {
-        "auto_wrap_policy": auto_wrap_policy,
-        "mixed_precision": mixed_precision,
-        "sharding_strategy": sharding_strategy,
-        "device_id": device_id,
-        "limit_all_gathers": True,
-    }
-
-    return fsdp_kwargs

fastvideo/models/mochi_hf/convert_diffusers_to_mochi.py

@@ -1,431 +0,0 @@
-import torch
-import argparse
-from safetensors.torch import save_file
-import os
-
-parser = argparse.ArgumentParser()
-parser.add_argument("--diffusers_path", required=True, type=str)
-parser.add_argument("--transformer_path", type=str, default=None, help="Path to save transformer model")
-parser.add_argument("--vae_encoder_path", type=str, default=None, help="Path to save VAE encoder model")
-parser.add_argument("--vae_decoder_path", type=str, default=None, help="Path to save VAE decoder model")
-
-args = parser.parse_args()
-
-def reverse_scale_shift(weight, dim):
-    scale, shift = weight.chunk(2, dim=0)
-    new_weight = torch.cat([shift, scale], dim=0)
-    return new_weight
-
-def reverse_proj_gate(weight):
-    gate, proj = weight.chunk(2, dim=0)
-    new_weight = torch.cat([proj, gate], dim=0)
-    return new_weight
-
-def convert_diffusers_transformer_to_mochi(state_dict):
-    original_state_dict = state_dict.copy()
-    new_state_dict = {}
-
-    # Convert patch_embed
-    new_state_dict["x_embedder.proj.weight"] = original_state_dict.pop("patch_embed.proj.weight")
-    new_state_dict["x_embedder.proj.bias"] = original_state_dict.pop("patch_embed.proj.bias")
-
-    # Convert time_embed
-    new_state_dict["t_embedder.mlp.0.weight"] = original_state_dict.pop("time_embed.timestep_embedder.linear_1.weight")
-    new_state_dict["t_embedder.mlp.0.bias"] = original_state_dict.pop("time_embed.timestep_embedder.linear_1.bias")
-    new_state_dict["t_embedder.mlp.2.weight"] = original_state_dict.pop("time_embed.timestep_embedder.linear_2.weight")
-    new_state_dict["t_embedder.mlp.2.bias"] = original_state_dict.pop("time_embed.timestep_embedder.linear_2.bias")
-    new_state_dict["t5_y_embedder.to_kv.weight"] = original_state_dict.pop("time_embed.pooler.to_kv.weight")
-    new_state_dict["t5_y_embedder.to_kv.bias"] = original_state_dict.pop("time_embed.pooler.to_kv.bias")
-    new_state_dict["t5_y_embedder.to_q.weight"] = original_state_dict.pop("time_embed.pooler.to_q.weight")
-    new_state_dict["t5_y_embedder.to_q.bias"] = original_state_dict.pop("time_embed.pooler.to_q.bias")
-    new_state_dict["t5_y_embedder.to_out.weight"] = original_state_dict.pop("time_embed.pooler.to_out.weight")
-    new_state_dict["t5_y_embedder.to_out.bias"] = original_state_dict.pop("time_embed.pooler.to_out.bias")
-    new_state_dict["t5_yproj.weight"] = original_state_dict.pop("time_embed.caption_proj.weight")
-    new_state_dict["t5_yproj.bias"] = original_state_dict.pop("time_embed.caption_proj.bias")
-
-    # Convert transformer blocks
-    num_layers = 48
-    for i in range(num_layers):
-        block_prefix = f"transformer_blocks.{i}."
-        new_prefix = f"blocks.{i}."
-
-        # norm1
-        new_state_dict[new_prefix + "mod_x.weight"] = original_state_dict.pop(block_prefix + "norm1.linear.weight")
-        new_state_dict[new_prefix + "mod_x.bias"] = original_state_dict.pop(block_prefix + "norm1.linear.bias")
-
-        if i < num_layers - 1:
-            new_state_dict[new_prefix + "mod_y.weight"] = original_state_dict.pop(
-                block_prefix + "norm1_context.linear.weight"
-            )
-            new_state_dict[new_prefix + "mod_y.bias"] = original_state_dict.pop(
-                block_prefix + "norm1_context.linear.bias"
-            )
-        else:
-            new_state_dict[new_prefix + "mod_y.weight"] = original_state_dict.pop(
-                block_prefix + "norm1_context.linear_1.weight"
-            )
-            new_state_dict[new_prefix + "mod_y.bias"] = original_state_dict.pop(
-                block_prefix + "norm1_context.linear_1.bias"
-            )
-
-        # Visual attention
-        q = original_state_dict.pop(block_prefix + "attn1.to_q.weight")
-        k = original_state_dict.pop(block_prefix + "attn1.to_k.weight") 
-        v = original_state_dict.pop(block_prefix + "attn1.to_v.weight")
-        qkv_weight = torch.cat([q, k, v], dim=0)
-        new_state_dict[new_prefix + "attn.qkv_x.weight"] = qkv_weight
-
-        new_state_dict[new_prefix + "attn.q_norm_x.weight"] = original_state_dict.pop(
-            block_prefix + "attn1.norm_q.weight"
-        )
-        new_state_dict[new_prefix + "attn.k_norm_x.weight"] = original_state_dict.pop(
-            block_prefix + "attn1.norm_k.weight"
-        )
-        new_state_dict[new_prefix + "attn.proj_x.weight"] = original_state_dict.pop(
-            block_prefix + "attn1.to_out.0.weight"
-        )
-        new_state_dict[new_prefix + "attn.proj_x.bias"] = original_state_dict.pop(
-            block_prefix + "attn1.to_out.0.bias"
-        )
-
-        # Context attention
-        q = original_state_dict.pop(block_prefix + "attn1.add_q_proj.weight")
-        k = original_state_dict.pop(block_prefix + "attn1.add_k_proj.weight")
-        v = original_state_dict.pop(block_prefix + "attn1.add_v_proj.weight")
-        qkv_weight = torch.cat([q, k, v], dim=0)
-        new_state_dict[new_prefix + "attn.qkv_y.weight"] = qkv_weight
-
-        new_state_dict[new_prefix + "attn.q_norm_y.weight"] = original_state_dict.pop(
-            block_prefix + "attn1.norm_added_q.weight"
-        )
-        new_state_dict[new_prefix + "attn.k_norm_y.weight"] = original_state_dict.pop(
-            block_prefix + "attn1.norm_added_k.weight"
-        )
-        if i < num_layers - 1:
-            new_state_dict[new_prefix + "attn.proj_y.weight"] = original_state_dict.pop(
-                block_prefix + "attn1.to_add_out.weight"
-            )
-            new_state_dict[new_prefix + "attn.proj_y.bias"] = original_state_dict.pop(
-                block_prefix + "attn1.to_add_out.bias"
-            )
-
-        # MLP
-        new_state_dict[new_prefix + "mlp_x.w1.weight"] = reverse_proj_gate(
-            original_state_dict.pop(block_prefix + "ff.net.0.proj.weight")
-        )
-        new_state_dict[new_prefix + "mlp_x.w2.weight"] = original_state_dict.pop(block_prefix + "ff.net.2.weight")
-        if i < num_layers - 1:
-            new_state_dict[new_prefix + "mlp_y.w1.weight"] = reverse_proj_gate(
-                original_state_dict.pop(block_prefix + "ff_context.net.0.proj.weight")
-            )
-            new_state_dict[new_prefix + "mlp_y.w2.weight"] = original_state_dict.pop(
-                block_prefix + "ff_context.net.2.weight"
-            )
-
-    # Output layers
-    new_state_dict["final_layer.mod.weight"] = reverse_scale_shift(
-        original_state_dict.pop("norm_out.linear.weight"), dim=0
-    )
-    new_state_dict["final_layer.mod.bias"] = reverse_scale_shift(
-        original_state_dict.pop("norm_out.linear.bias"), dim=0
-    )
-    new_state_dict["final_layer.linear.weight"] = original_state_dict.pop("proj_out.weight")
-    new_state_dict["final_layer.linear.bias"] = original_state_dict.pop("proj_out.bias")
-
-    new_state_dict["pos_frequencies"] = original_state_dict.pop("pos_frequencies")
-
-    print("Remaining Keys:", original_state_dict.keys())
-
-    return new_state_dict
-
-def convert_diffusers_vae_to_mochi(state_dict):
-    original_state_dict = state_dict.copy()
-    encoder_state_dict = {}
-    decoder_state_dict = {}
-
-    # Convert encoder
-    prefix = "encoder."
-
-    encoder_state_dict["layers.0.weight"] = original_state_dict.pop(f"{prefix}proj_in.weight")
-    encoder_state_dict["layers.0.bias"] = original_state_dict.pop(f"{prefix}proj_in.bias")
-
-    # Convert block_in
-    for i in range(3):
-        encoder_state_dict[f"layers.{i+1}.stack.0.weight"] = original_state_dict.pop(
-            f"{prefix}block_in.resnets.{i}.norm1.norm_layer.weight"
-        )
-        encoder_state_dict[f"layers.{i+1}.stack.0.bias"] = original_state_dict.pop(
-            f"{prefix}block_in.resnets.{i}.norm1.norm_layer.bias"
-        )
-        encoder_state_dict[f"layers.{i+1}.stack.2.weight"] = original_state_dict.pop(
-            f"{prefix}block_in.resnets.{i}.conv1.conv.weight"
-        )
-        encoder_state_dict[f"layers.{i+1}.stack.2.bias"] = original_state_dict.pop(
-            f"{prefix}block_in.resnets.{i}.conv1.conv.bias"
-        )
-        encoder_state_dict[f"layers.{i+1}.stack.3.weight"] = original_state_dict.pop(
-            f"{prefix}block_in.resnets.{i}.norm2.norm_layer.weight"
-        )
-        encoder_state_dict[f"layers.{i+1}.stack.3.bias"] = original_state_dict.pop(
-            f"{prefix}block_in.resnets.{i}.norm2.norm_layer.bias"
-        )
-        encoder_state_dict[f"layers.{i+1}.stack.5.weight"] = original_state_dict.pop(
-            f"{prefix}block_in.resnets.{i}.conv2.conv.weight"
-        )
-        encoder_state_dict[f"layers.{i+1}.stack.5.bias"] = original_state_dict.pop(
-            f"{prefix}block_in.resnets.{i}.conv2.conv.bias"
-        )
-
-    # Convert down_blocks
-    down_block_layers = [3, 4, 6]
-    for block in range(3):
-        encoder_state_dict[f"layers.{block+4}.layers.0.weight"] = original_state_dict.pop(
-            f"{prefix}down_blocks.{block}.conv_in.conv.weight"
-        )
-        encoder_state_dict[f"layers.{block+4}.layers.0.bias"] = original_state_dict.pop(
-            f"{prefix}down_blocks.{block}.conv_in.conv.bias"
-        )
-
-        for i in range(down_block_layers[block]):
-            # Convert resnets
-            encoder_state_dict[f"layers.{block+4}.layers.{i+1}.stack.0.weight"] = original_state_dict.pop(
-                f"{prefix}down_blocks.{block}.resnets.{i}.norm1.norm_layer.weight"
-            )
-            encoder_state_dict[f"layers.{block+4}.layers.{i+1}.stack.0.bias"] = original_state_dict.pop(
-                f"{prefix}down_blocks.{block}.resnets.{i}.norm1.norm_layer.bias"
-            )
-            encoder_state_dict[f"layers.{block+4}.layers.{i+1}.stack.2.weight"] = original_state_dict.pop(
-                f"{prefix}down_blocks.{block}.resnets.{i}.conv1.conv.weight"
-            )
-            encoder_state_dict[f"layers.{block+4}.layers.{i+1}.stack.2.bias"] = original_state_dict.pop(
-                f"{prefix}down_blocks.{block}.resnets.{i}.conv1.conv.bias"
-            )
-            encoder_state_dict[f"layers.{block+4}.layers.{i+1}.stack.3.weight"] = original_state_dict.pop(
-                f"{prefix}down_blocks.{block}.resnets.{i}.norm2.norm_layer.weight"
-            )
-            encoder_state_dict[f"layers.{block+4}.layers.{i+1}.stack.3.bias"] = original_state_dict.pop(
-                f"{prefix}down_blocks.{block}.resnets.{i}.norm2.norm_layer.bias"
-            )
-            encoder_state_dict[f"layers.{block+4}.layers.{i+1}.stack.5.weight"] = original_state_dict.pop(
-                f"{prefix}down_blocks.{block}.resnets.{i}.conv2.conv.weight"
-            )
-            encoder_state_dict[f"layers.{block+4}.layers.{i+1}.stack.5.bias"] = original_state_dict.pop(
-                f"{prefix}down_blocks.{block}.resnets.{i}.conv2.conv.bias"
-            )
-
-            # Convert attentions
-            q = original_state_dict.pop(f"{prefix}down_blocks.{block}.attentions.{i}.to_q.weight")
-            k = original_state_dict.pop(f"{prefix}down_blocks.{block}.attentions.{i}.to_k.weight")
-            v = original_state_dict.pop(f"{prefix}down_blocks.{block}.attentions.{i}.to_v.weight")
-            qkv_weight = torch.cat([q, k, v], dim=0)
-            encoder_state_dict[f"layers.{block+4}.layers.{i+1}.attn_block.attn.qkv.weight"] = qkv_weight
-
-            encoder_state_dict[f"layers.{block+4}.layers.{i+1}.attn_block.attn.out.weight"] = original_state_dict.pop(
-                f"{prefix}down_blocks.{block}.attentions.{i}.to_out.0.weight"
-            )
-            encoder_state_dict[f"layers.{block+4}.layers.{i+1}.attn_block.attn.out.bias"] = original_state_dict.pop(
-                f"{prefix}down_blocks.{block}.attentions.{i}.to_out.0.bias"
-            )
-            encoder_state_dict[f"layers.{block+4}.layers.{i+1}.attn_block.norm.weight"] = original_state_dict.pop(
-                f"{prefix}down_blocks.{block}.norms.{i}.norm_layer.weight"
-            )
-            encoder_state_dict[f"layers.{block+4}.layers.{i+1}.attn_block.norm.bias"] = original_state_dict.pop(
-                f"{prefix}down_blocks.{block}.norms.{i}.norm_layer.bias"
-            )
-
-    # Convert block_out
-    for i in range(3):
-        encoder_state_dict[f"layers.{i+7}.stack.0.weight"] = original_state_dict.pop(
-            f"{prefix}block_out.resnets.{i}.norm1.norm_layer.weight"
-        )
-        encoder_state_dict[f"layers.{i+7}.stack.0.bias"] = original_state_dict.pop(
-            f"{prefix}block_out.resnets.{i}.norm1.norm_layer.bias"
-        )
-        encoder_state_dict[f"layers.{i+7}.stack.2.weight"] = original_state_dict.pop(
-            f"{prefix}block_out.resnets.{i}.conv1.conv.weight"
-        )
-        encoder_state_dict[f"layers.{i+7}.stack.2.bias"] = original_state_dict.pop(
-            f"{prefix}block_out.resnets.{i}.conv1.conv.bias"
-        )
-        encoder_state_dict[f"layers.{i+7}.stack.3.weight"] = original_state_dict.pop(
-            f"{prefix}block_out.resnets.{i}.norm2.norm_layer.weight"
-        )
-        encoder_state_dict[f"layers.{i+7}.stack.3.bias"] = original_state_dict.pop(
-            f"{prefix}block_out.resnets.{i}.norm2.norm_layer.bias"
-        )
-        encoder_state_dict[f"layers.{i+7}.stack.5.weight"] = original_state_dict.pop(
-            f"{prefix}block_out.resnets.{i}.conv2.conv.weight"
-        )
-        encoder_state_dict[f"layers.{i+7}.stack.5.bias"] = original_state_dict.pop(
-            f"{prefix}block_out.resnets.{i}.conv2.conv.bias"
-        )
-
-        q = original_state_dict.pop(f"{prefix}block_out.attentions.{i}.to_q.weight")
-        k = original_state_dict.pop(f"{prefix}block_out.attentions.{i}.to_k.weight")
-        v = original_state_dict.pop(f"{prefix}block_out.attentions.{i}.to_v.weight")
-        qkv_weight = torch.cat([q, k, v], dim=0)
-        encoder_state_dict[f"layers.{i+7}.attn_block.attn.qkv.weight"] = qkv_weight
-
-        encoder_state_dict[f"layers.{i+7}.attn_block.attn.out.weight"] = original_state_dict.pop(
-            f"{prefix}block_out.attentions.{i}.to_out.0.weight"
-        )
-        encoder_state_dict[f"layers.{i+7}.attn_block.attn.out.bias"] = original_state_dict.pop(
-            f"{prefix}block_out.attentions.{i}.to_out.0.bias"
-        )
-        encoder_state_dict[f"layers.{i+7}.attn_block.norm.weight"] = original_state_dict.pop(
-            f"{prefix}block_out.norms.{i}.norm_layer.weight"
-        )
-        encoder_state_dict[f"layers.{i+7}.attn_block.norm.bias"] = original_state_dict.pop(
-            f"{prefix}block_out.norms.{i}.norm_layer.bias"
-        )
-
-    # Convert output layers
-    encoder_state_dict["output_norm.weight"] = original_state_dict.pop(f"{prefix}norm_out.norm_layer.weight")
-    encoder_state_dict["output_norm.bias"] = original_state_dict.pop(f"{prefix}norm_out.norm_layer.bias")
-    encoder_state_dict["output_proj.weight"] = original_state_dict.pop(f"{prefix}proj_out.weight")
-
-    # Convert decoder
-    prefix = "decoder."
-
-    decoder_state_dict["blocks.0.0.weight"] = original_state_dict.pop(f"{prefix}conv_in.weight")
-    decoder_state_dict["blocks.0.0.bias"] = original_state_dict.pop(f"{prefix}conv_in.bias")
-
-    # Convert block_in
-    for i in range(3):
-        decoder_state_dict[f"blocks.0.{i+1}.stack.0.weight"] = original_state_dict.pop(
-            f"{prefix}block_in.resnets.{i}.norm1.norm_layer.weight"
-        )
-        decoder_state_dict[f"blocks.0.{i+1}.stack.0.bias"] = original_state_dict.pop(
-            f"{prefix}block_in.resnets.{i}.norm1.norm_layer.bias"
-        )
-        decoder_state_dict[f"blocks.0.{i+1}.stack.2.weight"] = original_state_dict.pop(
-            f"{prefix}block_in.resnets.{i}.conv1.conv.weight"
-        )
-        decoder_state_dict[f"blocks.0.{i+1}.stack.2.bias"] = original_state_dict.pop(
-            f"{prefix}block_in.resnets.{i}.conv1.conv.bias"
-        )
-        decoder_state_dict[f"blocks.0.{i+1}.stack.3.weight"] = original_state_dict.pop(
-            f"{prefix}block_in.resnets.{i}.norm2.norm_layer.weight"
-        )
-        decoder_state_dict[f"blocks.0.{i+1}.stack.3.bias"] = original_state_dict.pop(
-            f"{prefix}block_in.resnets.{i}.norm2.norm_layer.bias"
-        )
-        decoder_state_dict[f"blocks.0.{i+1}.stack.5.weight"] = original_state_dict.pop(
-            f"{prefix}block_in.resnets.{i}.conv2.conv.weight"
-        )
-        decoder_state_dict[f"blocks.0.{i+1}.stack.5.bias"] = original_state_dict.pop(
-            f"{prefix}block_in.resnets.{i}.conv2.conv.bias"
-        )
-
-    # Convert up_blocks
-    up_block_layers = [6, 4, 3]
-    for block in range(3):
-        for i in range(up_block_layers[block]):
-            decoder_state_dict[f"blocks.{block+1}.blocks.{i}.stack.0.weight"] = original_state_dict.pop(
-                f"{prefix}up_blocks.{block}.resnets.{i}.norm1.norm_layer.weight"
-            )
-            decoder_state_dict[f"blocks.{block+1}.blocks.{i}.stack.0.bias"] = original_state_dict.pop(
-                f"{prefix}up_blocks.{block}.resnets.{i}.norm1.norm_layer.bias"
-            )
-            decoder_state_dict[f"blocks.{block+1}.blocks.{i}.stack.2.weight"] = original_state_dict.pop(
-                f"{prefix}up_blocks.{block}.resnets.{i}.conv1.conv.weight"
-            )
-            decoder_state_dict[f"blocks.{block+1}.blocks.{i}.stack.2.bias"] = original_state_dict.pop(
-                f"{prefix}up_blocks.{block}.resnets.{i}.conv1.conv.bias"
-            )
-            decoder_state_dict[f"blocks.{block+1}.blocks.{i}.stack.3.weight"] = original_state_dict.pop(
-                f"{prefix}up_blocks.{block}.resnets.{i}.norm2.norm_layer.weight"
-            )
-            decoder_state_dict[f"blocks.{block+1}.blocks.{i}.stack.3.bias"] = original_state_dict.pop(
-                f"{prefix}up_blocks.{block}.resnets.{i}.norm2.norm_layer.bias"
-            )
-            decoder_state_dict[f"blocks.{block+1}.blocks.{i}.stack.5.weight"] = original_state_dict.pop(
-                f"{prefix}up_blocks.{block}.resnets.{i}.conv2.conv.weight"
-            )
-            decoder_state_dict[f"blocks.{block+1}.blocks.{i}.stack.5.bias"] = original_state_dict.pop(
-                f"{prefix}up_blocks.{block}.resnets.{i}.conv2.conv.bias"
-            )
-        decoder_state_dict[f"blocks.{block+1}.proj.weight"] = original_state_dict.pop(
-            f"{prefix}up_blocks.{block}.proj.weight"
-        )
-        decoder_state_dict[f"blocks.{block+1}.proj.bias"] = original_state_dict.pop(
-            f"{prefix}up_blocks.{block}.proj.bias"
-        )
-
-    # Convert block_out
-    for i in range(3):
-        decoder_state_dict[f"blocks.4.{i}.stack.0.weight"] = original_state_dict.pop(
-            f"{prefix}block_out.resnets.{i}.norm1.norm_layer.weight"
-        )
-        decoder_state_dict[f"blocks.4.{i}.stack.0.bias"] = original_state_dict.pop(
-            f"{prefix}block_out.resnets.{i}.norm1.norm_layer.bias"
-        )
-        decoder_state_dict[f"blocks.4.{i}.stack.2.weight"] = original_state_dict.pop(
-            f"{prefix}block_out.resnets.{i}.conv1.conv.weight"
-        )
-        decoder_state_dict[f"blocks.4.{i}.stack.2.bias"] = original_state_dict.pop(
-            f"{prefix}block_out.resnets.{i}.conv1.conv.bias"
-        )
-        decoder_state_dict[f"blocks.4.{i}.stack.3.weight"] = original_state_dict.pop(
-            f"{prefix}block_out.resnets.{i}.norm2.norm_layer.weight"
-        )
-        decoder_state_dict[f"blocks.4.{i}.stack.3.bias"] = original_state_dict.pop(
-            f"{prefix}block_out.resnets.{i}.norm2.norm_layer.bias"
-        )
-        decoder_state_dict[f"blocks.4.{i}.stack.5.weight"] = original_state_dict.pop(
-            f"{prefix}block_out.resnets.{i}.conv2.conv.weight"
-        )
-        decoder_state_dict[f"blocks.4.{i}.stack.5.bias"] = original_state_dict.pop(
-            f"{prefix}block_out.resnets.{i}.conv2.conv.bias"
-        )
-
-    # Convert output layers  
-    decoder_state_dict["output_proj.weight"] = original_state_dict.pop(f"{prefix}proj_out.weight")
-    decoder_state_dict["output_proj.bias"] = original_state_dict.pop(f"{prefix}proj_out.bias")
-
-    return encoder_state_dict, decoder_state_dict
-
-def ensure_safetensors_extension(path):
-    if not path.endswith('.safetensors'):
-        path = path + '.safetensors'
-    return path
-
-def ensure_directory_exists(path):
-    directory = os.path.dirname(path)
-    if directory:
-        os.makedirs(directory, exist_ok=True)
-
-def main(args):
-    from diffusers import MochiPipeline
-    
-    pipe = MochiPipeline.from_pretrained(args.diffusers_path)
-
-    if args.transformer_path:
-        transformer_path = ensure_safetensors_extension(args.transformer_path)
-        ensure_directory_exists(transformer_path)
-
-        print(f"Converting transformer model...")
-        transformer_state_dict = convert_diffusers_transformer_to_mochi(pipe.transformer.state_dict())
-        save_file(transformer_state_dict, transformer_path)
-        print(f"Saved transformer to {transformer_path}")
-
-    if args.vae_encoder_path and args.vae_decoder_path:
-        encoder_path = ensure_safetensors_extension(args.vae_encoder_path)
-        decoder_path = ensure_safetensors_extension(args.vae_decoder_path)
-
-        ensure_directory_exists(encoder_path)
-        ensure_directory_exists(decoder_path)
-
-        print(f"Converting VAE models...")
-        encoder_state_dict, decoder_state_dict = convert_diffusers_vae_to_mochi(pipe.vae.state_dict())
-
-        save_file(encoder_state_dict, encoder_path)
-        print(f"Saved VAE encoder to {encoder_path}")
-
-        save_file(decoder_state_dict, decoder_path)
-        print(f"Saved VAE decoder to {decoder_path}")
-    elif args.vae_encoder_path or args.vae_decoder_path:
-        print("Warning: Both VAE encoder and decoder paths must be specified to convert VAE models.")
-
-if __name__ == "__main__":
-    main(args)

fastvideo/models/mochi_hf/mochi_latents_utils.py

@@ -1,42 +0,0 @@
-import torch
-
-mochi_latents_mean = torch.tensor(
-    [
-        -0.06730895953510081,
-        -0.038011381506090416,
-        -0.07477820912866141,
-        -0.05565264470995561,
-        0.012767231469026969,
-        -0.04703542746246419,
-        0.043896967884726704,
-        -0.09346305707025976,
-        -0.09918314763016893,
-        -0.008729793427399178,
-        -0.011931556316503654,
-        -0.0321993391887285,
-    ]
-).view(1, 12, 1, 1, 1)
-mochi_latents_std = torch.tensor(
-    [
-        0.9263795028493863,
-        0.9248894543193766,
-        0.9393059390890617,
-        0.959253732819592,
-        0.8244560132752793,
-        0.917259975397747,
-        0.9294154431013696,
-        1.3720942357788521,
-        0.881393668867029,
-        0.9168315692124348,
-        0.9185249279345552,
-        0.9274757570805041,
-    ]
-).view(1, 12, 1, 1, 1)
-mochi_scaling_factor = 1.0
-
-
-def normalize_mochi_dit_input(latents):
-    latents_mean = mochi_latents_mean.to(latents.device, latents.dtype)
-    latents_std = mochi_latents_std.to(latents.device, latents.dtype)
-    latents = (latents - latents_mean) / latents_std
-    return latents

fastvideo/models/mochi_hf/modeling_mochi.py

@@ -1,766 +0,0 @@
-# Copyright 2024 The Genmo team and The HuggingFace Team.
-# All rights reserved.
-#
-# 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.
-from typing import Any, Dict, Optional, Tuple
-
-import torch
-import torch.nn as nn
-import diffusers
-from diffusers.configuration_utils import ConfigMixin, register_to_config
-from diffusers.utils import is_torch_version, logging
-from diffusers.utils import (
-    USE_PEFT_BACKEND,
-    is_torch_version,
-    logging,
-    scale_lora_layers,
-    unscale_lora_layers,
-)
-from diffusers.utils.torch_utils import maybe_allow_in_graph
-from diffusers.models.attention import FeedForward as HF_FeedForward
-from diffusers.models.attention_processor import Attention
-from diffusers.models.embeddings import (
-    MochiCombinedTimestepCaptionEmbedding,
-    PatchEmbed,
-)
-from diffusers.models.modeling_outputs import Transformer2DModelOutput
-from diffusers.models.modeling_utils import ModelMixin
-from diffusers.loaders import PeftAdapterMixin
-from fastvideo.models.mochi_hf.norm import (
-    MochiLayerNormContinuous,
-    MochiRMSNormZero,
-    MochiModulatedRMSNorm,
-    MochiRMSNorm,
-)
-from diffusers.models.normalization import AdaLayerNormContinuous
-
-from fastvideo.utils.parallel_states import get_sequence_parallel_state, nccl_info
-from fastvideo.utils.communications import all_gather, all_to_all_4D
-import torch.nn.functional as F
-from diffusers.utils.torch_utils import is_torch_version, maybe_allow_in_graph
-from einops import rearrange
-
-import numbers
-from flash_attn import flash_attn_varlen_qkvpacked_func
-from flash_attn.bert_padding import pad_input, unpad_input
-
-from liger_kernel.ops.swiglu import LigerSiLUMulFunction
-
-logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
-
-
-class FeedForward(HF_FeedForward):
-    def __init__(
-        self,
-        dim: int,
-        dim_out: Optional[int] = None,
-        mult: int = 4,
-        dropout: float = 0.0,
-        activation_fn: str = "geglu",
-        final_dropout: bool = False,
-        inner_dim=None,
-        bias: bool = True,
-    ):
-        super().__init__(
-            dim, dim_out, mult, dropout, activation_fn, final_dropout, inner_dim, bias
-        )
-        assert activation_fn == "swiglu"
-
-    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
-        hidden_states = self.net[0].proj(hidden_states)
-        hidden_states, gate = hidden_states.chunk(2, dim=-1)
-
-        return self.net[2](LigerSiLUMulFunction.apply(gate, hidden_states))
-
-
-def flash_attn_no_pad(
-    qkv, key_padding_mask, causal=False, dropout_p=0.0, softmax_scale=None
-):
-    # adapted from https://github.com/Dao-AILab/flash-attention/blob/13403e81157ba37ca525890f2f0f2137edf75311/flash_attn/flash_attention.py#L27
-    batch_size = qkv.shape[0]
-    seqlen = qkv.shape[1]
-    nheads = qkv.shape[-2]
-    x = rearrange(qkv, "b s three h d -> b s (three h d)")
-    x_unpad, indices, cu_seqlens, max_s, used_seqlens_in_batch = unpad_input(
-        x, key_padding_mask
-    )
-
-    x_unpad = rearrange(x_unpad, "nnz (three h d) -> nnz three h d", three=3, h=nheads)
-    output_unpad = flash_attn_varlen_qkvpacked_func(
-        x_unpad,
-        cu_seqlens,
-        max_s,
-        dropout_p,
-        softmax_scale=softmax_scale,
-        causal=causal,
-    )
-    output = rearrange(
-        pad_input(
-            rearrange(output_unpad, "nnz h d -> nnz (h d)"), indices, batch_size, seqlen
-        ),
-        "b s (h d) -> b s h d",
-        h=nheads,
-    )
-    return output
-
-
-class MochiAttention(nn.Module):
-    def __init__(
-        self,
-        query_dim: int,
-        processor: "MochiAttnProcessor2_0",
-        heads: int = 8,
-        dim_head: int = 64,
-        dropout: float = 0.0,
-        bias: bool = False,
-        added_kv_proj_dim: Optional[int] = None,
-        added_proj_bias: Optional[bool] = True,
-        out_dim: int = None,
-        out_context_dim: int = None,
-        out_bias: bool = True,
-        context_pre_only: bool = False,
-        eps: float = 1e-5,
-    ):
-        super().__init__()
-        self.inner_dim = out_dim if out_dim is not None else dim_head * heads
-        self.out_dim = out_dim if out_dim is not None else query_dim
-        self.out_context_dim = out_context_dim if out_context_dim else query_dim
-        self.context_pre_only = context_pre_only
-
-        self.heads = out_dim // dim_head if out_dim is not None else heads
-
-        self.norm_q = MochiRMSNorm(dim_head, eps)
-        self.norm_k = MochiRMSNorm(dim_head, eps)
-        self.norm_added_q = MochiRMSNorm(dim_head, eps)
-        self.norm_added_k = MochiRMSNorm(dim_head, eps)
-
-        self.to_q = nn.Linear(query_dim, self.inner_dim, bias=bias)
-        self.to_k = nn.Linear(query_dim, self.inner_dim, bias=bias)
-        self.to_v = nn.Linear(query_dim, self.inner_dim, bias=bias)
-
-        self.add_k_proj = nn.Linear(
-            added_kv_proj_dim, self.inner_dim, bias=added_proj_bias
-        )
-        self.add_v_proj = nn.Linear(
-            added_kv_proj_dim, self.inner_dim, bias=added_proj_bias
-        )
-        if self.context_pre_only is not None:
-            self.add_q_proj = nn.Linear(
-                added_kv_proj_dim, self.inner_dim, bias=added_proj_bias
-            )
-
-        self.to_out = nn.ModuleList([])
-        self.to_out.append(nn.Linear(self.inner_dim, self.out_dim, bias=out_bias))
-        self.to_out.append(nn.Dropout(dropout))
-
-        if not self.context_pre_only:
-            self.to_add_out = nn.Linear(
-                self.inner_dim, self.out_context_dim, bias=out_bias
-            )
-
-        self.processor = processor
-
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        encoder_hidden_states: Optional[torch.Tensor] = None,
-        attention_mask: Optional[torch.Tensor] = None,
-        **kwargs,
-    ):
-        return self.processor(
-            self,
-            hidden_states,
-            encoder_hidden_states=encoder_hidden_states,
-            attention_mask=attention_mask,
-            **kwargs,
-        )
-
-
-class MochiAttnProcessor2_0:
-    """Attention processor used in Mochi."""
-
-    def __init__(self):
-        if not hasattr(F, "scaled_dot_product_attention"):
-            raise ImportError(
-                "MochiAttnProcessor2_0 requires PyTorch 2.0. To use it, please upgrade PyTorch to 2.0."
-            )
-
-    def __call__(
-        self,
-        attn: Attention,
-        hidden_states: torch.Tensor,
-        encoder_hidden_states: torch.Tensor,
-        encoder_attention_mask: torch.Tensor,
-        attention_mask: Optional[torch.Tensor] = None,
-        image_rotary_emb: Optional[torch.Tensor] = None,
-    ) -> torch.Tensor:
-        # [b, s, h * d]
-        query = attn.to_q(hidden_states)
-        key = attn.to_k(hidden_states)
-        value = attn.to_v(hidden_states)
-
-        # [b, s, h=24, d=128]
-        query = query.unflatten(2, (attn.heads, -1))
-        key = key.unflatten(2, (attn.heads, -1))
-        value = value.unflatten(2, (attn.heads, -1))
-
-        if attn.norm_q is not None:
-            query = attn.norm_q(query)
-        if attn.norm_k is not None:
-            key = attn.norm_k(key)
-        # [b, 256, h * d]
-        encoder_query = attn.add_q_proj(encoder_hidden_states)
-        encoder_key = attn.add_k_proj(encoder_hidden_states)
-        encoder_value = attn.add_v_proj(encoder_hidden_states)
-
-        # [b, 256, h=24, d=128]
-        encoder_query = encoder_query.unflatten(2, (attn.heads, -1))
-        encoder_key = encoder_key.unflatten(2, (attn.heads, -1))
-        encoder_value = encoder_value.unflatten(2, (attn.heads, -1))
-
-        if attn.norm_added_q is not None:
-            encoder_query = attn.norm_added_q(encoder_query)
-        if attn.norm_added_k is not None:
-            encoder_key = attn.norm_added_k(encoder_key)
-
-        if image_rotary_emb is not None:
-            freqs_cos, freqs_sin = image_rotary_emb[0], image_rotary_emb[1]
-        # shard the head dimension
-        if get_sequence_parallel_state():
-            # B, S, H, D to (S, B,) H, D
-            # batch_size, seq_len, attn_heads, head_dim
-            query = all_to_all_4D(query, scatter_dim=2, gather_dim=1)
-            key = all_to_all_4D(key, scatter_dim=2, gather_dim=1)
-            value = all_to_all_4D(value, scatter_dim=2, gather_dim=1)
-
-            def shrink_head(encoder_state, dim):
-                local_heads = encoder_state.shape[dim] // nccl_info.sp_size
-                return encoder_state.narrow(
-                    dim, nccl_info.rank_within_group * local_heads, local_heads
-                )
-
-            encoder_query = shrink_head(encoder_query, dim=2)
-            encoder_key = shrink_head(encoder_key, dim=2)
-            encoder_value = shrink_head(encoder_value, dim=2)
-            if image_rotary_emb is not None:
-                freqs_cos = shrink_head(freqs_cos, dim=1)
-                freqs_sin = shrink_head(freqs_sin, dim=1)
-
-        if image_rotary_emb is not None:
-
-            def apply_rotary_emb(x, freqs_cos, freqs_sin):
-                x_even = x[..., 0::2].float()
-                x_odd = x[..., 1::2].float()
-                cos = (x_even * freqs_cos - x_odd * freqs_sin).to(x.dtype)
-                sin = (x_even * freqs_sin + x_odd * freqs_cos).to(x.dtype)
-
-                return torch.stack([cos, sin], dim=-1).flatten(-2)
-
-            query = apply_rotary_emb(query, freqs_cos, freqs_sin)
-            key = apply_rotary_emb(key, freqs_cos, freqs_sin)
-
-        # query, key, value = query.transpose(1, 2), key.transpose(1, 2), value.transpose(1, 2)
-        # encoder_query, encoder_key, encoder_value = (
-        #     encoder_query.transpose(1, 2),
-        #     encoder_key.transpose(1, 2),
-        #     encoder_value.transpose(1, 2),
-        # )
-        # [b, s, h, d]
-        sequence_length = query.size(1)
-        encoder_sequence_length = encoder_query.size(1)
-
-        # H
-        query = torch.cat([query, encoder_query], dim=1).unsqueeze(2)
-        key = torch.cat([key, encoder_key], dim=1).unsqueeze(2)
-        value = torch.cat([value, encoder_value], dim=1).unsqueeze(2)
-        # B, S, 3, H, D
-        qkv = torch.cat([query, key, value], dim=2)
-
-        attn_mask = encoder_attention_mask[:, :].bool()
-        attn_mask = F.pad(attn_mask, (sequence_length, 0), value=True)
-        hidden_states = flash_attn_no_pad(
-            qkv, attn_mask, causal=False, dropout_p=0.0, softmax_scale=None
-        )
-
-        # hidden_states = F.scaled_dot_product_attention(query, key, value, attn_mask = None, dropout_p=0.0, is_causal=False)
-
-        # valid_lengths = encoder_attention_mask.sum(dim=1) + sequence_length
-        # def no_padding_mask(score, b, h, q_idx, kv_idx):
-        #     return torch.where(kv_idx < valid_lengths[b],score,  -float("inf"))
-
-        # hidden_states = flex_attention(query, key, value, score_mod=no_padding_mask)
-        if get_sequence_parallel_state():
-            hidden_states, encoder_hidden_states = hidden_states.split_with_sizes(
-                (sequence_length, encoder_sequence_length), dim=1
-            )
-            # B, S, H, D
-            hidden_states = all_to_all_4D(hidden_states, scatter_dim=1, gather_dim=2)
-            encoder_hidden_states = all_gather(
-                encoder_hidden_states, dim=2
-            ).contiguous()
-            hidden_states = hidden_states.flatten(2, 3)
-            hidden_states = hidden_states.to(query.dtype)
-            encoder_hidden_states = encoder_hidden_states.flatten(2, 3)
-            encoder_hidden_states = encoder_hidden_states.to(query.dtype)
-        else:
-            hidden_states = hidden_states.flatten(2, 3)
-            hidden_states = hidden_states.to(query.dtype)
-
-            hidden_states, encoder_hidden_states = hidden_states.split_with_sizes(
-                (sequence_length, encoder_sequence_length), dim=1
-            )
-
-        # linear proj
-        hidden_states = attn.to_out[0](hidden_states)
-        # dropout
-        hidden_states = attn.to_out[1](hidden_states)
-
-        if hasattr(attn, "to_add_out"):
-            encoder_hidden_states = attn.to_add_out(encoder_hidden_states)
-
-        return hidden_states, encoder_hidden_states
-
-
-@maybe_allow_in_graph
-class MochiTransformerBlock(nn.Module):
-    r"""
-    Transformer block used in [Mochi](https://huggingface.co/genmo/mochi-1-preview).
-
-    Args:
-        dim (`int`):
-            The number of channels in the input and output.
-        num_attention_heads (`int`):
-            The number of heads to use for multi-head attention.
-        attention_head_dim (`int`):
-            The number of channels in each head.
-        qk_norm (`str`, defaults to `"rms_norm"`):
-            The normalization layer to use.
-        activation_fn (`str`, defaults to `"swiglu"`):
-            Activation function to use in feed-forward.
-        context_pre_only (`bool`, defaults to `False`):
-            Whether or not to process context-related conditions with additional layers.
-        eps (`float`, defaults to `1e-6`):
-            Epsilon value for normalization layers.
-    """
-
-    def __init__(
-        self,
-        dim: int,
-        num_attention_heads: int,
-        attention_head_dim: int,
-        pooled_projection_dim: int,
-        qk_norm: str = "rms_norm",
-        activation_fn: str = "swiglu",
-        context_pre_only: bool = False,
-        eps: float = 1e-6,
-    ) -> None:
-        super().__init__()
-
-        self.context_pre_only = context_pre_only
-        self.ff_inner_dim = (4 * dim * 2) // 3
-        self.ff_context_inner_dim = (4 * pooled_projection_dim * 2) // 3
-
-        self.norm1 = MochiRMSNormZero(dim, 4 * dim, eps=eps, elementwise_affine=False)
-
-        if not context_pre_only:
-            self.norm1_context = MochiRMSNormZero(
-                dim, 4 * pooled_projection_dim, eps=eps, elementwise_affine=False
-            )
-        else:
-            self.norm1_context = MochiLayerNormContinuous(
-                embedding_dim=pooled_projection_dim,
-                conditioning_embedding_dim=dim,
-                eps=eps,
-            )
-
-        self.attn1 = MochiAttention(
-            query_dim=dim,
-            heads=num_attention_heads,
-            dim_head=attention_head_dim,
-            bias=False,
-            added_kv_proj_dim=pooled_projection_dim,
-            added_proj_bias=False,
-            out_dim=dim,
-            out_context_dim=pooled_projection_dim,
-            context_pre_only=context_pre_only,
-            processor=MochiAttnProcessor2_0(),
-            eps=1e-5,
-        )
-
-        # TODO(aryan): norm_context layers are not needed when `context_pre_only` is True
-        self.norm2 = MochiModulatedRMSNorm(eps=eps)
-        self.norm2_context = (
-            MochiModulatedRMSNorm(eps=eps) if not self.context_pre_only else None
-        )
-
-        self.norm3 = MochiModulatedRMSNorm(eps)
-        self.norm3_context = (
-            MochiModulatedRMSNorm(eps=eps) if not self.context_pre_only else None
-        )
-
-        self.ff = FeedForward(
-            dim, inner_dim=self.ff_inner_dim, activation_fn=activation_fn, bias=False
-        )
-        self.ff_context = None
-        if not context_pre_only:
-            self.ff_context = FeedForward(
-                pooled_projection_dim,
-                inner_dim=self.ff_context_inner_dim,
-                activation_fn=activation_fn,
-                bias=False,
-            )
-
-        self.norm4 = MochiModulatedRMSNorm(eps=eps)
-        self.norm4_context = MochiModulatedRMSNorm(eps=eps)
-
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        encoder_hidden_states: torch.Tensor,
-        encoder_attention_mask: torch.Tensor,
-        temb: torch.Tensor,
-        image_rotary_emb: Optional[torch.Tensor] = None,
-        output_attn=False,
-    ) -> Tuple[torch.Tensor, torch.Tensor]:
-        norm_hidden_states, gate_msa, scale_mlp, gate_mlp = self.norm1(
-            hidden_states, temb
-        )
-
-        if not self.context_pre_only:
-            (
-                norm_encoder_hidden_states,
-                enc_gate_msa,
-                enc_scale_mlp,
-                enc_gate_mlp,
-            ) = self.norm1_context(encoder_hidden_states, temb)
-        else:
-            norm_encoder_hidden_states = self.norm1_context(encoder_hidden_states, temb)
-
-        attn_hidden_states, context_attn_hidden_states = self.attn1(
-            hidden_states=norm_hidden_states,
-            encoder_hidden_states=norm_encoder_hidden_states,
-            image_rotary_emb=image_rotary_emb,
-            encoder_attention_mask=encoder_attention_mask,
-        )
-
-        hidden_states = hidden_states + self.norm2(
-            attn_hidden_states, torch.tanh(gate_msa).unsqueeze(1)
-        )
-        norm_hidden_states = self.norm3(
-            hidden_states, (1 + scale_mlp.unsqueeze(1).to(torch.float32))
-        )
-        ff_output = self.ff(norm_hidden_states)
-        hidden_states = hidden_states + self.norm4(
-            ff_output, torch.tanh(gate_mlp).unsqueeze(1)
-        )
-
-        if not self.context_pre_only:
-            encoder_hidden_states = encoder_hidden_states + self.norm2_context(
-                context_attn_hidden_states, torch.tanh(enc_gate_msa).unsqueeze(1)
-            )
-            norm_encoder_hidden_states = self.norm3_context(
-                encoder_hidden_states,
-                (1 + enc_scale_mlp.unsqueeze(1).to(torch.float32)),
-            )
-            context_ff_output = self.ff_context(norm_encoder_hidden_states)
-            encoder_hidden_states = encoder_hidden_states + self.norm4_context(
-                context_ff_output, torch.tanh(enc_gate_mlp).unsqueeze(1)
-            )
-
-        if not output_attn:
-            attn_hidden_states = None
-        return hidden_states, encoder_hidden_states, attn_hidden_states
-
-
-class MochiRoPE(nn.Module):
-    r"""
-    RoPE implementation used in [Mochi](https://huggingface.co/genmo/mochi-1-preview).
-
-    Args:
-        base_height (`int`, defaults to `192`):
-            Base height used to compute interpolation scale for rotary positional embeddings.
-        base_width (`int`, defaults to `192`):
-            Base width used to compute interpolation scale for rotary positional embeddings.
-    """
-
-    def __init__(self, base_height: int = 192, base_width: int = 192) -> None:
-        super().__init__()
-
-        self.target_area = base_height * base_width
-
-    def _centers(self, start, stop, num, device, dtype) -> torch.Tensor:
-        edges = torch.linspace(start, stop, num + 1, device=device, dtype=dtype)
-        return (edges[:-1] + edges[1:]) / 2
-
-    def _get_positions(
-        self,
-        num_frames: int,
-        height: int,
-        width: int,
-        device: Optional[torch.device] = None,
-        dtype: Optional[torch.dtype] = None,
-    ) -> torch.Tensor:
-        scale = (self.target_area / (height * width)) ** 0.5
-        t = torch.arange(num_frames * nccl_info.sp_size, device=device, dtype=dtype)
-        h = self._centers(
-            -height * scale / 2, height * scale / 2, height, device, dtype
-        )
-        w = self._centers(-width * scale / 2, width * scale / 2, width, device, dtype)
-
-        grid_t, grid_h, grid_w = torch.meshgrid(t, h, w, indexing="ij")
-
-        positions = torch.stack([grid_t, grid_h, grid_w], dim=-1).view(-1, 3)
-        return positions
-
-    def _create_rope(self, freqs: torch.Tensor, pos: torch.Tensor) -> torch.Tensor:
-        with torch.autocast(freqs.device.type, enabled=False):
-            # Always run ROPE freqs computation in FP32
-            freqs = torch.einsum(
-                "nd,dhf->nhf", pos.to(torch.float32), freqs.to(torch.float32)
-            )
-        freqs_cos = torch.cos(freqs)
-        freqs_sin = torch.sin(freqs)
-        return freqs_cos, freqs_sin
-
-    def forward(
-        self,
-        pos_frequencies: torch.Tensor,
-        num_frames: int,
-        height: int,
-        width: int,
-        device: Optional[torch.device] = None,
-        dtype: Optional[torch.dtype] = None,
-    ) -> Tuple[torch.Tensor, torch.Tensor]:
-        pos = self._get_positions(num_frames, height, width, device, dtype)
-        rope_cos, rope_sin = self._create_rope(pos_frequencies, pos)
-        return rope_cos, rope_sin
-
-
-@maybe_allow_in_graph
-class MochiTransformer3DModel(ModelMixin, ConfigMixin, PeftAdapterMixin):
-    r"""
-    A Transformer model for video-like data introduced in [Mochi](https://huggingface.co/genmo/mochi-1-preview).
-
-    Args:
-        patch_size (`int`, defaults to `2`):
-            The size of the patches to use in the patch embedding layer.
-        num_attention_heads (`int`, defaults to `24`):
-            The number of heads to use for multi-head attention.
-        attention_head_dim (`int`, defaults to `128`):
-            The number of channels in each head.
-        num_layers (`int`, defaults to `48`):
-            The number of layers of Transformer blocks to use.
-        in_channels (`int`, defaults to `12`):
-            The number of channels in the input.
-        out_channels (`int`, *optional*, defaults to `None`):
-            The number of channels in the output.
-        qk_norm (`str`, defaults to `"rms_norm"`):
-            The normalization layer to use.
-        text_embed_dim (`int`, defaults to `4096`):
-            Input dimension of text embeddings from the text encoder.
-        time_embed_dim (`int`, defaults to `256`):
-            Output dimension of timestep embeddings.
-        activation_fn (`str`, defaults to `"swiglu"`):
-            Activation function to use in feed-forward.
-        max_sequence_length (`int`, defaults to `256`):
-            The maximum sequence length of text embeddings supported.
-    """
-
-    _supports_gradient_checkpointing = True
-
-    @register_to_config
-    def __init__(
-        self,
-        patch_size: int = 2,
-        num_attention_heads: int = 24,
-        attention_head_dim: int = 128,
-        num_layers: int = 48,
-        pooled_projection_dim: int = 1536,
-        in_channels: int = 12,
-        out_channels: Optional[int] = None,
-        qk_norm: str = "rms_norm",
-        text_embed_dim: int = 4096,
-        time_embed_dim: int = 256,
-        activation_fn: str = "swiglu",
-        max_sequence_length: int = 256,
-    ) -> None:
-        super().__init__()
-
-        inner_dim = num_attention_heads * attention_head_dim
-        out_channels = out_channels or in_channels
-
-        self.patch_embed = PatchEmbed(
-            patch_size=patch_size,
-            in_channels=in_channels,
-            embed_dim=inner_dim,
-            pos_embed_type=None,
-        )
-
-        self.time_embed = MochiCombinedTimestepCaptionEmbedding(
-            embedding_dim=inner_dim,
-            pooled_projection_dim=pooled_projection_dim,
-            text_embed_dim=text_embed_dim,
-            time_embed_dim=time_embed_dim,
-            num_attention_heads=8,
-        )
-
-        self.pos_frequencies = nn.Parameter(
-            torch.full((3, num_attention_heads, attention_head_dim // 2), 0.0)
-        )
-        self.rope = MochiRoPE()
-
-        self.transformer_blocks = nn.ModuleList(
-            [
-                MochiTransformerBlock(
-                    dim=inner_dim,
-                    num_attention_heads=num_attention_heads,
-                    attention_head_dim=attention_head_dim,
-                    pooled_projection_dim=pooled_projection_dim,
-                    qk_norm=qk_norm,
-                    activation_fn=activation_fn,
-                    context_pre_only=i == num_layers - 1,
-                )
-                for i in range(num_layers)
-            ]
-        )
-
-        self.norm_out = AdaLayerNormContinuous(
-            inner_dim,
-            inner_dim,
-            elementwise_affine=False,
-            eps=1e-6,
-            norm_type="layer_norm",
-        )
-        self.proj_out = nn.Linear(inner_dim, patch_size * patch_size * out_channels)
-
-        self.gradient_checkpointing = False
-
-    def _set_gradient_checkpointing(self, module, value=False):
-        if hasattr(module, "gradient_checkpointing"):
-            module.gradient_checkpointing = value
-
-    def forward(
-        self,
-        hidden_states: torch.Tensor,
-        encoder_hidden_states: torch.Tensor,
-        timestep: torch.LongTensor,
-        encoder_attention_mask: torch.Tensor,
-        output_attn=False,
-        attention_kwargs: Optional[Dict[str, Any]] = None,
-        return_dict: bool = False,
-    ) -> torch.Tensor:
-        assert (
-            return_dict is False
-        ), "return_dict is not supported in MochiTransformer3DModel"
-
-        if attention_kwargs is not None:
-            attention_kwargs = attention_kwargs.copy()
-            lora_scale = attention_kwargs.pop("scale", 1.0)
-        else:
-            lora_scale = 1.0
-
-        if USE_PEFT_BACKEND:
-            # weight the lora layers by setting `lora_scale` for each PEFT layer
-            scale_lora_layers(self, lora_scale)
-        else:
-            if (
-                attention_kwargs is not None
-                and attention_kwargs.get("scale", None) is not None
-            ):
-                logger.warning(
-                    "Passing `scale` via `attention_kwargs` when not using the PEFT backend is ineffective."
-                )
-
-        batch_size, num_channels, num_frames, height, width = hidden_states.shape
-        p = self.config.patch_size
-
-        post_patch_height = height // p
-        post_patch_width = width // p
-        # Peiyuan: This is hacked to force mochi to follow the behaviour of SD3 and Flux
-        timestep = 1000 - timestep
-        temb, encoder_hidden_states = self.time_embed(
-            timestep,
-            encoder_hidden_states,
-            encoder_attention_mask,
-            hidden_dtype=hidden_states.dtype,
-        )
-
-        hidden_states = hidden_states.permute(0, 2, 1, 3, 4).flatten(0, 1)
-        hidden_states = self.patch_embed(hidden_states)
-        hidden_states = hidden_states.unflatten(0, (batch_size, -1)).flatten(1, 2)
-
-        image_rotary_emb = self.rope(
-            self.pos_frequencies,
-            num_frames,
-            post_patch_height,
-            post_patch_width,
-            device=hidden_states.device,
-            dtype=torch.float32,
-        )
-        attn_outputs_list = []
-        for i, block in enumerate(self.transformer_blocks):
-            if self.gradient_checkpointing:
-
-                def create_custom_forward(module):
-                    def custom_forward(*inputs):
-                        return module(*inputs)
-
-                    return custom_forward
-
-                ckpt_kwargs: Dict[str, Any] = (
-                    {"use_reentrant": False} if is_torch_version(">=", "1.11.0") else {}
-                )
-                (
-                    hidden_states,
-                    encoder_hidden_states,
-                    attn_outputs,
-                ) = torch.utils.checkpoint.checkpoint(
-                    create_custom_forward(block),
-                    hidden_states,
-                    encoder_hidden_states,
-                    encoder_attention_mask,
-                    temb,
-                    image_rotary_emb,
-                    output_attn,
-                    **ckpt_kwargs,
-                )
-            else:
-                hidden_states, encoder_hidden_states, attn_outputs = block(
-                    hidden_states=hidden_states,
-                    encoder_hidden_states=encoder_hidden_states,
-                    encoder_attention_mask=encoder_attention_mask,
-                    temb=temb,
-                    image_rotary_emb=image_rotary_emb,
-                    output_attn=output_attn,
-                )
-            attn_outputs_list.append(attn_outputs)
-
-        hidden_states = self.norm_out(hidden_states, temb)
-        hidden_states = self.proj_out(hidden_states)
-
-        hidden_states = hidden_states.reshape(
-            batch_size, num_frames, post_patch_height, post_patch_width, p, p, -1
-        )
-        hidden_states = hidden_states.permute(0, 6, 1, 2, 4, 3, 5)
-        output = hidden_states.reshape(batch_size, -1, num_frames, height, width)
-
-        if USE_PEFT_BACKEND:
-            # remove `lora_scale` from each PEFT layer
-            unscale_lora_layers(self, lora_scale)
-
-        if not output_attn:
-            attn_outputs_list = None
-        else:
-            attn_outputs_list = torch.stack(attn_outputs_list, dim=0)
-        # Peiyuan: This is hacked to force mochi to follow the behaviour of SD3 and Flux
-        return (-output, attn_outputs_list)

fastvideo/models/mochi_hf/norm.py

@@ -1,130 +0,0 @@
-# Copyright 2024 The Genmo team and The HuggingFace Team.
-# All rights reserved.
-#
-# 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.
-
-import numbers
-from typing import Dict, Optional, Tuple
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-
-class MochiModulatedRMSNorm(nn.Module):
-    def __init__(self, eps: float):
-        super().__init__()
-
-        self.eps = eps
-
-    def forward(self, hidden_states, scale=None):
-        hidden_states_dtype = hidden_states.dtype
-        hidden_states = hidden_states.to(torch.float32)
-        variance = hidden_states.pow(2).mean(-1, keepdim=True)
-        hidden_states = hidden_states * torch.rsqrt(variance + self.eps)
-        if scale is not None:
-            hidden_states = hidden_states * scale
-
-        hidden_states = hidden_states.to(hidden_states_dtype)
-
-        return hidden_states
-
-
-class MochiRMSNorm(nn.Module):
-    def __init__(self, dim, eps: float, elementwise_affine=True):
-        super().__init__()
-
-        self.eps = eps
-        if elementwise_affine:
-            self.weight = nn.Parameter(torch.ones(dim))
-        else:
-            self.weight = None
-
-    def forward(self, hidden_states):
-        hidden_states_dtype = hidden_states.dtype
-        hidden_states = hidden_states.to(torch.float32)
-        variance = hidden_states.pow(2).mean(-1, keepdim=True)
-        hidden_states = hidden_states * torch.rsqrt(variance + self.eps)
-        if self.weight is not None:
-            # convert into half-precision if necessary
-            if self.weight.dtype in [torch.float16, torch.bfloat16]:
-                hidden_states = hidden_states.to(self.weight.dtype)
-            hidden_states = hidden_states * self.weight
-        hidden_states = hidden_states.to(hidden_states_dtype)
-
-        return hidden_states
-
-
-class MochiLayerNormContinuous(nn.Module):
-    def __init__(
-        self,
-        embedding_dim: int,
-        conditioning_embedding_dim: int,
-        eps=1e-5,
-        bias=True,
-    ):
-        super().__init__()
-
-        # AdaLN
-        self.silu = nn.SiLU()
-        self.linear_1 = nn.Linear(conditioning_embedding_dim, embedding_dim, bias=bias)
-        self.norm = MochiModulatedRMSNorm(eps=eps)
-
-    def forward(
-        self,
-        x: torch.Tensor,
-        conditioning_embedding: torch.Tensor,
-    ) -> torch.Tensor:
-        input_dtype = x.dtype
-
-        # convert back to the original dtype in case `conditioning_embedding`` is upcasted to float32 (needed for hunyuanDiT)
-        scale = self.linear_1(self.silu(conditioning_embedding).to(x.dtype))
-        x = self.norm(x, (1 + scale.unsqueeze(1).to(torch.float32)))
-
-        return x.to(input_dtype)
-
-
-class MochiRMSNormZero(nn.Module):
-    r"""
-    Adaptive RMS Norm used in Mochi.
-    Parameters:
-        embedding_dim (`int`): The size of each embedding vector.
-    """
-
-    def __init__(
-        self,
-        embedding_dim: int,
-        hidden_dim: int,
-        eps: float = 1e-5,
-        elementwise_affine: bool = False,
-    ) -> None:
-        super().__init__()
-
-        self.silu = nn.SiLU()
-        self.linear = nn.Linear(embedding_dim, hidden_dim)
-        self.norm = MochiModulatedRMSNorm(eps=eps)
-
-    def forward(
-        self, hidden_states: torch.Tensor, emb: torch.Tensor
-    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
-        hidden_states_dtype = hidden_states.dtype
-
-        emb = self.linear(self.silu(emb))
-        scale_msa, gate_msa, scale_mlp, gate_mlp = emb.chunk(4, dim=1)
-
-        hidden_states = self.norm(
-            hidden_states, (1 + scale_msa[:, None].to(torch.float32))
-        )
-        hidden_states = hidden_states.to(hidden_states_dtype)
-
-        return hidden_states, gate_msa, scale_mlp, gate_mlp

fastvideo/models/mochi_hf/pipeline_mochi.py

@@ -1,849 +0,0 @@
-# Copyright 2024 Black Forest Labs and The HuggingFace Team. All rights reserved.
-#
-# 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.
-
-import inspect
-from typing import Callable, Dict, List, Optional, Union, Any
-import copy
-import numpy as np
-import torch
-from transformers import T5EncoderModel, T5TokenizerFast
-
-from diffusers.callbacks import MultiPipelineCallbacks, PipelineCallback
-from diffusers.models.autoencoders import AutoencoderKL
-from fastvideo.models.mochi_hf.modeling_mochi import MochiTransformer3DModel
-
-from diffusers.schedulers import FlowMatchEulerDiscreteScheduler
-from diffusers.utils import (
-    is_torch_xla_available,
-    logging,
-    replace_example_docstring,
-)
-from diffusers.utils.torch_utils import randn_tensor
-from diffusers.video_processor import VideoProcessor
-from diffusers.pipelines.pipeline_utils import DiffusionPipeline
-from diffusers.pipelines.mochi.pipeline_output import MochiPipelineOutput
-from einops import rearrange
-from fastvideo.utils.parallel_states import get_sequence_parallel_state, nccl_info
-from fastvideo.utils.communications import all_gather
-from diffusers.loaders import Mochi1LoraLoaderMixin
-
-if is_torch_xla_available():
-    import torch_xla.core.xla_model as xm
-
-    XLA_AVAILABLE = True
-else:
-    XLA_AVAILABLE = False
-
-
-logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
-
-EXAMPLE_DOC_STRING = """
-    Examples:
-        ```py
-        >>> import torch
-        >>> from diffusers import MochiPipeline
-        >>> from diffusers.utils import export_to_video
-
-        >>> pipe = MochiPipeline.from_pretrained("genmo/mochi-1-preview", torch_dtype=torch.bfloat16)
-        >>> pipe.to("cuda")
-        >>> prompt = "Close-up of a chameleon's eye, with its scaly skin changing color. Ultra high resolution 4k."
-        >>> frames = pipe(prompt, num_inference_steps=28, guidance_scale=3.5).frames[0]
-        >>> export_to_video(frames, "mochi.mp4")
-        ```
-"""
-
-
-def calculate_shift(
-    image_seq_len,
-    base_seq_len: int = 256,
-    max_seq_len: int = 4096,
-    base_shift: float = 0.5,
-    max_shift: float = 1.16,
-):
-    m = (max_shift - base_shift) / (max_seq_len - base_seq_len)
-    b = base_shift - m * base_seq_len
-    mu = image_seq_len * m + b
-    return mu
-
-
-# from: https://github.com/genmoai/models/blob/075b6e36db58f1242921deff83a1066887b9c9e1/src/mochi_preview/infer.py#L77
-def linear_quadratic_schedule(num_steps, threshold_noise, linear_steps=None):
-    if linear_steps is None:
-        linear_steps = num_steps // 2
-    linear_sigma_schedule = [
-        i * threshold_noise / linear_steps for i in range(linear_steps)
-    ]
-    threshold_noise_step_diff = linear_steps - threshold_noise * num_steps
-    quadratic_steps = num_steps - linear_steps
-    quadratic_coef = threshold_noise_step_diff / (linear_steps * quadratic_steps**2)
-    linear_coef = threshold_noise / linear_steps - 2 * threshold_noise_step_diff / (
-        quadratic_steps**2
-    )
-    const = quadratic_coef * (linear_steps**2)
-    quadratic_sigma_schedule = [
-        quadratic_coef * (i**2) + linear_coef * i + const
-        for i in range(linear_steps, num_steps)
-    ]
-    sigma_schedule = linear_sigma_schedule + quadratic_sigma_schedule
-    sigma_schedule = [1.0 - x for x in sigma_schedule]
-    return sigma_schedule
-
-
-# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.retrieve_timesteps
-def retrieve_timesteps(
-    scheduler,
-    num_inference_steps: Optional[int] = None,
-    device: Optional[Union[str, torch.device]] = None,
-    timesteps: Optional[List[int]] = None,
-    sigmas: Optional[List[float]] = None,
-    **kwargs,
-):
-    r"""
-    Calls the scheduler's `set_timesteps` method and retrieves timesteps from the scheduler after the call. Handles
-    custom timesteps. Any kwargs will be supplied to `scheduler.set_timesteps`.
-
-    Args:
-        scheduler (`SchedulerMixin`):
-            The scheduler to get timesteps from.
-        num_inference_steps (`int`):
-            The number of diffusion steps used when generating samples with a pre-trained model. If used, `timesteps`
-            must be `None`.
-        device (`str` or `torch.device`, *optional*):
-            The device to which the timesteps should be moved to. If `None`, the timesteps are not moved.
-        timesteps (`List[int]`, *optional*):
-            Custom timesteps used to override the timestep spacing strategy of the scheduler. If `timesteps` is passed,
-            `num_inference_steps` and `sigmas` must be `None`.
-        sigmas (`List[float]`, *optional*):
-            Custom sigmas used to override the timestep spacing strategy of the scheduler. If `sigmas` is passed,
-            `num_inference_steps` and `timesteps` must be `None`.
-
-    Returns:
-        `Tuple[torch.Tensor, int]`: A tuple where the first element is the timestep schedule from the scheduler and the
-        second element is the number of inference steps.
-    """
-    if timesteps is not None and sigmas is not None:
-        raise ValueError(
-            "Only one of `timesteps` or `sigmas` can be passed. Please choose one to set custom values"
-        )
-    if timesteps is not None:
-        accepts_timesteps = "timesteps" in set(
-            inspect.signature(scheduler.set_timesteps).parameters.keys()
-        )
-        if not accepts_timesteps:
-            raise ValueError(
-                f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom"
-                f" timestep schedules. Please check whether you are using the correct scheduler."
-            )
-        scheduler.set_timesteps(timesteps=timesteps, device=device, **kwargs)
-        timesteps = scheduler.timesteps
-        num_inference_steps = len(timesteps)
-    elif sigmas is not None:
-        accept_sigmas = "sigmas" in set(
-            inspect.signature(scheduler.set_timesteps).parameters.keys()
-        )
-        if not accept_sigmas:
-            raise ValueError(
-                f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom"
-                f" sigmas schedules. Please check whether you are using the correct scheduler."
-            )
-        scheduler.set_timesteps(sigmas=sigmas, device=device, **kwargs)
-        timesteps = scheduler.timesteps
-        num_inference_steps = len(timesteps)
-    else:
-        scheduler.set_timesteps(num_inference_steps, device=device, **kwargs)
-        timesteps = scheduler.timesteps
-    return timesteps, num_inference_steps
-
-
-class MochiPipeline(DiffusionPipeline, Mochi1LoraLoaderMixin):
-    r"""
-    The mochi pipeline for text-to-video generation.
-
-    Reference: https://github.com/genmoai/models
-
-    Args:
-        transformer ([`MochiTransformer3DModel`]):
-            Conditional Transformer architecture to denoise the encoded video latents.
-        scheduler ([`FlowMatchEulerDiscreteScheduler`]):
-            A scheduler to be used in combination with `transformer` to denoise the encoded image latents.
-        vae ([`AutoencoderKL`]):
-            Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations.
-        text_encoder ([`T5EncoderModel`]):
-            [T5](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5EncoderModel), specifically
-            the [google/t5-v1_1-xxl](https://huggingface.co/google/t5-v1_1-xxl) variant.
-        tokenizer (`CLIPTokenizer`):
-            Tokenizer of class
-            [CLIPTokenizer](https://huggingface.co/docs/transformers/en/model_doc/clip#transformers.CLIPTokenizer).
-        tokenizer (`T5TokenizerFast`):
-            Second Tokenizer of class
-            [T5TokenizerFast](https://huggingface.co/docs/transformers/en/model_doc/t5#transformers.T5TokenizerFast).
-    """
-
-    model_cpu_offload_seq = "text_encoder->transformer->vae"
-    _optional_components = []
-    _callback_tensor_inputs = ["latents", "prompt_embeds", "negative_prompt_embeds"]
-
-    def __init__(
-        self,
-        scheduler: FlowMatchEulerDiscreteScheduler,
-        vae: AutoencoderKL,
-        text_encoder: T5EncoderModel,
-        tokenizer: T5TokenizerFast,
-        transformer: MochiTransformer3DModel,
-    ):
-        super().__init__()
-
-        self.register_modules(
-            vae=vae,
-            text_encoder=text_encoder,
-            tokenizer=tokenizer,
-            transformer=transformer,
-            scheduler=scheduler,
-        )
-        self.vae_spatial_scale_factor = 8
-        self.vae_temporal_scale_factor = 6
-        self.patch_size = 2
-
-        self.video_processor = VideoProcessor(
-            vae_scale_factor=self.vae_spatial_scale_factor
-        )
-        self.tokenizer_max_length = (
-            self.tokenizer.model_max_length
-            if hasattr(self, "tokenizer") and self.tokenizer is not None
-            else 77
-        )
-        self.default_height = 480
-        self.default_width = 848
-
-    # Adapted from diffusers.pipelines.cogvideo.pipeline_cogvideox.CogVideoXPipeline._get_t5_prompt_embeds
-    def _get_t5_prompt_embeds(
-        self,
-        prompt: Union[str, List[str]] = None,
-        num_videos_per_prompt: int = 1,
-        max_sequence_length: int = 256,
-        device: Optional[torch.device] = None,
-        dtype: Optional[torch.dtype] = None,
-    ):
-        device = device or self._execution_device
-        dtype = dtype or self.text_encoder.dtype
-
-        prompt = [prompt] if isinstance(prompt, str) else prompt
-        batch_size = len(prompt)
-
-        text_inputs = self.tokenizer(
-            prompt,
-            padding="max_length",
-            max_length=max_sequence_length,
-            truncation=True,
-            add_special_tokens=True,
-            return_tensors="pt",
-        )
-        text_input_ids = text_inputs.input_ids
-        prompt_attention_mask = text_inputs.attention_mask
-        prompt_attention_mask = prompt_attention_mask.bool().to(device)
-
-        untruncated_ids = self.tokenizer(
-            prompt, padding="longest", return_tensors="pt"
-        ).input_ids
-
-        if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(
-            text_input_ids, untruncated_ids
-        ):
-            removed_text = self.tokenizer.batch_decode(
-                untruncated_ids[:, max_sequence_length - 1 : -1]
-            )
-            logger.warning(
-                "The following part of your input was truncated because `max_sequence_length` is set to "
-                f" {max_sequence_length} tokens: {removed_text}"
-            )
-
-        prompt_embeds = self.text_encoder(
-            text_input_ids.to(device), attention_mask=prompt_attention_mask
-        )[0]
-        prompt_embeds = prompt_embeds.to(dtype=dtype, device=device)
-
-        # duplicate text embeddings for each generation per prompt, using mps friendly method
-        _, seq_len, _ = prompt_embeds.shape
-        prompt_embeds = prompt_embeds.repeat(1, num_videos_per_prompt, 1)
-        prompt_embeds = prompt_embeds.view(
-            batch_size * num_videos_per_prompt, seq_len, -1
-        )
-
-        prompt_attention_mask = prompt_attention_mask.view(batch_size, -1)
-        prompt_attention_mask = prompt_attention_mask.repeat(num_videos_per_prompt, 1)
-
-        return prompt_embeds, prompt_attention_mask
-
-    # Adapted from diffusers.pipelines.cogvideo.pipeline_cogvideox.CogVideoXPipeline.encode_prompt
-    def encode_prompt(
-        self,
-        prompt: Union[str, List[str]],
-        negative_prompt: Optional[Union[str, List[str]]] = None,
-        do_classifier_free_guidance: bool = True,
-        num_videos_per_prompt: int = 1,
-        prompt_embeds: Optional[torch.Tensor] = None,
-        negative_prompt_embeds: Optional[torch.Tensor] = None,
-        prompt_attention_mask: Optional[torch.Tensor] = None,
-        negative_prompt_attention_mask: Optional[torch.Tensor] = None,
-        max_sequence_length: int = 256,
-        device: Optional[torch.device] = None,
-        dtype: Optional[torch.dtype] = None,
-    ):
-        r"""
-        Encodes the prompt into text encoder hidden states.
-
-        Args:
-            prompt (`str` or `List[str]`, *optional*):
-                prompt to be encoded
-            negative_prompt (`str` or `List[str]`, *optional*):
-                The prompt or prompts not to guide the image generation. If not defined, one has to pass
-                `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is
-                less than `1`).
-            do_classifier_free_guidance (`bool`, *optional*, defaults to `True`):
-                Whether to use classifier free guidance or not.
-            num_videos_per_prompt (`int`, *optional*, defaults to 1):
-                Number of videos that should be generated per prompt. torch device to place the resulting embeddings on
-            prompt_embeds (`torch.Tensor`, *optional*):
-                Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not
-                provided, text embeddings will be generated from `prompt` input argument.
-            negative_prompt_embeds (`torch.Tensor`, *optional*):
-                Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt
-                weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input
-                argument.
-            device: (`torch.device`, *optional*):
-                torch device
-            dtype: (`torch.dtype`, *optional*):
-                torch dtype
-        """
-        device = device or self._execution_device
-
-        prompt = [prompt] if isinstance(prompt, str) else prompt
-        if prompt is not None:
-            batch_size = len(prompt)
-        else:
-            batch_size = prompt_embeds.shape[0]
-
-        if prompt_embeds is None:
-            prompt_embeds, prompt_attention_mask = self._get_t5_prompt_embeds(
-                prompt=prompt,
-                num_videos_per_prompt=num_videos_per_prompt,
-                max_sequence_length=max_sequence_length,
-                device=device,
-                dtype=dtype,
-            )
-
-        if do_classifier_free_guidance and negative_prompt_embeds is None:
-            negative_prompt = negative_prompt or ""
-            negative_prompt = (
-                batch_size * [negative_prompt]
-                if isinstance(negative_prompt, str)
-                else negative_prompt
-            )
-
-            if prompt is not None and type(prompt) is not type(negative_prompt):
-                raise TypeError(
-                    f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !="
-                    f" {type(prompt)}."
-                )
-            elif batch_size != len(negative_prompt):
-                raise ValueError(
-                    f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
-                    f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
-                    " the batch size of `prompt`."
-                )
-
-            (
-                negative_prompt_embeds,
-                negative_prompt_attention_mask,
-            ) = self._get_t5_prompt_embeds(
-                prompt=negative_prompt,
-                num_videos_per_prompt=num_videos_per_prompt,
-                max_sequence_length=max_sequence_length,
-                device=device,
-                dtype=dtype,
-            )
-
-        return (
-            prompt_embeds,
-            prompt_attention_mask,
-            negative_prompt_embeds,
-            negative_prompt_attention_mask,
-        )
-
-    def check_inputs(
-        self,
-        prompt,
-        height,
-        width,
-        callback_on_step_end_tensor_inputs=None,
-        prompt_embeds=None,
-        negative_prompt_embeds=None,
-        prompt_attention_mask=None,
-        negative_prompt_attention_mask=None,
-    ):
-        if height % 8 != 0 or width % 8 != 0:
-            raise ValueError(
-                f"`height` and `width` have to be divisible by 8 but are {height} and {width}."
-            )
-
-        if callback_on_step_end_tensor_inputs is not None and not all(
-            k in self._callback_tensor_inputs
-            for k in callback_on_step_end_tensor_inputs
-        ):
-            raise ValueError(
-                f"`callback_on_step_end_tensor_inputs` has to be in {self._callback_tensor_inputs}, but found {[k for k in callback_on_step_end_tensor_inputs if k not in self._callback_tensor_inputs]}"
-            )
-
-        if prompt is not None and prompt_embeds is not None:
-            raise ValueError(
-                f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to"
-                " only forward one of the two."
-            )
-        elif prompt is None and prompt_embeds is None:
-            raise ValueError(
-                "Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined."
-            )
-        elif prompt is not None and (
-            not isinstance(prompt, str) and not isinstance(prompt, list)
-        ):
-            raise ValueError(
-                f"`prompt` has to be of type `str` or `list` but is {type(prompt)}"
-            )
-
-        if prompt_embeds is not None and prompt_attention_mask is None:
-            raise ValueError(
-                "Must provide `prompt_attention_mask` when specifying `prompt_embeds`."
-            )
-
-        if (
-            negative_prompt_embeds is not None
-            and negative_prompt_attention_mask is None
-        ):
-            raise ValueError(
-                "Must provide `negative_prompt_attention_mask` when specifying `negative_prompt_embeds`."
-            )
-
-        if prompt_embeds is not None and negative_prompt_embeds is not None:
-            if prompt_embeds.shape != negative_prompt_embeds.shape:
-                raise ValueError(
-                    "`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but"
-                    f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`"
-                    f" {negative_prompt_embeds.shape}."
-                )
-            if prompt_attention_mask.shape != negative_prompt_attention_mask.shape:
-                raise ValueError(
-                    "`prompt_attention_mask` and `negative_prompt_attention_mask` must have the same shape when passed directly, but"
-                    f" got: `prompt_attention_mask` {prompt_attention_mask.shape} != `negative_prompt_attention_mask`"
-                    f" {negative_prompt_attention_mask.shape}."
-                )
-
-    def enable_vae_slicing(self):
-        r"""
-        Enable sliced VAE decoding. When this option is enabled, the VAE will split the input tensor in slices to
-        compute decoding in several steps. This is useful to save some memory and allow larger batch sizes.
-        """
-        self.vae.enable_slicing()
-
-    def disable_vae_slicing(self):
-        r"""
-        Disable sliced VAE decoding. If `enable_vae_slicing` was previously enabled, this method will go back to
-        computing decoding in one step.
-        """
-        self.vae.disable_slicing()
-
-    def enable_vae_tiling(self):
-        r"""
-        Enable tiled VAE decoding. When this option is enabled, the VAE will split the input tensor into tiles to
-        compute decoding and encoding in several steps. This is useful for saving a large amount of memory and to allow
-        processing larger images.
-        """
-        self.vae.enable_tiling()
-
-    def disable_vae_tiling(self):
-        r"""
-        Disable tiled VAE decoding. If `enable_vae_tiling` was previously enabled, this method will go back to
-        computing decoding in one step.
-        """
-        self.vae.disable_tiling()
-
-    def prepare_latents(
-        self,
-        batch_size,
-        num_channels_latents,
-        height,
-        width,
-        num_frames,
-        dtype,
-        device,
-        generator,
-        latents=None,
-    ):
-        height = height // self.vae_spatial_scale_factor
-        width = width // self.vae_spatial_scale_factor
-        num_frames = (num_frames - 1) // self.vae_temporal_scale_factor + 1
-
-        shape = (batch_size, num_channels_latents, num_frames, height, width)
-
-        if latents is not None:
-            return latents.to(device=device, dtype=dtype)
-        if isinstance(generator, list) and len(generator) != batch_size:
-            raise ValueError(
-                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
-                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
-            )
-
-        latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
-        return latents
-
-    @property
-    def guidance_scale(self):
-        return self._guidance_scale
-
-    @property
-    def do_classifier_free_guidance(self):
-        return self._guidance_scale > 1.0
-
-    @property
-    def num_timesteps(self):
-        return self._num_timesteps
-
-    @property
-    def attention_kwargs(self):
-        return self._attention_kwargs
-
-    @property
-    def interrupt(self):
-        return self._interrupt
-
-    @torch.no_grad()
-    @replace_example_docstring(EXAMPLE_DOC_STRING)
-    def __call__(
-        self,
-        prompt: Union[str, List[str]] = None,
-        negative_prompt: Optional[Union[str, List[str]]] = None,
-        height: Optional[int] = None,
-        width: Optional[int] = None,
-        num_frames: int = 16,
-        num_inference_steps: int = 28,
-        timesteps: List[int] = None,
-        guidance_scale: float = 4.5,
-        num_videos_per_prompt: Optional[int] = 1,
-        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
-        latents: Optional[torch.Tensor] = None,
-        prompt_embeds: Optional[torch.Tensor] = None,
-        prompt_attention_mask: Optional[torch.Tensor] = None,
-        negative_prompt_embeds: Optional[torch.Tensor] = None,
-        negative_prompt_attention_mask: Optional[torch.Tensor] = None,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-        attention_kwargs: Optional[Dict[str, Any]] = None,
-        callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None,
-        callback_on_step_end_tensor_inputs: List[str] = ["latents"],
-        max_sequence_length: int = 256,
-        return_all_states=False,
-    ):
-        r"""
-        Function invoked when calling the pipeline for generation.
-
-        Args:
-            prompt (`str` or `List[str]`, *optional*):
-                The prompt or prompts to guide the image generation. If not defined, one has to pass `prompt_embeds`.
-                instead.
-            height (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor):
-                The height in pixels of the generated image. This is set to 1024 by default for the best results.
-            width (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor):
-                The width in pixels of the generated image. This is set to 1024 by default for the best results.
-            num_frames (`int`, defaults to 16):
-                The number of video frames to generate
-            num_inference_steps (`int`, *optional*, defaults to 50):
-                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
-                expense of slower inference.
-            timesteps (`List[int]`, *optional*):
-                Custom timesteps to use for the denoising process with schedulers which support a `timesteps` argument
-                in their `set_timesteps` method. If not defined, the default behavior when `num_inference_steps` is
-                passed will be used. Must be in descending order.
-            guidance_scale (`float`, defaults to `4.5`):
-                Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598).
-                `guidance_scale` is defined as `w` of equation 2. of [Imagen
-                Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale >
-                1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`,
-                usually at the expense of lower image quality.
-            num_videos_per_prompt (`int`, *optional*, defaults to 1):
-                The number of videos to generate per prompt.
-            generator (`torch.Generator` or `List[torch.Generator]`, *optional*):
-                One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html)
-                to make generation deterministic.
-            latents (`torch.Tensor`, *optional*):
-                Pre-generated noisy latents, sampled from a Gaussian distribution, to be used as inputs for image
-                generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
-                tensor will ge generated by sampling using the supplied random `generator`.
-            prompt_embeds (`torch.Tensor`, *optional*):
-                Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not
-                provided, text embeddings will be generated from `prompt` input argument.
-            prompt_attention_mask (`torch.Tensor`, *optional*):
-                Pre-generated attention mask for text embeddings.
-            negative_prompt_embeds (`torch.FloatTensor`, *optional*):
-                Pre-generated negative text embeddings. For PixArt-Sigma this negative prompt should be "". If not
-                provided, negative_prompt_embeds will be generated from `negative_prompt` input argument.
-            negative_prompt_attention_mask (`torch.FloatTensor`, *optional*):
-                Pre-generated attention mask for negative text embeddings.
-            output_type (`str`, *optional*, defaults to `"pil"`):
-                The output format of the generate image. Choose between
-                [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`.
-            return_dict (`bool`, *optional*, defaults to `True`):
-                Whether or not to return a [`~pipelines.mochi.MochiPipelineOutput`] instead of a plain tuple.
-            attention_kwargs (`dict`, *optional*):
-                A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under
-                `self.processor` in
-                [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
-            callback_on_step_end (`Callable`, *optional*):
-                A function that calls at the end of each denoising steps during the inference. The function is called
-                with the following arguments: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int,
-                callback_kwargs: Dict)`. `callback_kwargs` will include a list of all tensors as specified by
-                `callback_on_step_end_tensor_inputs`.
-            callback_on_step_end_tensor_inputs (`List`, *optional*):
-                The list of tensor inputs for the `callback_on_step_end` function. The tensors specified in the list
-                will be passed as `callback_kwargs` argument. You will only be able to include variables listed in the
-                `._callback_tensor_inputs` attribute of your pipeline class.
-            max_sequence_length (`int` defaults to `256`):
-                Maximum sequence length to use with the `prompt`.
-
-        Examples:
-
-        Returns:
-            [`~pipelines.mochi.MochiPipelineOutput`] or `tuple`:
-                If `return_dict` is `True`, [`~pipelines.mochi.MochiPipelineOutput`] is returned, otherwise a `tuple`
-                is returned where the first element is a list with the generated images.
-        """
-
-        if isinstance(callback_on_step_end, (PipelineCallback, MultiPipelineCallbacks)):
-            callback_on_step_end_tensor_inputs = callback_on_step_end.tensor_inputs
-
-        height = height or self.default_height
-        width = width or self.default_width
-
-        # 1. Check inputs. Raise error if not correct
-        self.check_inputs(
-            prompt=prompt,
-            height=height,
-            width=width,
-            callback_on_step_end_tensor_inputs=callback_on_step_end_tensor_inputs,
-            prompt_embeds=prompt_embeds,
-            negative_prompt_embeds=negative_prompt_embeds,
-            prompt_attention_mask=prompt_attention_mask,
-            negative_prompt_attention_mask=negative_prompt_attention_mask,
-        )
-
-        self._guidance_scale = guidance_scale
-        self._attention_kwargs = attention_kwargs
-        self._interrupt = False
-
-        # 2. Define call parameters
-        if prompt is not None and isinstance(prompt, str):
-            batch_size = 1
-        elif prompt is not None and isinstance(prompt, list):
-            batch_size = len(prompt)
-        else:
-            batch_size = prompt_embeds.shape[0]
-
-        device = self._execution_device
-
-        # 3. Prepare text embeddings
-        (
-            prompt_embeds,
-            prompt_attention_mask,
-            negative_prompt_embeds,
-            negative_prompt_attention_mask,
-        ) = self.encode_prompt(
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            do_classifier_free_guidance=self.do_classifier_free_guidance,
-            num_videos_per_prompt=num_videos_per_prompt,
-            prompt_embeds=prompt_embeds,
-            negative_prompt_embeds=negative_prompt_embeds,
-            prompt_attention_mask=prompt_attention_mask,
-            negative_prompt_attention_mask=negative_prompt_attention_mask,
-            max_sequence_length=max_sequence_length,
-            device=device,
-        )
-        if self.do_classifier_free_guidance:
-            prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0)
-            prompt_attention_mask = torch.cat(
-                [negative_prompt_attention_mask, prompt_attention_mask], dim=0
-            )
-
-        # 4. Prepare latent variables
-        num_channels_latents = self.transformer.config.in_channels
-        latents = self.prepare_latents(
-            batch_size * num_videos_per_prompt,
-            num_channels_latents,
-            height,
-            width,
-            num_frames,
-            prompt_embeds.dtype,
-            device,
-            generator,
-            latents,
-        )
-        world_size, rank = nccl_info.sp_size, nccl_info.rank_within_group
-        if get_sequence_parallel_state():
-            latents = rearrange(
-                latents, "b t (n s) h w -> b t n s h w", n=world_size
-            ).contiguous()
-            latents = latents[:, :, rank, :, :, :]
-
-        original_noise = copy.deepcopy(latents)
-        # 5. Prepare timestep
-        # from https://github.com/genmoai/models/blob/075b6e36db58f1242921deff83a1066887b9c9e1/src/mochi_preview/infer.py#L77
-        threshold_noise = 0.025
-        sigmas = linear_quadratic_schedule(num_inference_steps, threshold_noise)
-        sigmas = np.array(sigmas)
-        # check if of type FlowMatchEulerDiscreteScheduler
-        if isinstance(self.scheduler, FlowMatchEulerDiscreteScheduler):
-            timesteps, num_inference_steps = retrieve_timesteps(
-                self.scheduler,
-                num_inference_steps,
-                device,
-                timesteps,
-                sigmas,
-            )
-        else:
-            timesteps, num_inference_steps = retrieve_timesteps(
-                self.scheduler,
-                num_inference_steps,
-                device,
-            )
-        num_warmup_steps = max(
-            len(timesteps) - num_inference_steps * self.scheduler.order, 0
-        )
-        self._num_timesteps = len(timesteps)
-
-        # 6. Denoising loop
-        with self.progress_bar(total=num_inference_steps) as progress_bar:
-            for i, t in enumerate(timesteps):
-                if self.interrupt:
-                    continue
-
-                latent_model_input = (
-                    torch.cat([latents] * 2)
-                    if self.do_classifier_free_guidance
-                    else latents
-                )
-                # broadcast to batch dimension in a way that's compatible with ONNX/Core ML
-                timestep = t.expand(latent_model_input.shape[0]).to(latents.dtype)
-
-                noise_pred = self.transformer(
-                    hidden_states=latent_model_input,
-                    encoder_hidden_states=prompt_embeds,
-                    timestep=timestep,
-                    encoder_attention_mask=prompt_attention_mask,
-                    attention_kwargs=attention_kwargs,
-                    return_dict=False,
-                )[0]
-
-                # Mochi CFG + Sampling runs in FP32
-                noise_pred = noise_pred.to(torch.float32)
-                if self.do_classifier_free_guidance:
-                    noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
-                    noise_pred = noise_pred_uncond + self.guidance_scale * (
-                        noise_pred_text - noise_pred_uncond
-                    )
-
-                # compute the previous noisy sample x_t -> x_t-1
-                latents_dtype = latents.dtype
-                latents = self.scheduler.step(
-                    noise_pred, t, latents.to(torch.float32), return_dict=False
-                )[0]
-                latents = latents.to(latents_dtype)
-
-                if latents.dtype != latents_dtype:
-                    if torch.backends.mps.is_available():
-                        # some platforms (eg. apple mps) misbehave due to a pytorch bug: https://github.com/pytorch/pytorch/pull/99272
-                        latents = latents.to(latents_dtype)
-
-                if callback_on_step_end is not None:
-                    callback_kwargs = {}
-                    for k in callback_on_step_end_tensor_inputs:
-                        callback_kwargs[k] = locals()[k]
-                    callback_outputs = callback_on_step_end(self, i, t, callback_kwargs)
-
-                    latents = callback_outputs.pop("latents", latents)
-                    prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds)
-
-                # call the callback, if provided
-                if i == len(timesteps) - 1 or (
-                    (i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0
-                ):
-                    progress_bar.update()
-
-                if XLA_AVAILABLE:
-                    xm.mark_step()
-
-        if get_sequence_parallel_state():
-            latents = all_gather(latents, dim=2)
-            # latents_shape = list(latents.shape)
-            # full_shape = [latents_shape[0] * world_size] + latents_shape[1:]
-            # all_latents = torch.zeros(full_shape, dtype=latents.dtype, device=latents.device)
-            # torch.distributed.all_gather_into_tensor(all_latents, latents)
-            # latents_list = list(all_latents.chunk(world_size, dim=0))
-            # latents = torch.cat(latents_list, dim=2)
-
-        if output_type == "latent":
-            video = latents
-        else:
-            # unscale/denormalize the latents
-            # denormalize with the mean and std if available and not None
-            has_latents_mean = (
-                hasattr(self.vae.config, "latents_mean")
-                and self.vae.config.latents_mean is not None
-            )
-            has_latents_std = (
-                hasattr(self.vae.config, "latents_std")
-                and self.vae.config.latents_std is not None
-            )
-            if has_latents_mean and has_latents_std:
-                latents_mean = (
-                    torch.tensor(self.vae.config.latents_mean)
-                    .view(1, 12, 1, 1, 1)
-                    .to(latents.device, latents.dtype)
-                )
-                latents_std = (
-                    torch.tensor(self.vae.config.latents_std)
-                    .view(1, 12, 1, 1, 1)
-                    .to(latents.device, latents.dtype)
-                )
-                latents = (
-                    latents * latents_std / self.vae.config.scaling_factor
-                    + latents_mean
-                )
-            else:
-                latents = latents / self.vae.config.scaling_factor
-
-            video = self.vae.decode(latents, return_dict=False)[0]
-            video = self.video_processor.postprocess_video(
-                video, output_type=output_type
-            )
-
-        # Offload all models
-        self.maybe_free_model_hooks()
-        if return_all_states:
-            # Pay extra attention here:
-            # prompt_embeds with shape torch.Size([2, 256]), where prompt_embeds[1] is the prompt_embeds for the actual prompt
-            # prompt_embeds[0] is for negative prompt
-            return original_noise, video, latents, prompt_embeds, prompt_attention_mask
-
-        if not return_dict:
-            return (video,)
-
-        return MochiPipelineOutput(frames=video)

fastvideo/sample/generate_synthetic.py

@@ -1,133 +0,0 @@
-import json
-
-import torch.distributed as dist
-import torch
-from fastvideo.models.mochi_hf.pipeline_mochi import MochiPipeline
-import os
-from diffusers.utils import export_to_video
-import argparse
-
-
-def generate_video_and_latent(
-    pipe, prompt, height, width, num_frames, num_inference_steps, guidance_scale
-):
-    # Set the random seed for reproducibility
-    generator = torch.Generator("cuda").manual_seed(12345)
-    # Generate videos from the input prompt
-    noise, video, latent, prompt_embed, prompt_attention_mask = pipe(
-        prompt=prompt,
-        height=height,
-        width=width,
-        num_frames=num_frames,
-        generator=generator,
-        num_inference_steps=num_inference_steps,
-        guidance_scale=guidance_scale,
-        output_type="latent_and_video",
-    )
-    # prompt_embed has negative prompt at index 0
-    return noise[0], video[0], latent[0], prompt_embed[1], prompt_attention_mask[1]
-
-    # return dummy tensor to debug first
-    # return torch.zeros(1, 3, 480, 848), torch.zeros(1, 256, 16, 16)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--num_frames", type=int, default=163)
-    parser.add_argument("--height", type=int, default=480)
-    parser.add_argument("--width", type=int, default=848)
-    parser.add_argument("--num_inference_steps", type=int, default=64)
-    parser.add_argument("--guidance_scale", type=float, default=4.5)
-    parser.add_argument("--model_path", type=str, default="data/mochi")
-    parser.add_argument(
-        "--prompt_path", type=str, default="data/dummyVid/videos2caption.json"
-    )
-    parser.add_argument("--dataset_output_dir", type=str, default="data/dummySynthetic")
-    args = parser.parse_args()
-
-    local_rank = int(os.getenv("RANK", 0))
-    world_size = int(os.getenv("WORLD_SIZE", 1))
-    print("world_size", world_size, "local rank", local_rank)
-    torch.cuda.set_device(local_rank)
-    dist.init_process_group(
-        backend="nccl", init_method="env://", world_size=world_size, rank=local_rank
-    )
-
-    if not isinstance(args.prompt_path, list):
-        args.prompt_path = [args.prompt_path]
-    if len(args.prompt_path) == 1 and args.prompt_path[0].endswith("txt"):
-        text_prompt = open(args.prompt_path[0], "r").readlines()
-        text_prompt = [i.strip() for i in text_prompt]
-
-    pipe = MochiPipeline.from_pretrained(args.model_path, torch_dtype=torch.bfloat16)
-    pipe.enable_vae_tiling()
-    pipe.enable_model_cpu_offload(gpu_id=local_rank)
-    # make dir if not exist
-
-    os.makedirs(args.dataset_output_dir, exist_ok=True)
-    os.makedirs(os.path.join(args.dataset_output_dir, "noise"), exist_ok=True)
-    os.makedirs(os.path.join(args.dataset_output_dir, "video"), exist_ok=True)
-    os.makedirs(os.path.join(args.dataset_output_dir, "latent"), exist_ok=True)
-    os.makedirs(os.path.join(args.dataset_output_dir, "prompt_embed"), exist_ok=True)
-    os.makedirs(
-        os.path.join(args.dataset_output_dir, "prompt_attention_mask"), exist_ok=True
-    )
-    data = []
-    for i, prompt in enumerate(text_prompt):
-        if i % world_size != local_rank:
-            continue
-        (
-            noise,
-            video,
-            latent,
-            prompt_embed,
-            prompt_attention_mask,
-        ) = generate_video_and_latent(
-            pipe,
-            prompt,
-            args.height,
-            args.width,
-            args.num_frames,
-            args.num_inference_steps,
-            args.guidance_scale,
-        )
-        # save latent
-        video_name = str(i)
-        noise_path = os.path.join(args.dataset_output_dir, "noise", video_name + ".pt")
-        latent_path = os.path.join(
-            args.dataset_output_dir, "latent", video_name + ".pt"
-        )
-        prompt_embed_path = os.path.join(
-            args.dataset_output_dir, "prompt_embed", video_name + ".pt"
-        )
-        video_path = os.path.join(args.dataset_output_dir, "video", video_name + ".mp4")
-        prompt_attention_mask_path = os.path.join(
-            args.dataset_output_dir, "prompt_attention_mask", video_name + ".pt"
-        )
-        # save latent
-        torch.save(noise, noise_path)
-        torch.save(latent, latent_path)
-        torch.save(prompt_embed, prompt_embed_path)
-        torch.save(prompt_attention_mask, prompt_attention_mask_path)
-        export_to_video(video, video_path, fps=30)
-        item = {}
-
-        item["cap"] = prompt
-        item["video"] = video_name + ".mp4"
-        item["noise"] = video_name + ".pt"
-        item["latent_path"] = video_name + ".pt"
-        item["prompt_embed_path"] = video_name + ".pt"
-        item["prompt_attention_mask"] = video_name + ".pt"
-        data.append(item)
-    dist.barrier()
-    local_data = data
-    gathered_data = [None] * world_size
-    dist.all_gather_object(gathered_data, local_data)
-
-    # save json
-    if local_rank == 0:
-        all_data = [item for sublist in gathered_data for item in sublist]
-        with open(
-            os.path.join(args.dataset_output_dir, "videos2caption.json"), "w"
-        ) as f:
-            json.dump(all_data, f, indent=4)

fastvideo/sample/sample_t2v_mochi.py

@@ -1,177 +0,0 @@
-import torch
-from fastvideo.models.mochi_hf.pipeline_mochi import MochiPipeline
-import torch.distributed as dist
-
-from diffusers.utils import export_to_video
-from fastvideo.utils.parallel_states import (
-    initialize_sequence_parallel_state,
-    nccl_info,
-)
-import argparse
-import os
-from fastvideo.models.mochi_hf.modeling_mochi import MochiTransformer3DModel
-import json
-from typing import Optional
-from safetensors.torch import save_file, load_file
-from peft import set_peft_model_state_dict, inject_adapter_in_model, load_peft_weights
-from peft import LoraConfig
-import sys
-import pdb
-import copy
-from typing import Dict
-from diffusers import FlowMatchEulerDiscreteScheduler
-from diffusers.utils import convert_unet_state_dict_to_peft
-from fastvideo.distill.solver import PCMFMScheduler
-
-
-def initialize_distributed():
-    local_rank = int(os.getenv("RANK", 0))
-    world_size = int(os.getenv("WORLD_SIZE", 1))
-    print("world_size", world_size)
-    torch.cuda.set_device(local_rank)
-    dist.init_process_group(
-        backend="nccl", init_method="env://", world_size=world_size, rank=local_rank
-    )
-    initialize_sequence_parallel_state(world_size)
-
-
-def main(args):
-    initialize_distributed()
-    print(nccl_info.sp_size)
-    device = torch.cuda.current_device()
-    generator = torch.Generator(device).manual_seed(args.seed)
-    weight_dtype = torch.bfloat16
-    if args.scheduler_type == "euler":
-        scheduler = FlowMatchEulerDiscreteScheduler()
-    else:
-        linear_quadratic = True if "linear_quadratic" in args.scheduler_type else False
-        scheduler = PCMFMScheduler(
-            1000,
-            args.shift,
-            args.num_euler_timesteps,
-            linear_quadratic,
-            args.linear_threshold,
-            args.linear_range,
-        )
-    if args.transformer_path is not None:
-        transformer = MochiTransformer3DModel.from_pretrained(args.transformer_path)
-    else:
-        transformer = MochiTransformer3DModel.from_pretrained(
-            args.model_path, subfolder="transformer/"
-        )
-
-    pipe = MochiPipeline.from_pretrained(
-        args.model_path, transformer=transformer, scheduler=scheduler
-    )
-
-    pipe.enable_vae_tiling()
-
-    if args.lora_checkpoint_dir is not None:
-        print(f"Loading LoRA weights from {args.lora_checkpoint_dir}")
-        config_path = os.path.join(args.lora_checkpoint_dir, "lora_config.json")
-        with open(config_path, "r") as f:
-            lora_config_dict = json.load(f)
-        rank = lora_config_dict["lora_params"]["lora_rank"]
-        lora_alpha = lora_config_dict["lora_params"]["lora_alpha"]
-        lora_scaling = lora_alpha / rank
-        pipe.load_lora_weights(args.lora_checkpoint_dir, adapter_name="default")
-        pipe.set_adapters(["default"], [lora_scaling])
-        print(f"Successfully Loaded LoRA weights from {args.lora_checkpoint_dir}")
-    # pipe.to(device)
-
-    pipe.enable_model_cpu_offload(device)
-
-    # Generate videos from the input prompt
-
-    if args.prompt_embed_path is not None:
-        prompt_embeds = (
-            torch.load(args.prompt_embed_path, map_location="cpu", weights_only=True)
-            .to(device)
-            .unsqueeze(0)
-        )
-        encoder_attention_mask = (
-            torch.load(
-                args.encoder_attention_mask_path, map_location="cpu", weights_only=True
-            )
-            .to(device)
-            .unsqueeze(0)
-        )
-        prompts = None
-    elif args.prompt_path is not None:
-        prompts = [line.strip() for line in open(args.prompt_path, "r")]
-        prompt_embeds = None
-        encoder_attention_mask = None
-    else:
-        prompts = args.prompts
-        prompt_embeds = None
-        encoder_attention_mask = None
-
-    if prompts is not None:
-        videos = []
-        with torch.autocast("cuda", dtype=torch.bfloat16):
-            for prompt in prompts:
-                video = pipe(
-                    prompt=[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=generator,
-                ).frames
-                videos.append(video[0])
-    else:
-        with torch.autocast("cuda", dtype=torch.bfloat16):
-            videos = pipe(
-                prompt_embeds=prompt_embeds,
-                prompt_attention_mask=encoder_attention_mask,
-                height=args.height,
-                width=args.width,
-                num_frames=args.num_frames,
-                num_inference_steps=args.num_inference_steps,
-                guidance_scale=args.guidance_scale,
-                generator=generator,
-            ).frames
-
-    if nccl_info.global_rank <= 0:
-        if prompts is not None:
-            # mkdir
-            os.makedirs(args.output_path, exist_ok=True)
-            for video, prompt in zip(videos, prompts):
-                suffix = prompt.split(".")[0]
-                export_to_video(
-                    video, os.path.join(args.output_path, f"{suffix}.mp4"), fps=30
-                )
-        else:
-            export_to_video(videos[0], args.output_path + ".mp4", fps=30)
-
-
-if __name__ == "__main__":
-    # arg parse
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--prompts", nargs="+", default=[])
-    parser.add_argument("--num_frames", type=int, default=163)
-    parser.add_argument("--height", type=int, default=480)
-    parser.add_argument("--width", type=int, default=848)
-    parser.add_argument("--num_inference_steps", type=int, default=64)
-    parser.add_argument("--guidance_scale", type=float, default=4.5)
-    parser.add_argument("--model_path", type=str, default="data/mochi")
-    parser.add_argument("--seed", type=int, default=42)
-    parser.add_argument("--output_path", type=str, default="./outputs.mp4")
-    parser.add_argument("--transformer_path", type=str, default=None)
-    parser.add_argument("--prompt_embed_path", type=str, default=None)
-    parser.add_argument("--prompt_path", type=str, default=None)
-    parser.add_argument("--scheduler_type", type=str, default="euler")
-    parser.add_argument("--encoder_attention_mask_path", type=str, default=None)
-    parser.add_argument(
-        "--lora_checkpoint_dir",
-        type=str,
-        default=None,
-        help="Path to the directory containing LoRA checkpoints",
-    )
-    parser.add_argument("--shift", type=float, default=8.0)
-    parser.add_argument("--num_euler_timesteps", type=int, default=100)
-    parser.add_argument("--linear_threshold", type=float, default=0.025)
-    parser.add_argument("--linear_range", type=float, default=0.5)
-    args = parser.parse_args()
-    main(args)

fastvideo/sample/sample_t2v_mochi_no_sp.py

@@ -1,57 +0,0 @@
-import torch
-from fastvideo.models.mochi_hf.pipeline_mochi import MochiPipeline
-from fastvideo.models.mochi_hf.modeling_mochi import MochiTransformer3DModel
-from diffusers.utils import export_to_video, load_image, load_video
-import argparse
-from diffusers import FlowMatchEulerDiscreteScheduler
-
-
-def main(args):
-    # Set the random seed for reproducibility
-    generator = torch.Generator("cuda").manual_seed(args.seed)
-    # do not invert
-    scheduler = FlowMatchEulerDiscreteScheduler()
-    if args.transformer_path is not None:
-        transformer = MochiTransformer3DModel.from_pretrained(args.transformer_path)
-    else:
-        transformer = MochiTransformer3DModel.from_pretrained(
-            args.model_path, subfolder="transformer/"
-        )
-    pipe = MochiPipeline.from_pretrained(
-        args.model_path, transformer=transformer, scheduler=scheduler
-    )
-    pipe.enable_vae_tiling()
-    # pipe.to("cuda:1")
-    pipe.enable_model_cpu_offload()
-
-    # Generate videos from the input prompt
-    with torch.autocast("cuda", dtype=torch.bfloat16):
-        videos = pipe(
-            prompt=args.prompts,
-            height=args.height,
-            width=args.width,
-            num_frames=args.num_frames,
-            generator=generator,
-            num_inference_steps=args.num_inference_steps,
-            guidance_scale=args.guidance_scale,
-        ).frames
-
-    for prompt, video in zip(args.prompts, videos):
-        export_to_video(video, args.output_path + f"_{prompt}.mp4", fps=30)
-
-
-if __name__ == "__main__":
-    # arg parse
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--prompts", nargs="+", default=[])
-    parser.add_argument("--num_frames", type=int, default=163)
-    parser.add_argument("--height", type=int, default=480)
-    parser.add_argument("--width", type=int, default=848)
-    parser.add_argument("--num_inference_steps", type=int, default=64)
-    parser.add_argument("--guidance_scale", type=float, default=4.5)
-    parser.add_argument("--model_path", type=str, default="data/mochi")
-    parser.add_argument("--seed", type=int, default=12345)
-    parser.add_argument("--transformer_path", type=str, default=None)
-    parser.add_argument("--output_path", type=str, default="./outputs.mp4")
-    args = parser.parse_args()
-    main(args)

fastvideo/train.py

@@ -1,733 +0,0 @@
-import argparse
-from email.policy import strict
-import logging
-import math
-import os
-import shutil
-from pathlib import Path
-from fastvideo.utils.parallel_states import (
-    initialize_sequence_parallel_state,
-    destroy_sequence_parallel_group,
-    get_sequence_parallel_state,
-    nccl_info,
-)
-from fastvideo.utils.communications import sp_parallel_dataloader_wrapper, broadcast
-from fastvideo.models.mochi_hf.mochi_latents_utils import normalize_mochi_dit_input
-from fastvideo.utils.validation import log_validation
-import time
-from torch.utils.data import DataLoader
-import torch
-from torch.distributed.fsdp import (
-    FullyShardedDataParallel as FSDP,
-    StateDictType,
-    FullStateDictConfig,
-)
-import json
-from torch.utils.data.distributed import DistributedSampler
-from fastvideo.utils.dataset_utils import LengthGroupedSampler
-import wandb
-from accelerate.utils import set_seed
-from tqdm.auto import tqdm
-from fastvideo.fsdp_util import get_dit_fsdp_kwargs, apply_fsdp_checkpointing
-from diffusers.utils import convert_unet_state_dict_to_peft
-from diffusers import (
-    FlowMatchEulerDiscreteScheduler,
-)
-from diffusers.optimization import get_scheduler
-from fastvideo.models.mochi_hf.modeling_mochi import MochiTransformer3DModel
-from diffusers.utils import check_min_version
-from fastvideo.dataset.latent_datasets import LatentDataset, latent_collate_function
-import torch.distributed as dist
-from safetensors.torch import save_file, load_file
-from peft import LoraConfig, get_peft_model_state_dict, set_peft_model_state_dict
-from torch.distributed.fsdp import (
-    FullyShardedDataParallel as FSDP,
-)
-from fastvideo.utils.checkpoint import (
-    save_checkpoint,
-    save_lora_checkpoint,
-    resume_lora_optimizer,
-)
-from fastvideo.utils.logging import main_print
-from fastvideo.models.mochi_hf.pipeline_mochi import MochiPipeline
-# Will error if the minimal version of diffusers is not installed. Remove at your own risks.
-check_min_version("0.31.0")
-import time
-from collections import deque
-
-
-def compute_density_for_timestep_sampling(
-    weighting_scheme: str,
-    batch_size: int,
-    generator,
-    logit_mean: float = None,
-    logit_std: float = None,
-    mode_scale: float = None,
-):
-    """
-    Compute the density for sampling the timesteps when doing SD3 training.
-
-    Courtesy: This was contributed by Rafie Walker in https://github.com/huggingface/diffusers/pull/8528.
-
-    SD3 paper reference: https://arxiv.org/abs/2403.03206v1.
-    """
-    if weighting_scheme == "logit_normal":
-        # See 3.1 in the SD3 paper ($rf/lognorm(0.00,1.00)$).
-        u = torch.normal(
-            mean=logit_mean,
-            std=logit_std,
-            size=(batch_size,),
-            device="cpu",
-            generator=generator,
-        )
-        u = torch.nn.functional.sigmoid(u)
-    elif weighting_scheme == "mode":
-        u = torch.rand(size=(batch_size,), device="cpu", generator=generator)
-        u = 1 - u - mode_scale * (torch.cos(math.pi * u / 2) ** 2 - 1 + u)
-    else:
-        u = torch.rand(size=(batch_size,), device="cpu", generator=generator)
-    return u
-
-
-def get_sigmas(noise_scheduler, device, timesteps, n_dim=4, dtype=torch.float32):
-    sigmas = noise_scheduler.sigmas.to(device=device, dtype=dtype)
-    schedule_timesteps = noise_scheduler.timesteps.to(device)
-    timesteps = timesteps.to(device)
-    step_indices = [(schedule_timesteps == t).nonzero().item() for t in timesteps]
-
-    sigma = sigmas[step_indices].flatten()
-    while len(sigma.shape) < n_dim:
-        sigma = sigma.unsqueeze(-1)
-    return sigma
-
-
-def train_one_step_mochi(
-    transformer,
-    optimizer,
-    lr_scheduler,
-    loader,
-    noise_scheduler,
-    noise_random_generator,
-    gradient_accumulation_steps,
-    sp_size,
-    precondition_outputs,
-    max_grad_norm,
-    weighting_scheme,
-    logit_mean,
-    logit_std,
-    mode_scale,
-):
-    total_loss = 0.0
-    optimizer.zero_grad()
-    for _ in range(gradient_accumulation_steps):
-        (
-            latents,
-            encoder_hidden_states,
-            latents_attention_mask,
-            encoder_attention_mask,
-        ) = next(loader)
-        latents = normalize_mochi_dit_input(latents)
-        batch_size = latents.shape[0]
-        noise = torch.randn_like(latents)
-        u = compute_density_for_timestep_sampling(
-            weighting_scheme=weighting_scheme,
-            batch_size=batch_size,
-            generator=noise_random_generator,
-            logit_mean=logit_mean,
-            logit_std=logit_std,
-            mode_scale=mode_scale,
-        )
-        indices = (u * noise_scheduler.config.num_train_timesteps).long()
-        timesteps = noise_scheduler.timesteps[indices].to(device=latents.device)
-        if sp_size > 1:
-            # Make sure that the timesteps are the same across all sp processes.
-            broadcast(timesteps)
-        sigmas = get_sigmas(
-            noise_scheduler,
-            latents.device,
-            timesteps,
-            n_dim=latents.ndim,
-            dtype=latents.dtype,
-        )
-        noisy_model_input = (1.0 - sigmas) * latents + sigmas * noise
-        # if rank<=0:
-        #     print("2222222222222222222222222222222222222222222222")
-        # print(type(latents_attention_mask))
-        # print(latents_attention_mask)
-        with torch.autocast("cuda", torch.bfloat16):
-            model_pred = transformer(
-                noisy_model_input,
-                encoder_hidden_states,
-                timesteps,
-                encoder_attention_mask,  # B, L
-                return_dict=False,
-            )[0]
-        # if rank<=0:
-        #     print("333333333333333333333333333333333333333333333333")
-        if precondition_outputs:
-            model_pred = noisy_model_input - model_pred * sigmas
-        if precondition_outputs:
-            target = latents
-        else:
-            target = noise - latents
-
-        loss = (
-            torch.mean((model_pred.float() - target.float()) ** 2)
-            / gradient_accumulation_steps
-        )
-
-        loss.backward()
-
-        avg_loss = loss.detach().clone()
-        dist.all_reduce(avg_loss, op=dist.ReduceOp.AVG)
-        total_loss += avg_loss.item()
-
-    grad_norm = transformer.clip_grad_norm_(max_grad_norm)
-    optimizer.step()
-    lr_scheduler.step()
-    return total_loss, grad_norm.item()
-
-
-def main(args):
-    torch.backends.cuda.matmul.allow_tf32 = True
-
-    local_rank = int(os.environ["LOCAL_RANK"])
-    rank = int(os.environ["RANK"])
-    world_size = int(os.environ["WORLD_SIZE"])
-    dist.init_process_group("nccl")
-    torch.cuda.set_device(local_rank)
-    device = torch.cuda.current_device()
-    initialize_sequence_parallel_state(args.sp_size)
-
-    # If passed along, set the training seed now. On GPU...
-    if args.seed is not None:
-        # TODO: t within the same seq parallel group should be the same. Noise should be different.
-        set_seed(args.seed + rank)
-    # We use different seeds for the noise generation in each process to ensure that the noise is different in a batch.
-    noise_random_generator = None
-
-    # Handle the repository creation
-    if rank <= 0 and args.output_dir is not None:
-        os.makedirs(args.output_dir, exist_ok=True)
-
-    # For mixed precision training we cast all non-trainable weigths to half-precision
-    # as these weights are only used for inference, keeping weights in full precision is not required.
-
-    # Create model:
-
-    main_print(f"--> loading model from {args.pretrained_model_name_or_path}")
-    # keep the master weight to float32
-    transformer = MochiTransformer3DModel.from_pretrained(
-        args.pretrained_model_name_or_path,
-        subfolder="transformer",
-        torch_dtype=torch.float32
-        if args.master_weight_type == "fp32"
-        else torch.bfloat16,
-    )
-
-    if args.use_lora:
-        transformer.requires_grad_(False)
-        transformer_lora_config = LoraConfig(
-            r=args.lora_rank,
-            lora_alpha=args.lora_alpha,
-            init_lora_weights=True,
-            target_modules=["to_k", "to_q", "to_v", "to_out.0"],
-        )
-        transformer.add_adapter(transformer_lora_config)
-
-    if args.resume_from_lora_checkpoint:
-        lora_state_dict = MochiPipeline.lora_state_dict(
-            args.resume_from_lora_checkpoint
-        )
-        transformer_state_dict = {
-            f'{k.replace("transformer.", "")}': v
-            for k, v in lora_state_dict.items()
-            if k.startswith("transformer.")
-        }
-        transformer_state_dict = convert_unet_state_dict_to_peft(transformer_state_dict)
-        incompatible_keys = set_peft_model_state_dict(
-            transformer, transformer_state_dict, adapter_name="default"
-        )
-        if incompatible_keys is not None:
-            # check only for unexpected keys
-            unexpected_keys = getattr(incompatible_keys, "unexpected_keys", None)
-            if unexpected_keys:
-                main_print(
-                    f"Loading adapter weights from state_dict led to unexpected keys not found in the model: "
-                    f" {unexpected_keys}. "
-                )
-
-    main_print(
-        f"  Total training parameters = {sum(p.numel() for p in transformer.parameters() if p.requires_grad) / 1e6} M"
-    )
-    main_print(
-        f"--> Initializing FSDP with sharding strategy: {args.fsdp_sharding_startegy}"
-    )
-    fsdp_kwargs = get_dit_fsdp_kwargs(
-        args.fsdp_sharding_startegy,
-        args.use_lora,
-        args.use_cpu_offload,
-        args.master_weight_type,
-    )
-
-    if args.use_lora:
-        transformer.config.lora_rank = args.lora_rank
-        transformer.config.lora_alpha = args.lora_alpha
-        transformer.config.lora_target_modules = ["to_k", "to_q", "to_v", "to_out.0"]
-        transformer._no_split_modules = ["MochiTransformerBlock"]
-        fsdp_kwargs["auto_wrap_policy"] = fsdp_kwargs["auto_wrap_policy"](transformer)
-
-    transformer = FSDP(
-        transformer,
-        **fsdp_kwargs,
-    )
-    main_print(f"--> model loaded")
-
-    if args.gradient_checkpointing:
-        apply_fsdp_checkpointing(transformer, args.selective_checkpointing)
-
-    # Set model as trainable.
-    transformer.train()
-
-    noise_scheduler = FlowMatchEulerDiscreteScheduler()
-
-    params_to_optimize = transformer.parameters()
-    params_to_optimize = list(filter(lambda p: p.requires_grad, params_to_optimize))
-
-    optimizer = torch.optim.AdamW(
-        params_to_optimize,
-        lr=args.learning_rate,
-        betas=(0.9, 0.999),
-        weight_decay=args.weight_decay,
-        eps=1e-8,
-    )
-
-    init_steps = 0
-    if args.resume_from_lora_checkpoint:
-        transformer, optimizer, init_steps = resume_lora_optimizer(
-            transformer, args.resume_from_lora_checkpoint, optimizer
-        )
-    main_print(f"optimizer: {optimizer}")
-
-    lr_scheduler = get_scheduler(
-        args.lr_scheduler,
-        optimizer=optimizer,
-        num_warmup_steps=args.lr_warmup_steps,
-        num_training_steps=args.max_train_steps,
-        num_cycles=args.lr_num_cycles,
-        power=args.lr_power,
-        last_epoch=init_steps - 1,
-    )
-
-    train_dataset = LatentDataset(args.data_json_path, args.num_latent_t, args.cfg)
-    sampler = (
-        LengthGroupedSampler(
-            args.train_batch_size,
-            rank=rank,
-            world_size=world_size,
-            lengths=train_dataset.lengths,
-            group_frame=args.group_frame,
-            group_resolution=args.group_resolution,
-        )
-        if (args.group_frame or args.group_resolution)
-        else DistributedSampler(
-            train_dataset, rank=rank, num_replicas=world_size, shuffle=False
-        )
-    )
-
-    train_dataloader = DataLoader(
-        train_dataset,
-        sampler=sampler,
-        collate_fn=latent_collate_function,
-        pin_memory=True,
-        batch_size=args.train_batch_size,
-        num_workers=args.dataloader_num_workers,
-        drop_last=True,
-    )
-
-    num_update_steps_per_epoch = math.ceil(
-        len(train_dataloader)
-        / args.gradient_accumulation_steps
-        * args.sp_size
-        / args.train_sp_batch_size
-    )
-    args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
-
-    if rank <= 0:
-        project = args.tracker_project_name or "fastvideo"
-        wandb.init(project=project, config=args)
-
-    # Train!
-    total_batch_size = (
-        args.train_batch_size
-        * world_size
-        * args.gradient_accumulation_steps
-        / args.sp_size
-        * args.train_sp_batch_size
-    )
-    main_print("***** Running training *****")
-    main_print(f"  Num examples = {len(train_dataset)}")
-    main_print(f"  Dataloader size = {len(train_dataloader)}")
-    main_print(f"  Num Epochs = {args.num_train_epochs}")
-    main_print(f"  Resume training from step {init_steps}")
-    main_print(f"  Instantaneous batch size per device = {args.train_batch_size}")
-    main_print(
-        f"  Total train batch size (w. data & sequence parallel, accumulation) = {total_batch_size}"
-    )
-    main_print(f"  Gradient Accumulation steps = {args.gradient_accumulation_steps}")
-    main_print(f"  Total optimization steps = {args.max_train_steps}")
-    main_print(
-        f"  Total training parameters per FSDP shard = {sum(p.numel() for p in transformer.parameters() if p.requires_grad) / 1e9} B"
-    )
-    # print dtype
-    main_print(f"  Master weight dtype: {transformer.parameters().__next__().dtype}")
-
-    # Potentially load in the weights and states from a previous save
-    if args.resume_from_checkpoint:
-        assert NotImplementedError("resume_from_checkpoint is not supported now.")
-        # TODO
-
-    progress_bar = tqdm(
-        range(0, args.max_train_steps),
-        initial=init_steps,
-        desc="Steps",
-        # Only show the progress bar once on each machine.
-        disable=local_rank > 0,
-    )
-
-    loader = sp_parallel_dataloader_wrapper(
-        train_dataloader,
-        device,
-        args.train_batch_size,
-        args.sp_size,
-        args.train_sp_batch_size,
-    )
-
-    step_times = deque(maxlen=100)
-
-    # todo future
-    for i in range(init_steps):
-        next(loader)
-    for step in range(init_steps + 1, args.max_train_steps + 1):
-        start_time = time.time()
-        loss, grad_norm = train_one_step_mochi(
-            transformer,
-            optimizer,
-            lr_scheduler,
-            loader,
-            noise_scheduler,
-            noise_random_generator,
-            args.gradient_accumulation_steps,
-            args.sp_size,
-            args.precondition_outputs,
-            args.max_grad_norm,
-            args.weighting_scheme,
-            args.logit_mean,
-            args.logit_std,
-            args.mode_scale,
-        )
-
-        step_time = time.time() - start_time
-        step_times.append(step_time)
-        avg_step_time = sum(step_times) / len(step_times)
-
-        progress_bar.set_postfix(
-            {
-                "loss": f"{loss:.4f}",
-                "step_time": f"{step_time:.2f}s",
-                "grad_norm": grad_norm,
-            }
-        )
-        progress_bar.update(1)
-        if rank <= 0:
-            wandb.log(
-                {
-                    "train_loss": loss,
-                    "learning_rate": lr_scheduler.get_last_lr()[0],
-                    "step_time": step_time,
-                    "avg_step_time": avg_step_time,
-                    "grad_norm": grad_norm,
-                },
-                step=step,
-            )
-        if step % args.checkpointing_steps == 0:
-            if args.use_lora:
-                # Save LoRA weights
-                save_lora_checkpoint(
-                    transformer, optimizer, rank, args.output_dir, step
-                )
-            else:
-                # Your existing checkpoint saving code
-                save_checkpoint(transformer, optimizer, rank, args.output_dir, step)
-            dist.barrier()
-        if args.log_validation and step % args.validation_steps == 0:
-            log_validation(args, transformer, device, torch.bfloat16, step)
-
-    if args.use_lora:
-        save_lora_checkpoint(
-            transformer, optimizer, rank, args.output_dir, args.max_train_steps
-        )
-    else:
-        save_checkpoint(
-            transformer, optimizer, rank, args.output_dir, args.max_train_steps
-        )
-
-    if get_sequence_parallel_state():
-        destroy_sequence_parallel_group()
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-
-    # dataset & dataloader
-    parser.add_argument("--data_json_path", type=str, required=True)
-    parser.add_argument("--num_frames", type=int, default=163)
-    parser.add_argument(
-        "--dataloader_num_workers",
-        type=int,
-        default=10,
-        help="Number of subprocesses to use for data loading. 0 means that the data will be loaded in the main process.",
-    )
-    parser.add_argument(
-        "--train_batch_size",
-        type=int,
-        default=16,
-        help="Batch size (per device) for the training dataloader.",
-    )
-    parser.add_argument(
-        "--num_latent_t", type=int, default=28, help="Number of latent timesteps."
-    )
-    parser.add_argument("--group_frame", action="store_true")  # TODO
-    parser.add_argument("--group_resolution", action="store_true")  # TODO
-
-    # text encoder & vae & diffusion model
-    parser.add_argument("--pretrained_model_name_or_path", type=str)
-    parser.add_argument("--cache_dir", type=str, default="./cache_dir")
-
-    # diffusion setting
-    parser.add_argument("--ema_decay", type=float, default=0.999)
-    parser.add_argument("--ema_start_step", type=int, default=0)
-    parser.add_argument("--cfg", type=float, default=0.1)
-    parser.add_argument(
-        "--precondition_outputs",
-        action="store_true",
-        help="Whether to precondition the outputs of the model.",
-    )
-
-    # validation & logs
-    parser.add_argument("--validation_prompt_dir", type=str)
-    parser.add_argument("--uncond_prompt_dir", type=str)
-    parser.add_argument(
-        "--validation_sampling_steps",
-        type=str,
-        default="64",
-        help="use ',' to split multi sampling steps",
-    )
-    parser.add_argument(
-        "--validation_guidance_scale",
-        type=str,
-        default="4.5",
-        help="use ',' to split multi scale",
-    )
-    parser.add_argument("--validation_steps", type=int, default=50)
-    parser.add_argument("--log_validation", action="store_true")
-    parser.add_argument("--tracker_project_name", type=str, default=None)
-    parser.add_argument(
-        "--seed", type=int, default=None, help="A seed for reproducible training."
-    )
-    parser.add_argument(
-        "--output_dir",
-        type=str,
-        default=None,
-        help="The output directory where the model predictions and checkpoints will be written.",
-    )
-    parser.add_argument(
-        "--checkpoints_total_limit",
-        type=int,
-        default=None,
-        help=("Max number of checkpoints to store."),
-    )
-    parser.add_argument(
-        "--checkpointing_steps",
-        type=int,
-        default=500,
-        help=(
-            "Save a checkpoint of the training state every X updates. These checkpoints can be used both as final"
-            " checkpoints in case they are better than the last checkpoint, and are also suitable for resuming"
-            " training using `--resume_from_checkpoint`."
-        ),
-    )
-    parser.add_argument(
-        "--resume_from_checkpoint",
-        type=str,
-        default=None,
-        help=(
-            "Whether training should be resumed from a previous checkpoint. Use a path saved by"
-            ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.'
-        ),
-    )
-    parser.add_argument(
-        "--resume_from_lora_checkpoint",
-        type=str,
-        default=None,
-        help=(
-            "Whether training should be resumed from a previous lora checkpoint. Use a path saved by"
-            ' `--checkpointing_steps`, or `"latest"` to automatically select the last available checkpoint.'
-        ),
-    )
-    parser.add_argument(
-        "--logging_dir",
-        type=str,
-        default="logs",
-        help=(
-            "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to"
-            " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***."
-        ),
-    )
-
-    # optimizer & scheduler & Training
-    parser.add_argument("--num_train_epochs", type=int, default=100)
-    parser.add_argument(
-        "--max_train_steps",
-        type=int,
-        default=None,
-        help="Total number of training steps to perform.  If provided, overrides num_train_epochs.",
-    )
-    parser.add_argument(
-        "--gradient_accumulation_steps",
-        type=int,
-        default=1,
-        help="Number of updates steps to accumulate before performing a backward/update pass.",
-    )
-    parser.add_argument(
-        "--learning_rate",
-        type=float,
-        default=1e-4,
-        help="Initial learning rate (after the potential warmup period) to use.",
-    )
-    parser.add_argument(
-        "--scale_lr",
-        action="store_true",
-        default=False,
-        help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.",
-    )
-    parser.add_argument(
-        "--lr_warmup_steps",
-        type=int,
-        default=10,
-        help="Number of steps for the warmup in the lr scheduler.",
-    )
-    parser.add_argument(
-        "--max_grad_norm", default=1.0, type=float, help="Max gradient norm."
-    )
-    parser.add_argument(
-        "--gradient_checkpointing",
-        action="store_true",
-        help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.",
-    )
-    parser.add_argument("--selective_checkpointing", type=float, default=1.0)
-    parser.add_argument(
-        "--allow_tf32",
-        action="store_true",
-        help=(
-            "Whether or not to allow TF32 on Ampere GPUs. Can be used to speed up training. For more information, see"
-            " https://pytorch.org/docs/stable/notes/cuda.html#tensorfloat-32-tf32-on-ampere-devices"
-        ),
-    )
-    parser.add_argument(
-        "--mixed_precision",
-        type=str,
-        default=None,
-        choices=["no", "fp16", "bf16"],
-        help=(
-            "Whether to use mixed precision. Choose between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >="
-            " 1.10.and an Nvidia Ampere GPU.  Default to the value of accelerate config of the current system or the"
-            " flag passed with the `accelerate.launch` command. Use this argument to override the accelerate config."
-        ),
-    )
-    parser.add_argument(
-        "--use_cpu_offload",
-        action="store_true",
-        help="Whether to use CPU offload for param & gradient & optimizer states.",
-    )
-
-    parser.add_argument("--sp_size", type=int, default=1, help="For sequence parallel")
-    parser.add_argument(
-        "--train_sp_batch_size",
-        type=int,
-        default=1,
-        help="Batch size for sequence parallel training",
-    )
-
-    parser.add_argument(
-        "--use_lora",
-        action="store_true",
-        default=False,
-        help="Whether to use LoRA for finetuning.",
-    )
-    parser.add_argument(
-        "--lora_alpha", type=int, default=256, help="Alpha parameter for LoRA."
-    )
-    parser.add_argument(
-        "--lora_rank", type=int, default=128, help="LoRA rank parameter. "
-    )
-    parser.add_argument("--fsdp_sharding_startegy", default="full")
-
-    parser.add_argument(
-        "--weighting_scheme",
-        type=str,
-        default="uniform",
-        choices=["sigma_sqrt", "logit_normal", "mode", "cosmap", "uniform"],
-    )
-    parser.add_argument(
-        "--logit_mean",
-        type=float,
-        default=0.0,
-        help="mean to use when using the `'logit_normal'` weighting scheme.",
-    )
-    parser.add_argument(
-        "--logit_std",
-        type=float,
-        default=1.0,
-        help="std to use when using the `'logit_normal'` weighting scheme.",
-    )
-    parser.add_argument(
-        "--mode_scale",
-        type=float,
-        default=1.29,
-        help="Scale of mode weighting scheme. Only effective when using the `'mode'` as the `weighting_scheme`.",
-    )
-    # lr_scheduler
-    parser.add_argument(
-        "--lr_scheduler",
-        type=str,
-        default="constant",
-        help=(
-            'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",'
-            ' "constant", "constant_with_warmup"]'
-        ),
-    )
-    parser.add_argument(
-        "--lr_num_cycles",
-        type=int,
-        default=1,
-        help="Number of cycles in the learning rate scheduler.",
-    )
-    parser.add_argument(
-        "--lr_power",
-        type=float,
-        default=1.0,
-        help="Power factor of the polynomial scheduler.",
-    )
-    parser.add_argument(
-        "--weight_decay", type=float, default=0.01, help="Weight decay to apply."
-    )
-    parser.add_argument(
-        "--master_weight_type",
-        type=str,
-        default="fp32",
-        help="Weight type to use - fp32 or bf16.",
-    )
-
-    args = parser.parse_args()
-    main(args)

fastvideo/utils/checkpoint.py

@@ -1,282 +0,0 @@
-# import
-import os
-import json
-import torch
-from fastvideo.utils.logging import main_print
-from torch.distributed.fsdp import (
-    FullyShardedDataParallel as FSDP,
-    StateDictType,
-    FullStateDictConfig,
-)
-from safetensors.torch import save_file, load_file
-import torch.distributed.checkpoint as dist_cp
-from torch.distributed.checkpoint.default_planner import (
-    DefaultSavePlanner,
-    DefaultLoadPlanner,
-)
-from torch.distributed.checkpoint.optimizer import load_sharded_optimizer_state_dict
-from torch.distributed.fsdp import FullOptimStateDictConfig
-from peft import LoraConfig, get_peft_model_state_dict, set_peft_model_state_dict
-from fastvideo.models.mochi_hf.pipeline_mochi import MochiPipeline
-
-
-def save_checkpoint(model, optimizer, rank, output_dir, step, discriminator=False):
-    with FSDP.state_dict_type(
-        model,
-        StateDictType.FULL_STATE_DICT,
-        FullStateDictConfig(offload_to_cpu=True, rank0_only=True),
-        FullOptimStateDictConfig(offload_to_cpu=True, rank0_only=True),
-    ):
-        cpu_state = model.state_dict()
-        optim_state = FSDP.optim_state_dict(
-            model,
-            optimizer,
-        )
-
-    # todo move to get_state_dict
-    save_dir = os.path.join(output_dir, f"checkpoint-{step}")
-    os.makedirs(save_dir, exist_ok=True)
-    # save using safetensors
-    if rank <= 0 and not discriminator:
-        weight_path = os.path.join(save_dir, "diffusion_pytorch_model.safetensors")
-        save_file(cpu_state, weight_path)
-        config_dict = dict(model.config)
-        config_path = os.path.join(save_dir, "config.json")
-        # save dict as json
-        with open(config_path, "w") as f:
-            json.dump(config_dict, f, indent=4)
-        optimizer_path = os.path.join(save_dir, "optimizer.pt")
-        torch.save(optim_state, optimizer_path)
-    else:
-        weight_path = os.path.join(save_dir, "discriminator_pytorch_model.safetensors")
-        save_file(cpu_state, weight_path)
-        optimizer_path = os.path.join(save_dir, "discriminator_optimizer.pt")
-        torch.save(optim_state, optimizer_path)
-
-
-def save_checkpoint_generator_discriminator(
-    model,
-    optimizer,
-    discriminator,
-    discriminator_optimizer,
-    rank,
-    output_dir,
-    step,
-):
-    with FSDP.state_dict_type(
-        model,
-        StateDictType.FULL_STATE_DICT,
-        FullStateDictConfig(offload_to_cpu=True, rank0_only=True),
-    ):
-        cpu_state = model.state_dict()
-
-    # todo move to get_state_dict
-    save_dir = os.path.join(output_dir, f"checkpoint-{step}")
-    os.makedirs(save_dir, exist_ok=True)
-    hf_weight_dir = os.path.join(save_dir, "hf_weights")
-    os.makedirs(hf_weight_dir, exist_ok=True)
-    # save using safetensors
-    if rank <= 0:
-        config_dict = dict(model.config)
-        config_path = os.path.join(hf_weight_dir, "config.json")
-        # save dict as json
-        with open(config_path, "w") as f:
-            json.dump(config_dict, f, indent=4)
-        weight_path = os.path.join(hf_weight_dir, "diffusion_pytorch_model.safetensors")
-        save_file(cpu_state, weight_path)
-
-    main_print(f"--> saved HF weight checkpoint at path {hf_weight_dir}")
-    model_weight_dir = os.path.join(save_dir, "model_weights_state")
-    os.makedirs(model_weight_dir, exist_ok=True)
-    model_optimizer_dir = os.path.join(save_dir, "model_optimizer_state")
-    os.makedirs(model_optimizer_dir, exist_ok=True)
-    with FSDP.state_dict_type(model, StateDictType.SHARDED_STATE_DICT):
-        optim_state = FSDP.optim_state_dict(model, optimizer)
-        model_state = model.state_dict()
-        weight_state_dict = {"model": model_state}
-        dist_cp.save_state_dict(
-            state_dict=weight_state_dict,
-            storage_writer=dist_cp.FileSystemWriter(model_weight_dir),
-            planner=DefaultSavePlanner(),
-        )
-        optimizer_state_dict = {"optimizer": optim_state}
-        dist_cp.save_state_dict(
-            state_dict=optimizer_state_dict,
-            storage_writer=dist_cp.FileSystemWriter(model_optimizer_dir),
-            planner=DefaultSavePlanner(),
-        )
-
-    discriminator_fsdp_state_dir = os.path.join(save_dir, "discriminator_fsdp_state")
-    os.makedirs(discriminator_fsdp_state_dir, exist_ok=True)
-    with FSDP.state_dict_type(
-        discriminator,
-        StateDictType.FULL_STATE_DICT,
-        FullStateDictConfig(offload_to_cpu=True, rank0_only=True),
-        FullOptimStateDictConfig(offload_to_cpu=True, rank0_only=True),
-    ):
-        optim_state = FSDP.optim_state_dict(discriminator, discriminator_optimizer)
-        model_state = discriminator.state_dict()
-        state_dict = {"optimizer": optim_state, "model": model_state}
-        if rank <= 0:
-            discriminator_fsdp_state_fil = os.path.join(
-                discriminator_fsdp_state_dir, "discriminator_state.pt"
-            )
-            torch.save(state_dict, discriminator_fsdp_state_fil)
-
-    main_print("--> saved FSDP state checkpoint")
-
-
-def load_sharded_model(model, optimizer, model_dir, optimizer_dir):
-    with FSDP.state_dict_type(model, StateDictType.SHARDED_STATE_DICT):
-        weight_state_dict = {"model": model.state_dict()}
-
-        optim_state = load_sharded_optimizer_state_dict(
-            model_state_dict=weight_state_dict["model"],
-            optimizer_key="optimizer",
-            storage_reader=dist_cp.FileSystemReader(optimizer_dir),
-        )
-        optim_state = optim_state["optimizer"]
-        flattened_osd = FSDP.optim_state_dict_to_load(
-            model=model, optim=optimizer, optim_state_dict=optim_state
-        )
-        optimizer.load_state_dict(flattened_osd)
-        dist_cp.load_state_dict(
-            state_dict=weight_state_dict,
-            storage_reader=dist_cp.FileSystemReader(model_dir),
-            planner=DefaultLoadPlanner(),
-        )
-        model_state = weight_state_dict["model"]
-        model.load_state_dict(model_state)
-    main_print(f"--> loaded model and optimizer from path {model_dir}")
-    return model, optimizer
-
-
-def load_full_state_model(model, optimizer, checkpoint_file, rank):
-    with FSDP.state_dict_type(
-        model,
-        StateDictType.FULL_STATE_DICT,
-        FullStateDictConfig(offload_to_cpu=True, rank0_only=True),
-        FullOptimStateDictConfig(offload_to_cpu=True, rank0_only=True),
-    ):
-        discriminator_state = torch.load(checkpoint_file)
-        model_state = discriminator_state["model"]
-        if rank <= 0:
-            optim_state = discriminator_state["optimizer"]
-        else:
-            optim_state = None
-        model.load_state_dict(model_state)
-        discriminator_optim_state = FSDP.optim_state_dict_to_load(
-            model=model, optim=optimizer, optim_state_dict=optim_state
-        )
-        optimizer.load_state_dict(discriminator_optim_state)
-    main_print(
-        f"--> loaded discriminator and discriminator optimizer from path {checkpoint_file}"
-    )
-    return model, optimizer
-
-
-def resume_training_generator_discriminator(
-    model, optimizer, discriminator, discriminator_optimizer, checkpoint_dir, rank
-):
-    step = int(checkpoint_dir.split("-")[-1])
-    model_weight_dir = os.path.join(checkpoint_dir, "model_weights_state")
-    model_optimizer_dir = os.path.join(checkpoint_dir, "model_optimizer_state")
-    model, optimizer = load_sharded_model(
-        model, optimizer, model_weight_dir, model_optimizer_dir
-    )
-    discriminator_ckpt_file = os.path.join(
-        checkpoint_dir, "discriminator_fsdp_state", "discriminator_state.pt"
-    )
-    discriminator, discriminator_optimizer = load_full_state_model(
-        discriminator, discriminator_optimizer, discriminator_ckpt_file, rank
-    )
-    return model, optimizer, discriminator, discriminator_optimizer, step
-
-
-def resume_training(model, optimizer, checkpoint_dir, discriminator=False):
-    weight_path = os.path.join(checkpoint_dir, "diffusion_pytorch_model.safetensors")
-    if discriminator:
-        weight_path = os.path.join(
-            checkpoint_dir, "discriminator_pytorch_model.safetensors"
-        )
-    model_weights = load_file(weight_path)
-
-    with FSDP.state_dict_type(
-        model,
-        StateDictType.FULL_STATE_DICT,
-        FullStateDictConfig(offload_to_cpu=True, rank0_only=True),
-        FullOptimStateDictConfig(offload_to_cpu=True, rank0_only=True),
-    ):
-        current_state = model.state_dict()
-        current_state.update(model_weights)
-        model.load_state_dict(current_state, strict=False)
-    if discriminator:
-        optim_path = os.path.join(checkpoint_dir, "discriminator_optimizer.pt")
-    else:
-        optim_path = os.path.join(checkpoint_dir, "optimizer.pt")
-    optimizer_state_dict = torch.load(optim_path, weights_only=False)
-    optim_state = FSDP.optim_state_dict_to_load(
-        model=model, optim=optimizer, optim_state_dict=optimizer_state_dict
-    )
-    optimizer.load_state_dict(optim_state)
-    step = int(checkpoint_dir.split("-")[-1])
-    return model, optimizer, step
-
-
-def save_lora_checkpoint(transformer, optimizer, rank, output_dir, step):
-    with FSDP.state_dict_type(
-        transformer,
-        StateDictType.FULL_STATE_DICT,
-        FullStateDictConfig(offload_to_cpu=True, rank0_only=True),
-    ):
-        full_state_dict = transformer.state_dict()
-        lora_optim_state = FSDP.optim_state_dict(
-            transformer,
-            optimizer,
-        )
-
-    if rank <= 0:
-        save_dir = os.path.join(output_dir, f"lora-checkpoint-{step}")
-        os.makedirs(save_dir, exist_ok=True)
-
-        # save optimizer
-        optim_path = os.path.join(save_dir, "lora_optimizer.pt")
-        torch.save(lora_optim_state, optim_path)
-        # save lora weight
-        main_print(f"--> saving LoRA checkpoint at step {step}")
-        transformer_lora_layers = get_peft_model_state_dict(
-            model=transformer, state_dict=full_state_dict
-        )
-        MochiPipeline.save_lora_weights(
-            save_directory=save_dir,
-            transformer_lora_layers=transformer_lora_layers,
-            is_main_process=True,
-        )
-        # save config
-        lora_config = {
-            "step": step,
-            "lora_params": {
-                "lora_rank": transformer.config.lora_rank,
-                "lora_alpha": transformer.config.lora_alpha,
-                "target_modules": transformer.config.lora_target_modules,
-            },
-        }
-        config_path = os.path.join(save_dir, "lora_config.json")
-        with open(config_path, "w") as f:
-            json.dump(lora_config, f, indent=4)
-    main_print(f"--> LoRA checkpoint saved at step {step}")
-
-
-def resume_lora_optimizer(transformer, checkpoint_dir, optimizer):
-    config_path = os.path.join(checkpoint_dir, "lora_config.json")
-    with open(config_path, "r") as f:
-        config_dict = json.load(f)
-    optim_path = os.path.join(checkpoint_dir, "lora_optimizer.pt")
-    optimizer_state_dict = torch.load(optim_path, weights_only=False)
-    optim_state = FSDP.optim_state_dict_to_load(
-        model=transformer, optim=optimizer, optim_state_dict=optimizer_state_dict
-    )
-    optimizer.load_state_dict(optim_state)
-    step = config_dict["step"]
-    main_print(f"-->  Successfully resuming LoRA optimizer from step {step}")
-    return transformer, optimizer, step

fastvideo/utils/communications.py

@@ -1,334 +0,0 @@
-# Copyright (c) Microsoft Corporation.
-# SPDX-License-Identifier: Apache-2.0
-
-# DeepSpeed Team
-
-import torch
-import torch.distributed as dist
-from fastvideo.utils.parallel_states import nccl_info
-from typing import Any, Tuple
-from torch import Tensor
-from torch.nn import Module
-
-
-def broadcast(input_: torch.Tensor):
-    src = nccl_info.group_id * nccl_info.sp_size
-    dist.broadcast(input_, src=src, group=nccl_info.group)
-
-
-def _all_to_all_4D(
-    input: torch.tensor, scatter_idx: int = 2, gather_idx: int = 1, group=None
-) -> torch.tensor:
-    """
-    all-to-all for QKV
-
-    Args:
-        input (torch.tensor): a tensor sharded along dim scatter dim
-        scatter_idx (int): default 1
-        gather_idx (int): default 2
-        group : torch process group
-
-    Returns:
-        torch.tensor: resharded tensor (bs, seqlen/P, hc, hs)
-    """
-    assert (
-        input.dim() == 4
-    ), f"input must be 4D tensor, got {input.dim()} and shape {input.shape}"
-
-    seq_world_size = dist.get_world_size(group)
-
-    if scatter_idx == 2 and gather_idx == 1:
-        # input (torch.tensor): a tensor sharded along dim 1 (bs, seqlen/P, hc, hs) output: (bs, seqlen, hc/P, hs)
-        bs, shard_seqlen, hc, hs = input.shape
-        seqlen = shard_seqlen * seq_world_size
-        shard_hc = hc // seq_world_size
-
-        # transpose groups of heads with the seq-len parallel dimension, so that we can scatter them!
-        # (bs, seqlen/P, hc, hs) -reshape-> (bs, seq_len/P, P, hc/P, hs) -transpose(0,2)-> (P, seq_len/P, bs, hc/P, hs)
-        input_t = (
-            input.reshape(bs, shard_seqlen, seq_world_size, shard_hc, hs)
-            .transpose(0, 2)
-            .contiguous()
-        )
-
-        output = torch.empty_like(input_t)
-        # https://pytorch.org/docs/stable/distributed.html#torch.distributed.all_to_all_single
-        # (P, seq_len/P, bs, hc/P, hs) scatter seqlen -all2all-> (P, seq_len/P, bs, hc/P, hs) scatter head
-        if seq_world_size > 1:
-            dist.all_to_all_single(output, input_t, group=group)
-            torch.cuda.synchronize()
-        else:
-            output = input_t
-        # if scattering the seq-dim, transpose the heads back to the original dimension
-        output = output.reshape(seqlen, bs, shard_hc, hs)
-
-        # (seq_len, bs, hc/P, hs) -reshape-> (bs, seq_len, hc/P, hs)
-        output = output.transpose(0, 1).contiguous().reshape(bs, seqlen, shard_hc, hs)
-
-        return output
-
-    elif scatter_idx == 1 and gather_idx == 2:
-        # input (torch.tensor): a tensor sharded along dim 1 (bs, seqlen, hc/P, hs) output: (bs, seqlen/P, hc, hs)
-        bs, seqlen, shard_hc, hs = input.shape
-        hc = shard_hc * seq_world_size
-        shard_seqlen = seqlen // seq_world_size
-        seq_world_size = dist.get_world_size(group)
-
-        # transpose groups of heads with the seq-len parallel dimension, so that we can scatter them!
-        # (bs, seqlen, hc/P, hs) -reshape-> (bs, P, seq_len/P, hc/P, hs) -transpose(0, 3)-> (hc/P, P, seqlen/P, bs, hs) -transpose(0, 1) -> (P, hc/P, seqlen/P, bs, hs)
-        input_t = (
-            input.reshape(bs, seq_world_size, shard_seqlen, shard_hc, hs)
-            .transpose(0, 3)
-            .transpose(0, 1)
-            .contiguous()
-            .reshape(seq_world_size, shard_hc, shard_seqlen, bs, hs)
-        )
-
-        output = torch.empty_like(input_t)
-        # https://pytorch.org/docs/stable/distributed.html#torch.distributed.all_to_all_single
-        # (P, bs x hc/P, seqlen/P, hs) scatter seqlen -all2all-> (P, bs x seq_len/P, hc/P, hs) scatter head
-        if seq_world_size > 1:
-            dist.all_to_all_single(output, input_t, group=group)
-            torch.cuda.synchronize()
-        else:
-            output = input_t
-
-        # if scattering the seq-dim, transpose the heads back to the original dimension
-        output = output.reshape(hc, shard_seqlen, bs, hs)
-
-        # (hc, seqlen/N, bs, hs) -tranpose(0,2)-> (bs, seqlen/N, hc, hs)
-        output = output.transpose(0, 2).contiguous().reshape(bs, shard_seqlen, hc, hs)
-
-        return output
-    else:
-        raise RuntimeError("scatter_idx must be 1 or 2 and gather_idx must be 1 or 2")
-
-
-class SeqAllToAll4D(torch.autograd.Function):
-    @staticmethod
-    def forward(
-        ctx: Any,
-        group: dist.ProcessGroup,
-        input: Tensor,
-        scatter_idx: int,
-        gather_idx: int,
-    ) -> Tensor:
-        ctx.group = group
-        ctx.scatter_idx = scatter_idx
-        ctx.gather_idx = gather_idx
-
-        return _all_to_all_4D(input, scatter_idx, gather_idx, group=group)
-
-    @staticmethod
-    def backward(ctx: Any, *grad_output: Tensor) -> Tuple[None, Tensor, None, None]:
-        return (
-            None,
-            SeqAllToAll4D.apply(
-                ctx.group, *grad_output, ctx.gather_idx, ctx.scatter_idx
-            ),
-            None,
-            None,
-        )
-
-
-def all_to_all_4D(
-    input_: torch.Tensor,
-    scatter_dim: int = 2,
-    gather_dim: int = 1,
-):
-    return SeqAllToAll4D.apply(nccl_info.group, input_, scatter_dim, gather_dim)
-
-
-def _all_to_all(
-    input_: torch.Tensor,
-    world_size: int,
-    group: dist.ProcessGroup,
-    scatter_dim: int,
-    gather_dim: int,
-):
-    input_list = [
-        t.contiguous() for t in torch.tensor_split(input_, world_size, scatter_dim)
-    ]
-    output_list = [torch.empty_like(input_list[0]) for _ in range(world_size)]
-    dist.all_to_all(output_list, input_list, group=group)
-    return torch.cat(output_list, dim=gather_dim).contiguous()
-
-
-class _AllToAll(torch.autograd.Function):
-    """All-to-all communication.
-
-    Args:
-        input_: input matrix
-        process_group: communication group
-        scatter_dim: scatter dimension
-        gather_dim: gather dimension
-    """
-
-    @staticmethod
-    def forward(ctx, input_, process_group, scatter_dim, gather_dim):
-        ctx.process_group = process_group
-        ctx.scatter_dim = scatter_dim
-        ctx.gather_dim = gather_dim
-        ctx.world_size = dist.get_world_size(process_group)
-        output = _all_to_all(
-            input_, ctx.world_size, process_group, scatter_dim, gather_dim
-        )
-        return output
-
-    @staticmethod
-    def backward(ctx, grad_output):
-        grad_output = _all_to_all(
-            grad_output,
-            ctx.world_size,
-            ctx.process_group,
-            ctx.gather_dim,
-            ctx.scatter_dim,
-        )
-        return (
-            grad_output,
-            None,
-            None,
-            None,
-        )
-
-
-def all_to_all(
-    input_: torch.Tensor,
-    scatter_dim: int = 2,
-    gather_dim: int = 1,
-):
-    return _AllToAll.apply(input_, nccl_info.group, scatter_dim, gather_dim)
-
-
-class _AllGather(torch.autograd.Function):
-    """All-gather communication with autograd support.
-
-    Args:
-        input_: input tensor
-        dim: dimension along which to concatenate
-    """
-
-    @staticmethod
-    def forward(ctx, input_, dim):
-        ctx.dim = dim
-        world_size = nccl_info.sp_size
-        group = nccl_info.group
-        input_size = list(input_.size())
-
-        ctx.input_size = input_size[dim]
-
-        tensor_list = [torch.empty_like(input_) for _ in range(world_size)]
-        input_ = input_.contiguous()
-        dist.all_gather(tensor_list, input_, group=group)
-
-        output = torch.cat(tensor_list, dim=dim)
-        return output
-
-    @staticmethod
-    def backward(ctx, grad_output):
-        world_size = nccl_info.sp_size
-        rank = nccl_info.rank_within_group
-        dim = ctx.dim
-        input_size = ctx.input_size
-
-        sizes = [input_size] * world_size
-
-        grad_input_list = torch.split(grad_output, sizes, dim=dim)
-        grad_input = grad_input_list[rank]
-
-        return grad_input, None
-
-
-def all_gather(input_: torch.Tensor, dim: int = 1):
-    """Performs an all-gather operation on the input tensor along the specified dimension.
-
-    Args:
-        input_ (torch.Tensor): Input tensor of shape [B, H, S, D].
-        dim (int, optional): Dimension along which to concatenate. Defaults to 1.
-
-    Returns:
-        torch.Tensor: Output tensor after all-gather operation, concatenated along 'dim'.
-    """
-    return _AllGather.apply(input_, dim)
-
-
-def prepare_sequence_parallel_data(
-    hidden_states, encoder_hidden_states, attention_mask, encoder_attention_mask
-):
-    if nccl_info.sp_size == 1:
-        return (
-            hidden_states,
-            encoder_hidden_states,
-            attention_mask,
-            encoder_attention_mask,
-        )
-
-    def prepare(
-        hidden_states, encoder_hidden_states, attention_mask, encoder_attention_mask
-    ):
-        hidden_states = all_to_all(hidden_states, scatter_dim=2, gather_dim=0)
-        encoder_hidden_states = all_to_all(
-            encoder_hidden_states, scatter_dim=1, gather_dim=0
-        )
-        attention_mask = all_to_all(attention_mask, scatter_dim=1, gather_dim=0)
-        encoder_attention_mask = all_to_all(
-            encoder_attention_mask, scatter_dim=1, gather_dim=0
-        )
-        return (
-            hidden_states,
-            encoder_hidden_states,
-            attention_mask,
-            encoder_attention_mask,
-        )
-
-    sp_size = nccl_info.sp_size
-    frame = hidden_states.shape[2]
-    assert frame % sp_size == 0, "frame should be a multiple of sp_size"
-
-    (
-        hidden_states,
-        encoder_hidden_states,
-        attention_mask,
-        encoder_attention_mask,
-    ) = prepare(
-        hidden_states,
-        encoder_hidden_states.repeat(1, sp_size, 1),
-        attention_mask.repeat(1, sp_size, 1, 1),
-        encoder_attention_mask.repeat(1, sp_size),
-    )
-
-    return hidden_states, encoder_hidden_states, attention_mask, encoder_attention_mask
-
-
-def sp_parallel_dataloader_wrapper(
-    dataloader, device, train_batch_size, sp_size, train_sp_batch_size
-):
-    while True:
-        for data_item in dataloader:
-            latents, cond, attn_mask, cond_mask = data_item
-            latents = latents.to(device)
-            cond = cond.to(device)
-            attn_mask = attn_mask.to(device)
-            cond_mask = cond_mask.to(device)
-            frame = latents.shape[2]
-            if frame == 1:
-                yield latents, cond, attn_mask, cond_mask
-            else:
-                latents, cond, attn_mask, cond_mask = prepare_sequence_parallel_data(
-                    latents, cond, attn_mask, cond_mask
-                )
-                assert (
-                    train_batch_size * sp_size >= train_sp_batch_size
-                ), "train_batch_size * sp_size should be greater than train_sp_batch_size"
-                for iter in range(train_batch_size * sp_size // train_sp_batch_size):
-                    st_idx = iter * train_sp_batch_size
-                    ed_idx = (iter + 1) * train_sp_batch_size
-                    encoder_hidden_states = cond[st_idx:ed_idx]
-                    attention_mask = attn_mask[st_idx:ed_idx]
-                    encoder_attention_mask = cond_mask[st_idx:ed_idx]
-                    yield (
-                        latents[st_idx:ed_idx],
-                        encoder_hidden_states,
-                        attention_mask,
-                        encoder_attention_mask,
-                    )

fastvideo/utils/data_preprocess/finetune_data_T5.py

@@ -1,152 +0,0 @@
-import argparse
-import torch
-from accelerate.logging import get_logger
-from fastvideo.models.mochi_hf.pipeline_mochi import MochiPipeline
-from diffusers.utils import export_to_video
-import json
-import os
-import torch.distributed as dist
-
-logger = get_logger(__name__)
-from torch.utils.data import Dataset
-from torch.utils.data.distributed import DistributedSampler
-from torch.utils.data import DataLoader
-
-
-class T5dataset(Dataset):
-    def __init__(
-        self,
-        json_path,
-        vae_debug,
-    ):
-        self.json_path = json_path
-        self.vae_debug = vae_debug
-        with open(self.json_path, "r") as f:
-            train_dataset = json.load(f)
-            self.train_dataset = sorted(train_dataset, key=lambda x: x["latent_path"])
-
-    def __getitem__(self, idx):
-        caption = self.train_dataset[idx]["caption"]
-        filename = self.train_dataset[idx]["latent_path"].split(".")[0]
-        length = self.train_dataset[idx]["length"]
-        if self.vae_debug:
-            latents = torch.load(
-                os.path.join(
-                    args.output_dir, "latent", self.train_dataset[idx]["latent_path"]
-                ),
-                map_location="cpu",
-            )
-        else:
-            latents = []
-
-        return dict(caption=caption, latents=latents, filename=filename, length=length)
-
-    def __len__(self):
-        return len(self.train_dataset)
-
-
-def main(args):
-    local_rank = int(os.getenv("RANK", 0))
-    world_size = int(os.getenv("WORLD_SIZE", 1))
-    print("world_size", world_size, "local rank", local_rank)
-
-    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    torch.cuda.set_device(local_rank)
-    if not dist.is_initialized():
-        dist.init_process_group(
-            backend="nccl", init_method="env://", world_size=world_size, rank=local_rank
-        )
-
-    pipe = MochiPipeline.from_pretrained(args.model_path).to(device)
-    pipe.vae.enable_tiling()
-    os.makedirs(args.output_dir, exist_ok=True)
-    os.makedirs(os.path.join(args.output_dir, "video"), exist_ok=True)
-    os.makedirs(os.path.join(args.output_dir, "latent"), exist_ok=True)
-    os.makedirs(os.path.join(args.output_dir, "prompt_embed"), exist_ok=True)
-    os.makedirs(os.path.join(args.output_dir, "prompt_attention_mask"), exist_ok=True)
-
-    latents_json_path = os.path.join(args.output_dir, "videos2caption_temp.json")
-    train_dataset = T5dataset(latents_json_path, args.vae_debug)
-    sampler = DistributedSampler(
-        train_dataset, rank=local_rank, num_replicas=world_size, shuffle=True
-    )
-    train_dataloader = DataLoader(
-        train_dataset,
-        sampler=sampler,
-        batch_size=args.train_batch_size,
-        num_workers=args.dataloader_num_workers,
-    )
-
-    json_data = []
-    for _, data in enumerate(train_dataloader):
-        with torch.inference_mode():
-            with torch.autocast("cuda", dtype=torch.bfloat16):
-                prompt_embeds, prompt_attention_mask, _, _ = pipe.encode_prompt(
-                    prompt=data["caption"],
-                )
-                if args.vae_debug:
-                    latents = data["latents"]
-                    video = pipe.vae.decode(latents.to(device), return_dict=False)[0]
-                    video = pipe.video_processor.postprocess_video(video)
-                for idx, video_name in enumerate(data["filename"]):
-                    prompt_embed_path = os.path.join(
-                        args.output_dir, "prompt_embed", video_name + ".pt"
-                    )
-                    video_path = os.path.join(
-                        args.output_dir, "video", video_name + ".mp4"
-                    )
-                    prompt_attention_mask_path = os.path.join(
-                        args.output_dir, "prompt_attention_mask", video_name + ".pt"
-                    )
-                    # save latent
-                    torch.save(prompt_embeds[idx], prompt_embed_path)
-                    torch.save(prompt_attention_mask[idx], prompt_attention_mask_path)
-                    print(f"sample {video_name} saved")
-                    if args.vae_debug:
-                        export_to_video(video[idx], video_path, fps=30)
-                    item = {}
-                    item["length"] = int(data["length"][idx])
-                    item["latent_path"] = video_name + ".pt"
-                    item["prompt_embed_path"] = video_name + ".pt"
-                    item["prompt_attention_mask"] = video_name + ".pt"
-                    item["caption"] = data["caption"][idx]
-                    json_data.append(item)
-    dist.barrier()
-    local_data = json_data
-    gathered_data = [None] * world_size
-    dist.all_gather_object(gathered_data, local_data)
-    if local_rank == 0:
-        # os.remove(latents_json_path)
-        all_json_data = [item for sublist in gathered_data for item in sublist]
-        with open(os.path.join(args.output_dir, "videos2caption.json"), "w") as f:
-            json.dump(all_json_data, f, indent=4)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # dataset & dataloader
-    parser.add_argument("--model_path", type=str, default="data/mochi")
-    # text encoder & vae & diffusion model
-    parser.add_argument(
-        "--dataloader_num_workers",
-        type=int,
-        default=1,
-        help="Number of subprocesses to use for data loading. 0 means that the data will be loaded in the main process.",
-    )
-    parser.add_argument(
-        "--train_batch_size",
-        type=int,
-        default=1,
-        help="Batch size (per device) for the training dataloader.",
-    )
-    parser.add_argument("--text_encoder_name", type=str, default="google/t5-v1_1-xxl")
-    parser.add_argument("--cache_dir", type=str, default="./cache_dir")
-    parser.add_argument(
-        "--output_dir",
-        type=str,
-        default=None,
-        help="The output directory where the model predictions and checkpoints will be written.",
-    )
-    parser.add_argument("--vae_debug", action="store_true")
-    args = parser.parse_args()
-    main(args)

fastvideo/utils/data_preprocess/finetune_data_VAE.py

@@ -1,143 +0,0 @@
-from fastvideo.dataset import getdataset
-from torch.utils.data import DataLoader
-from fastvideo.utils.dataset_utils import Collate
-import argparse
-import torch
-from accelerate import Accelerator
-from accelerate.logging import get_logger
-from accelerate.utils import ProjectConfiguration
-import json
-import os
-from diffusers import AutoencoderKLMochi
-import torch.distributed as dist
-from torch.utils.data.distributed import DistributedSampler
-
-logger = get_logger(__name__)
-
-
-def main(args):
-    local_rank = int(os.getenv("RANK", 0))
-    world_size = int(os.getenv("WORLD_SIZE", 1))
-    print("world_size", world_size, "local rank", local_rank)
-    args.ae_stride_t, args.ae_stride_h, args.ae_stride_w = 4, 8, 8
-    args.ae_stride = args.ae_stride_h
-    patch_size_t, patch_size_h, patch_size_w = 1, 2, 2
-    args.patch_size = patch_size_h
-    args.patch_size_t, args.patch_size_h, args.patch_size_w = (
-        patch_size_t,
-        patch_size_h,
-        patch_size_w,
-    )
-    accelerator_project_config = ProjectConfiguration(
-        project_dir=args.output_dir, logging_dir=args.logging_dir
-    )
-    accelerator = Accelerator(
-        project_config=accelerator_project_config,
-    )
-    train_dataset = getdataset(args)
-    sampler = DistributedSampler(
-        train_dataset, rank=local_rank, num_replicas=world_size, shuffle=True
-    )
-    train_dataloader = DataLoader(
-        train_dataset,
-        sampler=sampler,
-        batch_size=args.train_batch_size,
-        num_workers=args.dataloader_num_workers,
-    )
-
-    encoder_device = torch.device(f"cuda" if torch.cuda.is_available() else "cpu")
-    torch.cuda.set_device(local_rank)
-    if not dist.is_initialized():
-        dist.init_process_group(
-            backend="nccl", init_method="env://", world_size=world_size, rank=local_rank
-        )
-    vae = AutoencoderKLMochi.from_pretrained(args.model_path, subfolder="vae").to(
-        "cuda"
-    )
-    vae.enable_tiling()
-    os.makedirs(args.output_dir, exist_ok=True)
-    os.makedirs(os.path.join(args.output_dir, "latent"), exist_ok=True)
-
-    json_data = []
-    for _, data in enumerate(train_dataloader):
-        with torch.inference_mode():
-            with torch.autocast("cuda", dtype=torch.bfloat16):
-                latents = vae.encode(data["pixel_values"].to(encoder_device))[
-                    "latent_dist"
-                ].sample()
-                for idx, video_path in enumerate(data["path"]):
-                    video_name = os.path.basename(video_path).split(".")[0]
-                    latent_path = os.path.join(
-                        args.output_dir, "latent", video_name + ".pt"
-                    )
-                    torch.save(latents[idx].to(torch.bfloat16), latent_path)
-                    item = {}
-                    item["length"] = latents[idx].shape[1]
-                    item["latent_path"] = video_name + ".pt"
-                    item["caption"] = data["text"][idx]
-                    json_data.append(item)
-                    print(f"{video_name} processed")
-    dist.barrier()
-    local_data = json_data
-    gathered_data = [None] * world_size
-    dist.all_gather_object(gathered_data, local_data)
-    if local_rank == 0:
-        all_json_data = [item for sublist in gathered_data for item in sublist]
-        with open(os.path.join(args.output_dir, "videos2caption_temp.json"), "w") as f:
-            json.dump(all_json_data, f, indent=4)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    # dataset & dataloader
-    parser.add_argument("--model_path", type=str, default="data/mochi")
-    parser.add_argument("--data_merge_path", type=str, required=True)
-    parser.add_argument("--num_frames", type=int, default=163)
-    parser.add_argument(
-        "--dataloader_num_workers",
-        type=int,
-        default=1,
-        help="Number of subprocesses to use for data loading. 0 means that the data will be loaded in the main process.",
-    )
-    parser.add_argument(
-        "--train_batch_size",
-        type=int,
-        default=16,
-        help="Batch size (per device) for the training dataloader.",
-    )
-    parser.add_argument(
-        "--num_latent_t", type=int, default=28, help="Number of latent timesteps."
-    )
-    parser.add_argument("--max_height", type=int, default=480)
-    parser.add_argument("--max_width", type=int, default=848)
-    parser.add_argument("--video_length_tolerance_range", type=int, default=2.0)
-    parser.add_argument("--group_frame", action="store_true")  # TODO
-    parser.add_argument("--group_resolution", action="store_true")  # TODO
-    parser.add_argument("--dataset", default="t2v")
-    parser.add_argument("--train_fps", type=int, default=30)
-    parser.add_argument("--use_image_num", type=int, default=0)
-    parser.add_argument("--text_max_length", type=int, default=256)
-    parser.add_argument("--speed_factor", type=float, default=1.0)
-    parser.add_argument("--drop_short_ratio", type=float, default=1.0)
-    # text encoder & vae & diffusion model
-    parser.add_argument("--text_encoder_name", type=str, default="google/t5-v1_1-xxl")
-    parser.add_argument("--cache_dir", type=str, default="./cache_dir")
-    parser.add_argument("--cfg", type=float, default=0.0)
-    parser.add_argument(
-        "--output_dir",
-        type=str,
-        default=None,
-        help="The output directory where the model predictions and checkpoints will be written.",
-    )
-    parser.add_argument(
-        "--logging_dir",
-        type=str,
-        default="logs",
-        help=(
-            "[TensorBoard](https://www.tensorflow.org/tensorboard) log directory. Will default to"
-            " *output_dir/runs/**CURRENT_DATETIME_HOSTNAME***."
-        ),
-    )
-
-    args = parser.parse_args()
-    main(args)

fastvideo/utils/dataset_utils.py

@@ -1,377 +0,0 @@
-import math
-from einops import rearrange
-import decord
-from torch.nn import functional as F
-import torch
-from typing import Optional
-import torch.utils
-import torch.utils.data
-import torch
-from torch.utils.data import Sampler
-from typing import List
-from collections import Counter
-import random
-
-
-IMG_EXTENSIONS = [".jpg", ".JPG", ".jpeg", ".JPEG", ".png", ".PNG"]
-
-
-def is_image_file(filename):
-    return any(filename.endswith(extension) for extension in IMG_EXTENSIONS)
-
-
-class DecordInit(object):
-    """Using Decord(https://github.com/dmlc/decord) to initialize the video_reader."""
-
-    def __init__(self, num_threads=1):
-        self.num_threads = num_threads
-        self.ctx = decord.cpu(0)
-
-    def __call__(self, filename):
-        """Perform the Decord initialization.
-        Args:
-            results (dict): The resulting dict to be modified and passed
-                to the next transform in pipeline.
-        """
-        reader = decord.VideoReader(
-            filename, ctx=self.ctx, num_threads=self.num_threads
-        )
-        return reader
-
-    def __repr__(self):
-        repr_str = (
-            f"{self.__class__.__name__}("
-            f"sr={self.sr},"
-            f"num_threads={self.num_threads})"
-        )
-        return repr_str
-
-
-def pad_to_multiple(number, ds_stride):
-    remainder = number % ds_stride
-    if remainder == 0:
-        return number
-    else:
-        padding = ds_stride - remainder
-        return number + padding
-
-
-class Collate:
-    def __init__(self, args):
-        self.batch_size = args.train_batch_size
-        self.group_frame = args.group_frame
-        self.group_resolution = args.group_resolution
-
-        self.max_height = args.max_height
-        self.max_width = args.max_width
-        self.ae_stride = args.ae_stride
-
-        self.ae_stride_t = args.ae_stride_t
-        self.ae_stride_thw = (self.ae_stride_t, self.ae_stride, self.ae_stride)
-
-        self.patch_size = args.patch_size
-        self.patch_size_t = args.patch_size_t
-
-        self.num_frames = args.num_frames
-        self.use_image_num = args.use_image_num
-        self.max_thw = (self.num_frames, self.max_height, self.max_width)
-
-    def package(self, batch):
-        batch_tubes = [i["pixel_values"] for i in batch]  # b [c t h w]
-        input_ids = [i["input_ids"] for i in batch]  # b [1 l]
-        cond_mask = [i["cond_mask"] for i in batch]  # b [1 l]
-        return batch_tubes, input_ids, cond_mask
-
-    def __call__(self, batch):
-        batch_tubes, input_ids, cond_mask = self.package(batch)
-
-        ds_stride = self.ae_stride * self.patch_size
-        t_ds_stride = self.ae_stride_t * self.patch_size_t
-
-        pad_batch_tubes, attention_mask, input_ids, cond_mask = self.process(
-            batch_tubes,
-            input_ids,
-            cond_mask,
-            t_ds_stride,
-            ds_stride,
-            self.max_thw,
-            self.ae_stride_thw,
-        )
-        assert not torch.any(torch.isnan(pad_batch_tubes)), "after pad_batch_tubes"
-        return pad_batch_tubes, attention_mask, input_ids, cond_mask
-
-    def process(
-        self,
-        batch_tubes,
-        input_ids,
-        cond_mask,
-        t_ds_stride,
-        ds_stride,
-        max_thw,
-        ae_stride_thw,
-    ):
-        # pad to max multiple of ds_stride
-        batch_input_size = [i.shape for i in batch_tubes]  # [(c t h w), (c t h w)]
-        assert len(batch_input_size) == self.batch_size
-        if self.group_frame or self.group_resolution or self.batch_size == 1:  #
-            len_each_batch = batch_input_size
-            idx_length_dict = dict([*zip(list(range(self.batch_size)), len_each_batch)])
-            count_dict = Counter(len_each_batch)
-            if len(count_dict) != 1:
-                sorted_by_value = sorted(count_dict.items(), key=lambda item: item[1])
-                pick_length = sorted_by_value[-1][0]  # the highest frequency
-                candidate_batch = [
-                    idx
-                    for idx, length in idx_length_dict.items()
-                    if length == pick_length
-                ]
-                random_select_batch = [
-                    random.choice(candidate_batch)
-                    for _ in range(len(len_each_batch) - len(candidate_batch))
-                ]
-                print(
-                    batch_input_size,
-                    idx_length_dict,
-                    count_dict,
-                    sorted_by_value,
-                    pick_length,
-                    candidate_batch,
-                    random_select_batch,
-                )
-                pick_idx = candidate_batch + random_select_batch
-
-                batch_tubes = [batch_tubes[i] for i in pick_idx]
-                batch_input_size = [
-                    i.shape for i in batch_tubes
-                ]  # [(c t h w), (c t h w)]
-                input_ids = [input_ids[i] for i in pick_idx]  # b [1, l]
-                cond_mask = [cond_mask[i] for i in pick_idx]  # b [1, l]
-
-            for i in range(1, self.batch_size):
-                assert batch_input_size[0] == batch_input_size[i]
-            max_t = max([i[1] for i in batch_input_size])
-            max_h = max([i[2] for i in batch_input_size])
-            max_w = max([i[3] for i in batch_input_size])
-        else:
-            max_t, max_h, max_w = max_thw
-        pad_max_t, pad_max_h, pad_max_w = (
-            pad_to_multiple(max_t - 1 + self.ae_stride_t, t_ds_stride),
-            pad_to_multiple(max_h, ds_stride),
-            pad_to_multiple(max_w, ds_stride),
-        )
-        pad_max_t = pad_max_t + 1 - self.ae_stride_t
-        each_pad_t_h_w = [
-            [pad_max_t - i.shape[1], pad_max_h - i.shape[2], pad_max_w - i.shape[3]]
-            for i in batch_tubes
-        ]
-        pad_batch_tubes = [
-            F.pad(im, (0, pad_w, 0, pad_h, 0, pad_t), value=0)
-            for (pad_t, pad_h, pad_w), im in zip(each_pad_t_h_w, batch_tubes)
-        ]
-        pad_batch_tubes = torch.stack(pad_batch_tubes, dim=0)
-
-        max_tube_size = [pad_max_t, pad_max_h, pad_max_w]
-        max_latent_size = [
-            ((max_tube_size[0] - 1) // ae_stride_thw[0] + 1),
-            max_tube_size[1] // ae_stride_thw[1],
-            max_tube_size[2] // ae_stride_thw[2],
-        ]
-        valid_latent_size = [
-            [
-                int(math.ceil((i[1] - 1) / ae_stride_thw[0])) + 1,
-                int(math.ceil(i[2] / ae_stride_thw[1])),
-                int(math.ceil(i[3] / ae_stride_thw[2])),
-            ]
-            for i in batch_input_size
-        ]
-        attention_mask = [
-            F.pad(
-                torch.ones(i, dtype=pad_batch_tubes.dtype),
-                (
-                    0,
-                    max_latent_size[2] - i[2],
-                    0,
-                    max_latent_size[1] - i[1],
-                    0,
-                    max_latent_size[0] - i[0],
-                ),
-                value=0,
-            )
-            for i in valid_latent_size
-        ]
-        attention_mask = torch.stack(attention_mask)  # b t h w
-        if self.batch_size == 1 or self.group_frame or self.group_resolution:
-            assert torch.all(attention_mask.bool())
-
-        input_ids = torch.stack(input_ids)  # b 1 l
-        cond_mask = torch.stack(cond_mask)  # b 1 l
-
-        return pad_batch_tubes, attention_mask, input_ids, cond_mask
-
-
-def split_to_even_chunks(indices, lengths, num_chunks, batch_size):
-    """
-    Split a list of indices into `chunks` chunks of roughly equal lengths.
-    """
-
-    if len(indices) % num_chunks != 0:
-        chunks = [indices[i::num_chunks] for i in range(num_chunks)]
-    else:
-        num_indices_per_chunk = len(indices) // num_chunks
-
-        chunks = [[] for _ in range(num_chunks)]
-        chunks_lengths = [0 for _ in range(num_chunks)]
-        for index in indices:
-            shortest_chunk = chunks_lengths.index(min(chunks_lengths))
-            chunks[shortest_chunk].append(index)
-            chunks_lengths[shortest_chunk] += lengths[index]
-            if len(chunks[shortest_chunk]) == num_indices_per_chunk:
-                chunks_lengths[shortest_chunk] = float("inf")
-    # return chunks
-
-    pad_chunks = []
-    for idx, chunk in enumerate(chunks):
-        if batch_size != len(chunk):
-            assert batch_size > len(chunk)
-            if len(chunk) != 0:
-                chunk = chunk + [
-                    random.choice(chunk) for _ in range(batch_size - len(chunk))
-                ]
-            else:
-                chunk = random.choice(pad_chunks)
-                print(chunks[idx], "->", chunk)
-        pad_chunks.append(chunk)
-    return pad_chunks
-
-
-def group_frame_fun(indices, lengths):
-    # sort by num_frames
-    indices.sort(key=lambda i: lengths[i], reverse=True)
-    return indices
-
-
-def megabatch_frame_alignment(megabatches, lengths):
-    aligned_magabatches = []
-    for _, megabatch in enumerate(megabatches):
-        assert len(megabatch) != 0
-        len_each_megabatch = [lengths[i] for i in megabatch]
-        idx_length_dict = dict([*zip(megabatch, len_each_megabatch)])
-        count_dict = Counter(len_each_megabatch)
-
-        # mixed frame length, align megabatch inside
-        if len(count_dict) != 1:
-            sorted_by_value = sorted(count_dict.items(), key=lambda item: item[1])
-            pick_length = sorted_by_value[-1][0]  # the highest frequency
-            candidate_batch = [
-                idx for idx, length in idx_length_dict.items() if length == pick_length
-            ]
-            random_select_batch = [
-                random.choice(candidate_batch)
-                for i in range(len(idx_length_dict) - len(candidate_batch))
-            ]
-            aligned_magabatch = candidate_batch + random_select_batch
-            aligned_magabatches.append(aligned_magabatch)
-        # already aligned megabatches
-        else:
-            aligned_magabatches.append(megabatch)
-
-    return aligned_magabatches
-
-
-def get_length_grouped_indices(
-    lengths,
-    batch_size,
-    world_size,
-    generator=None,
-    group_frame=False,
-    group_resolution=False,
-    seed=42,
-):
-    # We need to use torch for the random part as a distributed sampler will set the random seed for torch.
-    if generator is None:
-        generator = torch.Generator().manual_seed(
-            seed
-        )  # every rank will generate a fixed order but random index
-
-    indices = torch.randperm(len(lengths), generator=generator).tolist()
-
-    # sort dataset according to frame
-    indices = group_frame_fun(indices, lengths)
-
-    # chunk dataset to megabatches
-    megabatch_size = world_size * batch_size
-    megabatches = [
-        indices[i : i + megabatch_size] for i in range(0, len(lengths), megabatch_size)
-    ]
-
-    # make sure the length in each magabatch is align with each other
-    megabatches = megabatch_frame_alignment(megabatches, lengths)
-
-    # aplit aligned megabatch into batches
-    megabatches = [
-        split_to_even_chunks(megabatch, lengths, world_size, batch_size)
-        for megabatch in megabatches
-    ]
-
-    # random megabatches to do video-image mix training
-    indices = torch.randperm(len(megabatches), generator=generator).tolist()
-    shuffled_megabatches = [megabatches[i] for i in indices]
-
-    # expand indices and return
-    return [
-        i for megabatch in shuffled_megabatches for batch in megabatch for i in batch
-    ]
-
-
-class LengthGroupedSampler(Sampler):
-    r"""
-    Sampler that samples indices in a way that groups together features of the dataset of roughly the same length while
-    keeping a bit of randomness.
-    """
-
-    def __init__(
-        self,
-        batch_size: int,
-        rank: int,
-        world_size: int,
-        lengths: Optional[List[int]] = None,
-        group_frame=False,
-        group_resolution=False,
-        generator=None,
-    ):
-        if lengths is None:
-            raise ValueError("Lengths must be provided.")
-
-        self.batch_size = batch_size
-        self.rank = rank
-        self.world_size = world_size
-        self.lengths = lengths
-        self.group_frame = group_frame
-        self.group_resolution = group_resolution
-        self.generator = generator
-
-    def __len__(self):
-        return len(self.lengths)
-
-    def __iter__(self):
-        indices = get_length_grouped_indices(
-            self.lengths,
-            self.batch_size,
-            self.world_size,
-            group_frame=self.group_frame,
-            group_resolution=self.group_resolution,
-            generator=self.generator,
-        )
-
-        def distributed_sampler(lst, rank, batch_size, world_size):
-            result = []
-            index = rank * batch_size
-            while index < len(lst):
-                result.extend(lst[index : index + batch_size])
-                index += batch_size * world_size
-            return result
-
-        indices = distributed_sampler(
-            indices, self.rank, self.batch_size, self.world_size
-        )
-        return iter(indices)

fastvideo/utils/logging.py

@@ -1,24 +0,0 @@
-import sys
-import pdb
-import os
-
-
-def main_print(content):
-    if int(os.environ["LOCAL_RANK"]) <= 0:
-        print(content)
-
-
-# ForkedPdb().set_trace()
-class ForkedPdb(pdb.Pdb):
-    """A Pdb subclass that may be used
-    from a forked multiprocessing child
-
-    """
-
-    def interaction(self, *args, **kwargs):
-        _stdin = sys.stdin
-        try:
-            sys.stdin = open("/dev/stdin")
-            pdb.Pdb.interaction(self, *args, **kwargs)
-        finally:
-            sys.stdin = _stdin

fastvideo/utils/optimizer.py

@@ -1,77 +0,0 @@
-from accelerate.logging import get_logger
-import torch
-
-logger = get_logger(__name__)
-
-
-def get_optimizer(args, params_to_optimize, use_deepspeed: bool = False):
-    # Optimizer creation
-    supported_optimizers = ["adam", "adamw", "prodigy"]
-    if args.optimizer not in supported_optimizers:
-        logger.warning(
-            f"Unsupported choice of optimizer: {args.optimizer}. Supported optimizers include {supported_optimizers}. Defaulting to AdamW"
-        )
-        args.optimizer = "adamw"
-
-    if args.use_8bit_adam and not (args.optimizer.lower() not in ["adam", "adamw"]):
-        logger.warning(
-            f"use_8bit_adam is ignored when optimizer is not set to 'Adam' or 'AdamW'. Optimizer was "
-            f"set to {args.optimizer.lower()}"
-        )
-
-    if args.use_8bit_adam:
-        try:
-            import bitsandbytes as bnb
-        except ImportError:
-            raise ImportError(
-                "To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`."
-            )
-
-    if args.optimizer.lower() == "adamw":
-        optimizer_class = (
-            bnb.optim.AdamW8bit if args.use_8bit_adam else torch.optim.AdamW
-        )
-
-        optimizer = optimizer_class(
-            params_to_optimize,
-            betas=(args.adam_beta1, args.adam_beta2),
-            eps=args.adam_epsilon,
-            weight_decay=args.adam_weight_decay,
-        )
-    elif args.optimizer.lower() == "adam":
-        optimizer_class = bnb.optim.Adam8bit if args.use_8bit_adam else torch.optim.Adam
-
-        optimizer = optimizer_class(
-            params_to_optimize,
-            betas=(args.adam_beta1, args.adam_beta2),
-            eps=args.adam_epsilon,
-            weight_decay=args.adam_weight_decay,
-        )
-    elif args.optimizer.lower() == "prodigy":
-        try:
-            import prodigyopt
-        except ImportError:
-            raise ImportError(
-                "To use Prodigy, please install the prodigyopt library: `pip install prodigyopt`"
-            )
-
-        optimizer_class = prodigyopt.Prodigy
-
-        if args.learning_rate <= 0.1:
-            logger.warning(
-                "Learning rate is too low. When using prodigy, it's generally better to set learning rate around 1.0"
-            )
-
-        optimizer = optimizer_class(
-            params_to_optimize,
-            lr=args.learning_rate,
-            betas=(args.adam_beta1, args.adam_beta2),
-            beta3=args.prodigy_beta3,
-            weight_decay=args.adam_weight_decay,
-            eps=args.adam_epsilon,
-            decouple=args.prodigy_decouple,
-            use_bias_correction=args.prodigy_use_bias_correction,
-            safeguard_warmup=args.prodigy_safeguard_warmup,
-        )
-
-    return optimizer

fastvideo/utils/parallel_states.py

@@ -1,63 +0,0 @@
-import torch
-import torch.distributed as dist
-import os
-
-
-class COMM_INFO:
-    def __init__(self):
-        self.group = None
-        self.sp_size = 1
-        self.global_rank = 0
-        self.rank_within_group = 0
-        self.group_id = 0
-
-
-nccl_info = COMM_INFO()
-_SEQUENCE_PARALLEL_STATE = False
-
-
-def initialize_sequence_parallel_state(sequence_parallel_size):
-    global _SEQUENCE_PARALLEL_STATE
-    if sequence_parallel_size > 1:
-        _SEQUENCE_PARALLEL_STATE = True
-        initialize_sequence_parallel_group(sequence_parallel_size)
-    else:
-        nccl_info.sp_size = 1
-        nccl_info.global_rank = int(os.getenv("RANK", "0"))
-        nccl_info.rank_within_group = 0
-        nccl_info.group_id = int(os.getenv("RANK", "0"))
-
-
-def set_sequence_parallel_state(state):
-    global _SEQUENCE_PARALLEL_STATE
-    _SEQUENCE_PARALLEL_STATE = state
-
-
-def get_sequence_parallel_state():
-    return _SEQUENCE_PARALLEL_STATE
-
-
-def initialize_sequence_parallel_group(sequence_parallel_size):
-    """Initialize the sequence parallel group."""
-    rank = int(os.getenv("RANK", "0"))
-    world_size = int(os.getenv("WORLD_SIZE", "1"))
-    assert (
-        world_size % sequence_parallel_size == 0
-    ), "world_size must be divisible by sequence_parallel_size, but got world_size: {}, sequence_parallel_size: {}".format(
-        world_size, sequence_parallel_size
-    )
-    nccl_info.sp_size = sequence_parallel_size
-    nccl_info.global_rank = rank
-    num_sequence_parallel_groups: int = world_size // sequence_parallel_size
-    for i in range(num_sequence_parallel_groups):
-        ranks = range(i * sequence_parallel_size, (i + 1) * sequence_parallel_size)
-        group = dist.new_group(ranks)
-        if rank in ranks:
-            nccl_info.group = group
-            nccl_info.rank_within_group = rank - i * sequence_parallel_size
-            nccl_info.group_id = i
-
-
-def destroy_sequence_parallel_group():
-    """Destroy the sequence parallel group."""
-    dist.destroy_process_group()

fastvideo/utils/validation.py

@@ -1,341 +0,0 @@
-from typing import Optional, Union, List
-import numpy as np
-import torch
-from einops import rearrange
-from fastvideo.utils.parallel_states import get_sequence_parallel_state, nccl_info
-from fastvideo.utils.communications import all_gather
-from diffusers.utils.torch_utils import randn_tensor
-from fastvideo.models.mochi_hf.pipeline_mochi import (
-    linear_quadratic_schedule,
-    retrieve_timesteps,
-)
-from tqdm import tqdm
-from diffusers.video_processor import VideoProcessor
-from diffusers import (
-    FlowMatchEulerDiscreteScheduler,
-    AutoencoderKLMochi,
-)
-from fastvideo.utils.logging import main_print
-from fastvideo.distill.solver import PCMFMScheduler
-from diffusers.utils import export_to_video
-import os
-import wandb
-import gc
-
-
-def prepare_latents(
-    batch_size,
-    num_channels_latents,
-    height,
-    width,
-    num_frames,
-    dtype,
-    device,
-    generator,
-    vae_spatial_scale_factor,
-    vae_temporal_scale_factor,
-):
-    height = height // vae_spatial_scale_factor
-    width = width // vae_spatial_scale_factor
-    num_frames = (num_frames - 1) // vae_temporal_scale_factor + 1
-
-    shape = (batch_size, num_channels_latents, num_frames, height, width)
-
-    latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
-    return latents
-
-
-def sample_validation_video(
-    transformer,
-    vae,
-    scheduler,
-    scheduler_type="euler",
-    height: Optional[int] = None,
-    width: Optional[int] = None,
-    num_frames: int = 16,
-    num_inference_steps: int = 28,
-    timesteps: List[int] = None,
-    guidance_scale: float = 4.5,
-    num_videos_per_prompt: Optional[int] = 1,
-    generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
-    prompt_embeds: Optional[torch.Tensor] = None,
-    prompt_attention_mask: Optional[torch.Tensor] = None,
-    negative_prompt_embeds: Optional[torch.Tensor] = None,
-    negative_prompt_attention_mask: Optional[torch.Tensor] = None,
-    output_type: Optional[str] = "pil",
-    vae_spatial_scale_factor=8,
-    vae_temporal_scale_factor=6,
-):
-    device = vae.device
-
-    batch_size = prompt_embeds.shape[0]
-
-    do_classifier_free_guidance = guidance_scale > 1.0
-    if do_classifier_free_guidance:
-        prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds], dim=0)
-        prompt_attention_mask = torch.cat(
-            [negative_prompt_attention_mask, prompt_attention_mask], dim=0
-        )
-
-    # 4. Prepare latent variables
-    # TODO: Remove hardcore
-    num_channels_latents = 12
-    latents = prepare_latents(
-        batch_size * num_videos_per_prompt,
-        num_channels_latents,
-        height,
-        width,
-        num_frames,
-        prompt_embeds.dtype,
-        device,
-        generator,
-        vae_spatial_scale_factor,
-        vae_temporal_scale_factor,
-    )
-    world_size, rank = nccl_info.sp_size, nccl_info.rank_within_group
-    if get_sequence_parallel_state():
-        latents = rearrange(
-            latents, "b t (n s) h w -> b t n s h w", n=world_size
-        ).contiguous()
-        latents = latents[:, :, rank, :, :, :]
-
-    # 5. Prepare timestep
-    # from https://github.com/genmoai/models/blob/075b6e36db58f1242921deff83a1066887b9c9e1/src/mochi_preview/infer.py#L77
-    threshold_noise = 0.025
-    sigmas = linear_quadratic_schedule(num_inference_steps, threshold_noise)
-    sigmas = np.array(sigmas)
-    if scheduler_type == "euler":
-        timesteps, num_inference_steps = retrieve_timesteps(
-            scheduler,
-            num_inference_steps,
-            device,
-            timesteps,
-            sigmas,
-        )
-    else:
-        timesteps, num_inference_steps = retrieve_timesteps(
-            scheduler,
-            num_inference_steps,
-            device,
-        )
-    num_warmup_steps = max(len(timesteps) - num_inference_steps * scheduler.order, 0)
-
-    # 6. Denoising loop
-    # with self.progress_bar(total=num_inference_steps) as progress_bar:
-    # write with tqdm instead
-    # only enable if nccl_info.global_rank == 0
-
-    with tqdm(
-        total=num_inference_steps,
-        disable=nccl_info.rank_within_group != 0,
-        desc="Validation sampling...",
-    ) as progress_bar:
-        for i, t in enumerate(timesteps):
-            latent_model_input = (
-                torch.cat([latents] * 2) if do_classifier_free_guidance else latents
-            )
-            # broadcast to batch dimension in a way that's compatible with ONNX/Core ML
-            timestep = t.expand(latent_model_input.shape[0]).to(latents.dtype)
-            noise_pred = transformer(
-                hidden_states=latent_model_input,
-                encoder_hidden_states=prompt_embeds,
-                timestep=timestep,
-                encoder_attention_mask=prompt_attention_mask,
-                return_dict=False,
-            )[0]
-
-            # Mochi CFG + Sampling runs in FP32
-            noise_pred = noise_pred.to(torch.float32)
-            if do_classifier_free_guidance:
-                noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
-                noise_pred = noise_pred_uncond + guidance_scale * (
-                    noise_pred_text - noise_pred_uncond
-                )
-
-            # compute the previous noisy sample x_t -> x_t-1
-            latents_dtype = latents.dtype
-            latents = scheduler.step(
-                noise_pred, t, latents.to(torch.float32), return_dict=False
-            )[0]
-            latents = latents.to(latents_dtype)
-
-            if latents.dtype != latents_dtype:
-                if torch.backends.mps.is_available():
-                    # some platforms (eg. apple mps) misbehave due to a pytorch bug: https://github.com/pytorch/pytorch/pull/99272
-                    latents = latents.to(latents_dtype)
-
-            if i == len(timesteps) - 1 or (
-                (i + 1) > num_warmup_steps and (i + 1) % scheduler.order == 0
-            ):
-                progress_bar.update()
-
-    if get_sequence_parallel_state():
-        latents = all_gather(latents, dim=2)
-
-    if output_type == "latent":
-        video = latents
-    else:
-        # unscale/denormalize the latents
-        # denormalize with the mean and std if available and not None
-        has_latents_mean = (
-            hasattr(vae.config, "latents_mean") and vae.config.latents_mean is not None
-        )
-        has_latents_std = (
-            hasattr(vae.config, "latents_std") and vae.config.latents_std is not None
-        )
-        if has_latents_mean and has_latents_std:
-            latents_mean = (
-                torch.tensor(vae.config.latents_mean)
-                .view(1, 12, 1, 1, 1)
-                .to(latents.device, latents.dtype)
-            )
-            latents_std = (
-                torch.tensor(vae.config.latents_std)
-                .view(1, 12, 1, 1, 1)
-                .to(latents.device, latents.dtype)
-            )
-            latents = latents * latents_std / vae.config.scaling_factor + latents_mean
-        else:
-            latents = latents / vae.config.scaling_factor
-
-        video = vae.decode(latents, return_dict=False)[0]
-        video_processor = VideoProcessor(vae_scale_factor=vae_spatial_scale_factor)
-        video = video_processor.postprocess_video(video, output_type=output_type)
-
-    return (video,)
-
-
-@torch.no_grad()
-@torch.autocast("cuda", dtype=torch.bfloat16)
-def log_validation(
-    args,
-    transformer,
-    device,
-    weight_dtype,
-    global_step,
-    scheduler_type="euler",
-    shift=1.0,
-    num_euler_timesteps=100,
-    linear_quadratic_threshold=0.025,
-    linear_range=0.5,
-    ema=False,
-):
-    # TODO
-    print(f"Running validation....\n")
-    vae = AutoencoderKLMochi.from_pretrained(
-        args.pretrained_model_name_or_path, subfolder="vae", torch_dtype=weight_dtype
-    ).to("cuda")
-    vae.enable_tiling()
-    if scheduler_type == "euler":
-        scheduler = FlowMatchEulerDiscreteScheduler()
-    else:
-        linear_quadraic = True if scheduler_type == "pcm_linear_quadratic" else False
-        scheduler = PCMFMScheduler(
-            1000,
-            shift,
-            num_euler_timesteps,
-            linear_quadraic,
-            linear_quadratic_threshold,
-            linear_range,
-        )
-    # args.validation_prompt_dir
-
-    validation_guidance_scale_ls = args.validation_guidance_scale.split(",")
-    validation_guidance_scale_ls = [
-        float(scale) for scale in validation_guidance_scale_ls
-    ]
-    for validation_sampling_step in args.validation_sampling_steps.split(","):
-        validation_sampling_step = int(validation_sampling_step)
-        for validation_guidance_scale in validation_guidance_scale_ls:
-            videos = []
-            # prompt_embed are named embed0 to embedN
-            # check how many embeds are there
-            num_embeds = len(
-                [f for f in os.listdir(args.validation_prompt_dir) if "embed" in f]
-            )
-            validation_prompt_ids = list(range(num_embeds))
-            num_sp_groups = int(os.getenv("WORLD_SIZE", "1")) // nccl_info.sp_size
-            # pad to multiple of groups
-            validation_prompt_ids += [0] * (num_sp_groups - num_embeds % num_sp_groups)
-            num_embeds_per_group = len(validation_prompt_ids) // num_sp_groups
-            local_prompt_ids = validation_prompt_ids[
-                nccl_info.group_id * num_embeds_per_group : (nccl_info.group_id + 1)
-                * num_embeds_per_group
-            ]
-
-            for i in local_prompt_ids:
-                prompt_embed_path = os.path.join(
-                    args.validation_prompt_dir, f"embed{i}.pt"
-                )
-                prompt_mask_path = os.path.join(
-                    args.validation_prompt_dir, f"mask{i}.pt"
-                )
-                prompt_embeds = (
-                    torch.load(prompt_embed_path, map_location="cpu", weights_only=True)
-                    .to(device)
-                    .to(weight_dtype)
-                    .unsqueeze(0)
-                )
-                prompt_attention_mask = (
-                    torch.load(prompt_mask_path, map_location="cpu", weights_only=True)
-                    .to(device)
-                    .to(weight_dtype)
-                    .unsqueeze(0)
-                )
-                negative_prompt_embeds = (
-                    torch.zeros(256, 4096).to(device).to(weight_dtype).unsqueeze(0)
-                )
-                negative_prompt_attention_mask = (
-                    torch.zeros(256).bool().to(device).unsqueeze(0)
-                )
-                generator = torch.Generator(device="cuda").manual_seed(12345)
-                video = sample_validation_video(
-                    transformer,
-                    vae,
-                    scheduler,
-                    scheduler_type=scheduler_type,
-                    num_frames=args.num_frames,
-                    # Peiyuan TODO: remove hardcode
-                    height=480,
-                    width=848,
-                    num_inference_steps=validation_sampling_step,
-                    guidance_scale=validation_guidance_scale,
-                    generator=generator,
-                    prompt_embeds=prompt_embeds,
-                    prompt_attention_mask=prompt_attention_mask,
-                    negative_prompt_embeds=negative_prompt_embeds,
-                    negative_prompt_attention_mask=negative_prompt_attention_mask,
-                )[0]
-                if nccl_info.rank_within_group == 0:
-                    videos.append(video[0])
-            # collect videos from all process to process zero
-
-            gc.collect()
-            torch.cuda.empty_cache()
-            # log if main process
-            torch.distributed.barrier()
-            all_videos = [
-                None for i in range(int(os.getenv("WORLD_SIZE", "1")))
-            ]  # remove padded videos
-            torch.distributed.all_gather_object(all_videos, videos)
-            if nccl_info.global_rank == 0:
-                # remove padding
-                videos = [video for videos in all_videos for video in videos]
-                videos = videos[:num_embeds]
-                # linearize all videos
-                video_filenames = []
-                for i, video in enumerate(videos):
-                    filename = os.path.join(
-                        args.output_dir,
-                        f"validation_step_{global_step}_sample_{validation_sampling_step}_guidance_{validation_guidance_scale}_video_{i}.mp4",
-                    )
-                    export_to_video(video, filename, fps=30)
-                    video_filenames.append(filename)
-
-                logs = {
-                    f"{'ema_' if ema else ''}validation_sample_{validation_sampling_step}_guidance_{validation_guidance_scale}": [
-                        wandb.Video(filename)
-                        for i, filename in enumerate(video_filenames)
-                    ]
-                }
-                wandb.log(logs, step=global_step)

fastvideo2/__init__.py

@@ -0,0 +1,31 @@
+"""fastvideo2 — a post-training-to-serving substrate for video models, MVP.
+
+Four surfaces (see README.md at the repo root):
+  contracts   fastvideo2.card / pipeline / loop  — frozen data cards, enforced
+              stage edges, the driven-loop protocol
+  reference   fastvideo2.<family>.reference       — the standalone eager oracle
+  verifier    fastvideo2.verify                   — tiered gates + evidence ledger
+  trace       engine identity chain               — request/stage/loop.step -> NVTX
+
+``import fastvideo2`` is dependency-light: torch / diffusers / transformers
+load lazily, only when weights are actually touched.
+"""
+from fastvideo2.card import ModelCard, derive
+from fastvideo2.engine import Instance, Output, Request, run
+from fastvideo2.registry import resolve
+from fastvideo2.sdk import Model, Result, load
+
+__version__ = "0.1.0"
+__all__ = ["ModelCard", "derive", "Model", "Result", "load", "resolve",
+           "Instance", "Output", "Request", "run", "generate", "__version__"]
+
+
+def generate(model: str, prompt: str, *, root: str | None = None,
+             device: str | None = None, **request_kwargs) -> Result:
+    """One-call convenience over the SDK: load then generate (loads per call —
+    hold a :class:`Model` via :func:`load` to amortize residency).
+
+    >>> result = fastvideo2.generate("wan2.1-t2v-1.3b", "a cat surfing", seed=7)
+    >>> result.video.shape   # [T, H, W, C] uint8
+    """
+    return load(model, root=root, device=device).generate(prompt, **request_kwargs)

fastvideo2/__main__.py

@@ -0,0 +1,3 @@
+from fastvideo2.cli import main
+
+raise SystemExit(main())

fastvideo2/card.py

@@ -0,0 +1,213 @@
+"""Model cards — the contract surface.
+
+A card is a frozen, pure-data description of one servable artifact: its
+components, the loops its weights assume, and the sampling defaults that are
+part of the trained artifact. Components and loops are declared as
+``"module:attr"`` reference strings and loop params must be plain JSON values
+— no callables — so a card is:
+
+* **serializable** — ``to_json``/``from_dict`` are lossless (T0-gated), so a
+  card ships as ``card.json`` beside a checkpoint or inside a deploy config;
+* **content-addressed** — ``digest()`` hashes the canonical JSON (think git
+  object id) and is the card's identity in evidence records, T1 baselines,
+  and environment manifests. It names the declaration only; weights, code,
+  and environment drift are checked separately (T1, T2, env fingerprint).
+
+Variants are expressed as diffs against a base card via :func:`derive` — never
+as builder functions with keyword arguments. Derivation is additive: a variant
+that needs to *remove* something picked the wrong base and should be declared
+fresh.
+
+Import discipline: this module is stdlib-only. ``validate()`` imports the
+declared loop modules to check their ``semantics`` ids, so loop modules must be
+importable without torch.
+"""
+from __future__ import annotations
+
+import hashlib
+import importlib
+import json
+from dataclasses import asdict, dataclass, field, fields, is_dataclass, replace
+from typing import Any
+
+
+class CardError(ValueError):
+    pass
+
+
+def resolve_ref(ref: str) -> Any:
+    """Resolve a ``"module:attr"`` reference string to the live object."""
+    mod, _, attr = ref.partition(":")
+    if not mod or not attr:
+        raise CardError(f"bad reference {ref!r} (expected 'module:attr')")
+    return getattr(importlib.import_module(mod), attr)
+
+
+@dataclass(frozen=True)
+class ComponentSpec:
+    """One weight-bearing (or processing) component of the artifact."""
+    component_id: str
+    kind: str        # dit | vae | text_encoder | tokenizer
+    module: str      # loader reference, e.g. "fastvideo2.wan21.model:WanModel"
+    subfolder: str   # subfolder in the checkpoint layout ("" = repo root)
+    dtype: str = "bf16"  # bf16 | fp32 | "" (dtype-less, e.g. tokenizer)
+    source: str = ""     # weights repo override; "" = the card-level `weights`
+
+
+@dataclass(frozen=True)
+class LoopSpec:
+    """One iterative computation the card can run.
+
+    ``loop`` names the implementation class; ``params`` are plain JSON values
+    passed to its constructor. The class carries a ``semantics`` id that
+    provenance pins (see ``Provenance.assumes_loop``).
+    """
+    loop_id: str
+    loop: str                                  # "fastvideo2.wan21.loop:WanDenoiseLoop"
+    params: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class SamplingDefaults:
+    """Per-model generation defaults that are part of the trained artifact."""
+    num_steps: int
+    guidance_scale: float
+    height: int
+    width: int
+    num_frames: int
+    fps: int
+    shift: float
+    negative_prompt: str = ""
+
+
+@dataclass(frozen=True)
+class Provenance:
+    """Where the weights came from and what they assume.
+
+    ``assumes_loop`` is a *semantics id* (e.g. ``"wan.flow_euler.cfg/v1"``),
+    not a loop_id: validation resolves every declared loop class and requires
+    one whose ``semantics`` matches. A distilled student that requires a
+    different sampler therefore cannot validate against a base card.
+    ``substitution`` classifies this artifact relative to ``parents``:
+    ``exact`` | ``bounded`` | ``quality-changing``.
+    """
+    method: str = "base"
+    parents: tuple[str, ...] = ()
+    assumes_loop: str = ""
+    precision: str = "bf16"
+    substitution: str = "exact"
+    tolerances: dict[str, float] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class ModelCard:
+    model_id: str
+    family: str
+    weights: str                                # canonical source (HF repo id)
+    components: dict[str, ComponentSpec]
+    loops: dict[str, LoopSpec]
+    capabilities: tuple[str, ...]
+    provenance: Provenance
+    sampling_defaults: SamplingDefaults
+    determinism: str = "tolerance"              # bitwise | tolerance
+
+    # --- identity ---------------------------------------------------------- #
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict(), sort_keys=True, indent=2)
+
+    def digest(self) -> str:
+        """Content digest over the canonical JSON — the card's identity in the
+        evidence ledger and every environment manifest."""
+        canon = json.dumps(self.to_dict(), sort_keys=True, separators=(",", ":"))
+        return hashlib.sha256(canon.encode()).hexdigest()[:16]
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "ModelCard":
+        return cls(
+            model_id=d["model_id"],
+            family=d["family"],
+            weights=d["weights"],
+            components={k: ComponentSpec(**v) for k, v in d["components"].items()},
+            loops={k: LoopSpec(**v) for k, v in d["loops"].items()},
+            capabilities=tuple(d["capabilities"]),
+            provenance=Provenance(**{**d["provenance"], "parents": tuple(d["provenance"]["parents"])}),
+            sampling_defaults=SamplingDefaults(**d["sampling_defaults"]),
+            determinism=d.get("determinism", "tolerance"),
+        )
+
+    # --- validation -------------------------------------------------------- #
+    def validate(self) -> "ModelCard":
+        errs: list[str] = []
+        if not self.components:
+            errs.append("card declares no components")
+        if not self.loops:
+            errs.append("card declares no loops")
+        for cid, spec in self.components.items():
+            if cid != spec.component_id:
+                errs.append(f"component key {cid!r} != component_id {spec.component_id!r}")
+        semantics_seen: list[str] = []
+        for lid, spec in self.loops.items():
+            if lid != spec.loop_id:
+                errs.append(f"loop key {lid!r} != loop_id {spec.loop_id!r}")
+            try:
+                cls = resolve_ref(spec.loop)
+            except Exception as e:  # unresolvable ref is a contract violation
+                errs.append(f"loop {lid!r}: cannot resolve {spec.loop!r} ({e})")
+                continue
+            sem = getattr(cls, "semantics", None)
+            if not sem:
+                errs.append(f"loop {lid!r}: class {spec.loop!r} declares no `semantics` id")
+            else:
+                semantics_seen.append(sem)
+            try:
+                json.dumps(spec.params)
+            except TypeError:
+                errs.append(f"loop {lid!r}: params are not plain JSON values")
+        # the teeth: weights may only be served under a loop whose semantics
+        # they were trained for.
+        if self.provenance.assumes_loop and self.provenance.assumes_loop not in semantics_seen:
+            errs.append(
+                f"provenance.assumes_loop={self.provenance.assumes_loop!r} matches no declared "
+                f"loop semantics (have {semantics_seen}) — these weights cannot run on this card")
+        if self.determinism not in ("bitwise", "tolerance"):
+            errs.append(f"unknown determinism class {self.determinism!r}")
+        if errs:
+            raise CardError(f"ModelCard {self.model_id!r} failed validation:\n  - " + "\n  - ".join(errs))
+        return self
+
+
+def _merge_field(old: Any, patch: Any) -> Any:
+    """One-level structural merge used by :func:`derive`.
+
+    dict field + dict patch      -> merge by key (spec values replace; dict
+                                    values patch the existing spec/dict)
+    dataclass field + dict patch -> replace() with recursively merged fields
+    anything else                -> the patch value wins
+    """
+    if is_dataclass(old) and isinstance(patch, dict):
+        merged = {k: _merge_field(getattr(old, k), v) for k, v in patch.items()}
+        return replace(old, **merged)
+    if isinstance(old, dict) and isinstance(patch, dict):
+        out = dict(old)
+        for k, v in patch.items():
+            out[k] = _merge_field(old[k], v) if k in old else v
+        return out
+    return patch
+
+
+def derive(base: ModelCard, **delta: Any) -> ModelCard:
+    """A variant as an explicit diff against a base card.
+
+    Additive only: keys merge, nothing is deleted. A variant that must remove a
+    component or loop is a different architecture — declare it fresh. The
+    derived card re-validates, so an invalid diff fails at declaration.
+    """
+    valid = {f.name for f in fields(ModelCard)}
+    unknown = set(delta) - valid
+    if unknown:
+        raise CardError(f"derive: unknown card fields {sorted(unknown)}")
+    merged = {k: _merge_field(getattr(base, k), v) for k, v in delta.items()}
+    return replace(base, **merged).validate()

fastvideo2/cli.py

@@ -0,0 +1,92 @@
+"""CLI: describe / generate / verify — the three agent-facing verbs.
+
+  python -m fastvideo2 describe wan2.1-t2v-1.3b
+  python -m fastvideo2 generate wan2.1-t2v-1.3b --prompt "a cat surfing" --out cat.mp4
+  python -m fastvideo2 verify   wan2.1-t2v-1.3b --tier 2 [--bless]
+
+``describe`` prints the card as JSON plus its digest — machine-readable
+capability discovery. ``verify`` appends typed results to the evidence ledger
+and exits non-zero on any failed gate.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+
+def _describe(args) -> int:
+    from fastvideo2.registry import resolve
+    card, _ = resolve(args.model)
+    print(card.to_json())
+    print(f'// digest: {card.digest()}', file=sys.stderr)
+    return 0
+
+
+def _generate(args) -> int:
+    import fastvideo2
+    kwargs = {k: getattr(args, k) for k in
+              ("seed", "num_steps", "guidance_scale", "height", "width", "num_frames", "shift")
+              if getattr(args, k) is not None}
+    model = fastvideo2.load(args.model, root=args.root, device=args.device)
+    result = model.generate(args.prompt, **kwargs)
+    result.save(args.out, fps=args.fps)
+    steps = [t for t in result.trace if "/denoise." in t["label"]]
+    print(f"video {result.video.shape} -> {args.out}")
+    print(f"total {result.seconds:.1f}s; denoise steps {len(steps)}, "
+          f"mean {sum(t['seconds'] for t in steps) / max(len(steps), 1):.2f}s/step")
+    return 0
+
+
+def _verify(args) -> int:
+    from fastvideo2.verify import LEDGER, verify
+    results = verify(args.model, tier=args.tier, root=args.root, device=args.device,
+                     bless=args.bless, anchor=args.anchor)
+    for r in results:
+        mark = {"pass": "PASS ", "blessed": "BLESS", "fail": "FAIL "}[r.status]
+        print(f"  {mark} {r.gate:14s} {r.detail or json.dumps(r.metrics)[:120]}")
+    print(f"ledger: {LEDGER}")
+    return 0 if all(r.ok for r in results) else 1
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(prog="fastvideo2", description=__doc__)
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    d = sub.add_parser("describe", help="print a card as JSON + digest")
+    d.add_argument("model")
+    d.set_defaults(fn=_describe)
+
+    g = sub.add_parser("generate", help="run one request, save an mp4")
+    g.add_argument("model")
+    g.add_argument("--prompt", required=True)
+    g.add_argument("--out", default="out.mp4")
+    g.add_argument("--root", default=None, help="local checkpoint dir (else HF cache)")
+    g.add_argument("--device", default=None)
+    g.add_argument("--seed", type=int, default=0)
+    g.add_argument("--num-steps", dest="num_steps", type=int, default=None)
+    g.add_argument("--guidance-scale", dest="guidance_scale", type=float, default=None)
+    g.add_argument("--height", type=int, default=None)
+    g.add_argument("--width", type=int, default=None)
+    g.add_argument("--num-frames", dest="num_frames", type=int, default=None)
+    g.add_argument("--shift", type=float, default=None)
+    g.add_argument("--fps", type=int, default=16)
+    g.set_defaults(fn=_generate)
+
+    v = sub.add_parser("verify", help="run tiered gates; append to the evidence ledger")
+    v.add_argument("model")
+    v.add_argument("--tier", type=int, default=3, choices=(0, 1, 2, 3))
+    v.add_argument("--root", default=None)
+    v.add_argument("--device", default=None)
+    v.add_argument("--bless", action="store_true",
+                   help="write the T1 fingerprint baseline for this environment")
+    v.add_argument("--anchor", action="store_true",
+                   help="also certify components against the official Wan2.1 goldens")
+    v.set_defaults(fn=_verify)
+
+    args = p.parse_args(argv)
+    return args.fn(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

fastvideo2/dreamverse/__init__.py

@@ -0,0 +1,4 @@
+"""Dreamverse runtime on fastvideo2 — session WS + fMP4 segments. See server.py."""
+from fastvideo2.dreamverse.server import build_app, main
+
+__all__ = ["build_app", "main"]

fastvideo2/dreamverse/__main__.py

@@ -0,0 +1,3 @@
+from fastvideo2.dreamverse.server import main
+
+main()

fastvideo2/dreamverse/gates/dreamverse_anchor.py

@@ -0,0 +1,100 @@
+"""Dreamverse runtime anchor: boot the server with DUMMY prompt keys, drive
+one full session over the protocol, and assert the streaming contract:
+segment_start -> live step_complete x3 -> media_init -> binary fMP4 chunks
+(first chunk carries an ISO-BMFF `ftyp` box) -> media_segment_complete ->
+segment_complete with a latents sha.
+
+Usage (cluster): python -m fastvideo2.dreamverse.gates.dreamverse_anchor
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import subprocess
+import sys
+import time
+import urllib.request
+
+MODEL = "fastwan-qad-fp8-1.3b"
+PORT = 8019
+PROMPT = "A raccoon in a field of sunflowers, warm light, mid-shot."
+
+
+def main() -> int:
+    env = dict(os.environ, CEREBRAS_API_KEY="dummy", GROQ_API_KEY="dummy")
+    server = subprocess.Popen(
+        [sys.executable, "-m", "fastvideo2.dreamverse", "--model", MODEL,
+         "--port", str(PORT)], env=env,
+        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    try:
+        for _ in range(360):
+            try:
+                with urllib.request.urlopen(
+                        f"http://127.0.0.1:{PORT}/health", timeout=5) as r:
+                    if json.loads(r.read())["model"] == MODEL:
+                        break
+            except Exception:
+                time.sleep(2)
+        else:
+            raise RuntimeError("server never became healthy")
+
+        import websockets
+
+        async def session() -> dict:
+            counts = {"steps": 0, "chunks": 0, "ftyp": False}
+            async with websockets.connect(
+                    f"ws://127.0.0.1:{PORT}/ws", max_size=None) as ws:
+                await ws.send(json.dumps({"type": "session_init_v2",
+                                          "enhancement": True}))
+                for expected in ("queue_status", "gpu_assigned", "stream_start"):
+                    got = json.loads(await ws.recv())["type"]
+                    assert got == expected, (got, expected)
+                await ws.send(json.dumps({"type": "segment_prompt_source",
+                                          "prompt": PROMPT, "seed": 7}))
+                while True:
+                    raw = await asyncio.wait_for(ws.recv(), timeout=900)
+                    if isinstance(raw, bytes):
+                        if counts["chunks"] == 0:
+                            counts["ftyp"] = b"ftyp" in raw[:64]
+                        counts["chunks"] += 1
+                        continue
+                    msg = json.loads(raw)
+                    t = msg["type"]
+                    if t == "step_complete":
+                        counts["steps"] += 1
+                    elif t == "segment_complete":
+                        counts["latents_sha"] = msg["latents_sha"]
+                        counts["frames"] = msg["frames"]
+                        break
+                    elif t == "error":
+                        raise RuntimeError(msg)
+                await ws.send(json.dumps({"type": "leave"}))
+                assert json.loads(await ws.recv())["type"] == "stream_complete"
+            return counts
+
+        c = asyncio.run(session())
+    finally:
+        server.terminate()
+        server.wait(timeout=30)
+
+    ok = (c["steps"] == 3 and c["chunks"] >= 1 and c["ftyp"]
+          and c.get("frames", 0) == 81)
+    print(f"steps={c['steps']} chunks={c['chunks']} ftyp={c['ftyp']} "
+          f"frames={c.get('frames')} sha={c.get('latents_sha')} "
+          f"{'OK' if ok else 'FAIL'}")
+
+    from fastvideo2.verify import GateResult, append_ledger, env_fingerprint
+    append_ledger([GateResult(gate="anchor.dreamverse-runtime",
+                              status="pass" if ok else "fail", model_id=MODEL,
+                              card_digest="-",
+                              metrics={"steps": float(c["steps"]),
+                                       "chunks": float(c["chunks"]),
+                                       "ftyp": 1.0 if c["ftyp"] else 0.0},
+                              tolerances={}, env=env_fingerprint(),
+                              detail=f"latents {c.get('latents_sha')}")])
+    return 0 if ok else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

fastvideo2/dreamverse/server.py

@@ -0,0 +1,269 @@
+"""Dreamverse runtime on fastvideo2 — the realtime video session server.
+
+Ported from ``apps/dreamverse`` (fastvideo-main): the WebSocket session
+protocol (``session_init_v2`` → per-segment prompts → fMP4 fragments over
+the socket), the ffmpeg fragmented-MP4 encoder (verbatim flags from
+``entrypoints/streaming/stream.py``: libx264, zerolatency,
+``empty_moov+default_base_moof+frag_keyframe+faststart``), and an optional
+Cerebras/Groq prompt enhancer (boots with dummy keys — enhancement simply
+stays off, the same bring-up shortcut the GB200 deploys used).
+
+Deliberately re-based for v2.1 (the original is LTX2-specific — audio,
+refine stage, continuation-state, LoRA stack): segments generate through the
+fastvideo2 SDK on the FastWan 3-step DMD student (seconds per segment on
+GB200), and per-step progress is LIVE via the engine's ``on_step`` hook
+(``step_complete`` per denoise step — the original emits one terminal event
+per segment). Message names follow the upstream protocol so their web client
+schema maps directly; LTX2-only fields are ignored.
+
+Run:  python -m fastvideo2.dreamverse --model fastwan-qad-fp8-1.3b --port 8009
+ffmpeg: FASTVIDEO_FFMPEG_BIN, or PATH, or the imageio-ffmpeg bundled binary.
+"""
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import json
+import os
+import shutil
+import subprocess
+import threading
+import urllib.request
+import uuid
+from typing import Any
+
+
+def find_ffmpeg() -> str:
+    p = os.environ.get("FASTVIDEO_FFMPEG_BIN") or shutil.which("ffmpeg")
+    if p:
+        return p
+    try:  # the GB200 bring-up shortcut: pip-installed bundled binary
+        import imageio_ffmpeg
+        return imageio_ffmpeg.get_ffmpeg_exe()
+    except ImportError as e:
+        raise RuntimeError("no ffmpeg (set FASTVIDEO_FFMPEG_BIN, install "
+                           "ffmpeg, or `pip install imageio-ffmpeg`)") from e
+
+
+def fmp4_encode(frames: Any, *, fps: int, ffmpeg: str) -> list[bytes]:
+    """One segment -> fragmented-MP4 byte chunks (upstream's exact flags)."""
+    t, h, w, _ = frames.shape
+    args = [ffmpeg, "-hide_banner", "-loglevel", "error",
+            "-f", "rawvideo", "-pix_fmt", "rgb24", "-s", f"{w}x{h}",
+            "-r", str(fps), "-i", "-",
+            "-c:v", "libx264", "-preset", "ultrafast", "-tune", "zerolatency",
+            "-pix_fmt", "yuv420p",
+            "-movflags", "empty_moov+default_base_moof+frag_keyframe+faststart",
+            "-f", "mp4", "-"]
+    proc = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                            stderr=subprocess.DEVNULL, bufsize=0)
+    out: list[bytes] = []
+
+    def _read() -> None:
+        while True:
+            chunk = proc.stdout.read(65536)
+            if not chunk:
+                break
+            out.append(chunk)
+
+    reader = threading.Thread(target=_read, daemon=True)
+    reader.start()
+    for i in range(t):
+        proc.stdin.write(frames[i].tobytes())
+    proc.stdin.close()
+    proc.wait(timeout=120)
+    reader.join(timeout=30)
+    return out
+
+
+class PromptEnhancer:
+    """Cerebras-or-Groq chat call (upstream's provider pair, gpt-oss-120b).
+    Dummy/missing keys or any failure -> pass the prompt through unchanged."""
+
+    def __init__(self) -> None:
+        self.cerebras = os.environ.get("CEREBRAS_API_KEY", "")
+        self.groq = os.environ.get("GROQ_API_KEY", "")
+        self.enabled = any(k and k != "dummy" for k in (self.cerebras, self.groq))
+
+    def enhance(self, prompt: str, history: list[str]) -> str:
+        if not self.enabled:
+            return prompt
+        targets = []
+        if self.cerebras and self.cerebras != "dummy":
+            targets.append(("https://api.cerebras.ai/v1/chat/completions",
+                            self.cerebras, "gpt-oss-120b"))
+        if self.groq and self.groq != "dummy":
+            targets.append(("https://api.groq.com/openai/v1/chat/completions",
+                            self.groq, "openai/gpt-oss-120b"))
+        system = ("Rewrite the user's next-video-segment prompt into one vivid, "
+                  "concrete shot description. Prior segments: "
+                  + " | ".join(history[-3:]))
+        for url, key, model_name in targets:
+            try:
+                req = urllib.request.Request(
+                    url, method="POST",
+                    headers={"Authorization": f"Bearer {key}",
+                             "Content-Type": "application/json"},
+                    data=json.dumps({"model": model_name, "temperature": 1.0,
+                                     "messages": [{"role": "system", "content": system},
+                                                  {"role": "user", "content": prompt}]
+                                     }).encode())
+                with urllib.request.urlopen(req, timeout=20) as r:
+                    return json.loads(r.read())["choices"][0]["message"]["content"].strip()
+            except Exception:
+                continue
+        return prompt
+
+
+def build_app(model: Any) -> Any:
+    from fastapi import FastAPI
+    from starlette.routing import WebSocketRoute
+    from starlette.websockets import WebSocketDisconnect
+
+    from fastvideo2.engine import Request
+    from fastvideo2.engine import run as engine_run
+    from fastvideo2.sdk import Result
+
+    app = FastAPI(title="dreamverse-fv2", version="0.1")
+    ffmpeg = find_ffmpeg()
+    enhancer = PromptEnhancer()
+    gen_lock = threading.Lock()
+
+    @app.get("/health")
+    def health() -> dict:
+        return {"status": "ok", "model": model.model_id,
+                "enhancer": enhancer.enabled, "ffmpeg": ffmpeg}
+
+    @app.get("/readyz")
+    def readyz() -> dict:
+        return {"ready": True}
+
+    async def ws_session(ws) -> None:
+        await ws.accept()
+        try:
+            init = await ws.receive_json()
+        except WebSocketDisconnect:
+            return
+        if init.get("type") != "session_init_v2":
+            await ws.send_json({"type": "error", "code": "bad_init",
+                                "error": "expected session_init_v2"})
+            await ws.close()
+            return
+        session_id = uuid.uuid4().hex[:12]
+        enhancement_on = bool(init.get("enhancement", False)) and enhancer.enabled
+        history: list[str] = []
+        segment_idx = 0
+        await ws.send_json({"type": "queue_status", "position": 0})
+        await ws.send_json({"type": "gpu_assigned", "session_id": session_id})
+        await ws.send_json({"type": "stream_start", "session_id": session_id,
+                            "model": model.model_id})
+
+        loop = asyncio.get_running_loop()
+        while True:
+            try:
+                msg = await ws.receive_json()
+            except WebSocketDisconnect:
+                return
+            mtype = msg.get("type")
+            if mtype == "leave":
+                await ws.send_json({"type": "stream_complete",
+                                    "segments": segment_idx})
+                await ws.close()
+                return
+            if mtype == "enhancement_updated":
+                enhancement_on = bool(msg.get("enabled")) and enhancer.enabled
+                continue
+            if mtype != "segment_prompt_source":
+                await ws.send_json({"type": "error", "code": "bad_message",
+                                    "error": f"unsupported type {mtype!r}"})
+                continue
+
+            prompt = str(msg.get("prompt", ""))
+            if not prompt:
+                await ws.send_json({"type": "error", "code": "bad_prompt",
+                                    "error": "prompt required"})
+                continue
+            if enhancement_on:
+                prompt = await loop.run_in_executor(
+                    None, enhancer.enhance, prompt, history)
+            history.append(prompt)
+            await ws.send_json({"type": "segment_start", "segment": segment_idx,
+                                "prompt": prompt})
+
+            q: asyncio.Queue = asyncio.Queue()
+
+            def on_step(label: str, seconds: float, meta: dict) -> None:
+                loop.call_soon_threadsafe(
+                    q.put_nowait, {"type": "step_complete", "label": label,
+                                   "seconds": round(seconds, 4)})
+
+            def generate(p: str = prompt, seed: Any = msg.get("seed", 0),
+                         steps: Any = msg.get("num_steps")) -> None:
+                try:
+                    req = Request(prompt=p, request_id=f"{session_id}-{segment_idx}",
+                                  seed=int(seed), num_steps=steps)
+                    with gen_lock:
+                        out = engine_run(model.instance, model.pipeline, req,
+                                         on_step=on_step)
+                    result = Result(outputs=out.outputs, trace=out.trace,
+                                    request=req.resolve(model.card),
+                                    model_id=model.model_id,
+                                    card_digest=model.card.digest(),
+                                    fps=model.card.sampling_defaults.fps)
+                    chunks = fmp4_encode(result.video, fps=result.fps,
+                                         ffmpeg=ffmpeg)
+                    import torch
+                    sha = hashlib.sha256(result.latents.detach().to(
+                        torch.float32).cpu().numpy().tobytes()).hexdigest()[:16]
+                    loop.call_soon_threadsafe(
+                        q.put_nowait, {"__chunks": chunks, "latents_sha": sha,
+                                       "frames": int(result.video.shape[0])})
+                except Exception as e:
+                    loop.call_soon_threadsafe(
+                        q.put_nowait, {"type": "error", "code": "generation",
+                                       "error": f"{type(e).__name__}: {e}"})
+
+            threading.Thread(target=generate, daemon=True).start()
+            while True:
+                ev = await q.get()
+                if "__chunks" in ev:
+                    await ws.send_json({"type": "media_init",
+                                        "segment": segment_idx,
+                                        "mime": 'video/mp4; codecs="avc1"'})
+                    for chunk in ev["__chunks"]:
+                        await ws.send_bytes(chunk)
+                    await ws.send_json({"type": "media_segment_complete",
+                                        "segment": segment_idx})
+                    await ws.send_json({"type": "segment_complete",
+                                        "segment": segment_idx,
+                                        "frames": ev["frames"],
+                                        "latents_sha": ev["latents_sha"]})
+                    segment_idx += 1
+                    break
+                await ws.send_json(ev)
+                if ev.get("type") == "error":
+                    break
+
+    app.router.routes.append(WebSocketRoute("/ws", ws_session))
+    return app
+
+
+def main(argv: list[str] | None = None) -> None:
+    import argparse
+
+    import uvicorn
+
+    import fastvideo2 as fv2
+
+    p = argparse.ArgumentParser("fastvideo2.dreamverse")
+    p.add_argument("--model", default="fastwan-qad-fp8-1.3b")
+    p.add_argument("--host", default="127.0.0.1")
+    p.add_argument("--port", type=int, default=8009)
+    p.add_argument("--device", default=None)
+    args = p.parse_args(argv)
+    model = fv2.load(args.model, device=args.device)
+    uvicorn.run(build_app(model), host=args.host, port=args.port)
+
+
+if __name__ == "__main__":
+    main()

fastvideo2/engine.py

@@ -0,0 +1,178 @@
+"""The engine — drives a pipeline over one resident instance, one request at a
+time, with the identity chain attached.
+
+Identity chain: every unit of work is named ``request/stage`` for one-shot
+stages and ``request/stage/loop.step`` for loop steps. The same name goes to
+(a) the returned trace (typed timings, machine-readable) and (b) NVTX ranges
+when CUDA is present — so Nsight correlates kernels to model-level identity
+with no extra instrumentation.
+
+Deliberately absent (this is the one-shot MVP): queueing, admission, batching,
+sessions, cancellation. Sessions with forkable state are the next consumer of
+the loop contract, not a reason to grow this file now.
+"""
+from __future__ import annotations
+
+import contextlib
+from dataclasses import dataclass, field, replace
+from typing import Any
+
+from fastvideo2.card import ModelCard
+from fastvideo2.loading import load_component, resolve_weights
+from fastvideo2.loop import LoopRunner, build_loop
+from fastvideo2.pipeline import ComponentStage, LoopStage, Pipeline, run_component_stage
+
+
+@dataclass(frozen=True)
+class Request:
+    """One generation request. ``None`` fields resolve from the card's
+    sampling defaults via :meth:`resolve`."""
+    prompt: str
+    request_id: str = "req0"
+    negative_prompt: str | None = None
+    seed: int = 0
+    num_steps: int | None = None
+    guidance_scale: float | None = None
+    height: int | None = None
+    width: int | None = None
+    num_frames: int | None = None
+    shift: float | None = None
+    capture_trajectory: bool = False
+
+    def resolve(self, card: ModelCard) -> "Request":
+        d = card.sampling_defaults
+        fill = {
+            "negative_prompt": d.negative_prompt,
+            "num_steps": d.num_steps,
+            "guidance_scale": d.guidance_scale,
+            "height": d.height,
+            "width": d.width,
+            "num_frames": d.num_frames,
+            "shift": d.shift,
+        }
+        patch = {k: v for k, v in fill.items() if getattr(self, k) is None}
+        return replace(self, **patch)
+
+
+@dataclass
+class Output:
+    request_id: str
+    outputs: dict[str, Any]
+    trace: list[dict] = field(default_factory=list)   # [{label, seconds, ...meta}]
+
+    @property
+    def seconds(self) -> float:
+        return sum(t["seconds"] for t in self.trace)
+
+
+class Instance:
+    """A resident, loaded card: components materialize lazily and are shared
+    by reference; loops are built from the card's declared specs."""
+
+    def __init__(self, card: ModelCard, root: str | None = None, device: str = "cpu"):
+        self.card = card
+        self.device = device
+        self.root = resolve_weights(card, root)
+        self._components: dict[str, Any] = {}
+        self._source_roots: dict[str, str] = {}
+        self._loops: dict[str, Any] = {}
+
+    def component(self, component_id: str) -> Any:
+        if component_id not in self._components:
+            spec = self.card.components.get(component_id)
+            if spec is None:
+                raise KeyError(f"component {component_id!r} not declared on card {self.card.model_id!r}")
+            root = self._source_root(spec.source) if spec.source else self.root
+            self._components[component_id] = load_component(spec, root, self.device)
+        return self._components[component_id]
+
+    def _source_root(self, source: str) -> str:
+        """Resolve a per-component weights source (e.g. the official-layout
+        transformer repo) through the same snapshot cache as card weights."""
+        if source not in self._source_roots:
+            from huggingface_hub import snapshot_download
+            self._source_roots[source] = snapshot_download(source)
+        return self._source_roots[source]
+
+    def loop(self, loop_id: str) -> Any:
+        if loop_id not in self._loops:
+            spec = self.card.loops.get(loop_id)
+            if spec is None:
+                raise KeyError(f"loop {loop_id!r} not declared on card {self.card.model_id!r}")
+            self._loops[loop_id] = build_loop(spec)
+        return self._loops[loop_id]
+
+
+def load(card: ModelCard, root: str | None = None, device: str | None = None) -> Instance:
+    """The public entrypoint: card + weights root -> resident instance."""
+    card.validate()
+    if device is None:
+        device = _detect_device()
+    return Instance(card, root=root, device=device)
+
+
+def _detect_device() -> str:
+    try:
+        import torch
+        if torch.cuda.is_available():
+            return "cuda"
+    except ImportError:
+        pass
+    return "cpu"
+
+
+@contextlib.contextmanager
+def _nvtx(name: str):
+    """NVTX range when CUDA is live; free otherwise."""
+    pushed = False
+    try:
+        import torch
+        if torch.cuda.is_available():
+            torch.cuda.nvtx.range_push(name)
+            pushed = True
+    except ImportError:
+        pass
+    try:
+        yield
+    finally:
+        if pushed:
+            import torch
+            torch.cuda.nvtx.range_pop()
+
+
+def run(instance: Instance, pipeline: Pipeline, request: Request,
+        on_step: Any = None) -> Output:
+    """Run one request through a pipeline to completion. ``on_step(label,
+    seconds, meta)``, when given, fires live after every loop step (serving
+    streams progress through it)."""
+    import time
+    req = request.resolve(instance.card)
+    trace: list[dict] = []
+    slots: dict[str, Any] = {}
+    for name in pipeline.inputs:  # request-provided slots, by attribute name
+        slots[name] = getattr(req, name)
+
+    for stage in pipeline.stages:
+        chain = f"{req.request_id}/{stage.stage_id}"
+        if isinstance(stage, ComponentStage):
+            with _nvtx(chain):
+                t0 = time.perf_counter()
+                run_component_stage(stage, instance, slots, req)
+                trace.append({"label": chain, "seconds": time.perf_counter() - t0})
+        elif isinstance(stage, LoopStage):
+            loop = instance.loop(stage.loop_id)
+
+            def observe(label: str, seconds: float, meta: dict, _chain: str = chain) -> None:
+                trace.append({"label": f"{_chain}/{label}", "seconds": seconds, **meta})
+                if on_step is not None:
+                    on_step(f"{_chain}/{label}", seconds, meta)
+
+            inputs = {k: slots[k] for k in stage.reads}
+            with _nvtx(chain):
+                runner = LoopRunner(loop, req, instance, inputs, observe=observe)
+                slots[stage.writes[0]] = runner.run()
+        else:
+            raise TypeError(f"unknown stage kind {type(stage).__name__}")
+
+    outputs = {name: slots[slot] for name, slot in pipeline.outputs.items()}
+    return Output(request_id=req.request_id, outputs=outputs, trace=trace)

fastvideo2/evidence/README.md

@@ -0,0 +1,18 @@
+# Evidence ledger
+
+Typed verification records, committed with the code they vouch for.
+
+- `ledger.jsonl` — append-only `GateResult` records: gate, status, card digest,
+  metrics, tolerances, environment fingerprint, timestamp. Written only by
+  `python -m fastvideo2 verify`; never edited by hand.
+- `<model_id>.fingerprints.json` — the blessed T1 component baseline for one
+  card digest in one environment.
+- `sample_*.mp4` — eyeballable artifacts from full-scale runs (e.g.
+  `sample_wan21_seed7.mp4`, 50 steps / 81 frames on GB200, byte-identical
+  between the production pipeline and `reference.py` at the same seed). Re-bless deliberately (`verify --bless`)
+  when the card or environment legitimately changes; a digest mismatch is a
+  failure, not a skip.
+
+Ownership rule: baselines and gate tolerances are human-owned. Agents run the
+gates and append evidence; they do not re-bless baselines to make a failure
+disappear.

fastvideo2/evidence/fastwan_numerics_report.md

@@ -0,0 +1,82 @@
+# FastWan variants — bitwise alignment vs fastvideo-main
+
+Authority for FastWan artifacts is **fastvideo main** (they were distilled in
+that stack); the alignment target was bit-exactness against main's own serving
+path, pinned to main's exposed knobs so the goldens measure the artifact, not
+the accelerator stack: `FASTVIDEO_ATTENTION_BACKEND=FLASH_ATTN` (QAD) /
+`VIDEO_SPARSE_ATTN` (VSA), FP8 per-tensor dynamic quant (QAD), no torch.compile,
+no FSDP, single GB200.
+
+Goldens captured at main commit `c459a1897899ffcec3be7765534d81000b9bb9c1`;
+the vendored forward (`wan21/model_fv.py`) was read at `e3f47dc2de2d…` — all
+10 numerics-relevant source files verified byte-identical between the two.
+
+## Final anchor results (all rows target 0.0 — bitwise)
+
+| row | fastwan-qad-fp8-1.3b | fastwan-t2v-1.3b (VSA) |
+|---|---|---|
+| dit bf16 probes t∈{1000,757,522} | 0.0 / 0.0 / 0.0 | — |
+| dit fp8 probes t∈{1000,757,522} | 0.0 / 0.0 / 0.0 | — |
+| dit vsa probes t∈{1000,757,522} | — | 0.0 / 0.0 / 0.0 |
+| text_encoder (e2e + probe prompts) | 0.0 / 0.0 | 0.0 / 0.0 |
+| e2e step-1 / step-2 latent chain | 0.0 / 0.0 | 0.0 / 0.0 |
+| e2e final latents (81f, 480×832, 3 steps) | 0.0 | 0.0 |
+
+Ledger: `anchor.fastwan-qad-main` and `anchor.fastwan-vsa-main`, both `pass`
+(card digests `1c8e6f7d1380552d`, `0bd5c7771e10ce44`).
+
+## Root causes found by the gates (in discovery order)
+
+1. **fp8 quantization is device-sensitive.** main converts weights to fp8 on
+   the GPU (post-materialization); quantizing the *identical* bf16 weights on
+   CPU produces different fp8 codes often enough to move a full forward by
+   ~4e-2 rel (fp8's coarse grid amplifies conversion-tie differences).
+   Fix: `FP8Linear` defers quantization to first forward on the serving
+   device (`layers/fp8.py`).
+2. **0-dim sigma tensors demote the renoise mixing to bf16.** In torch type
+   promotion 0-dim tensors act as scalars, so `(1-σ)*x0 + σ*ε` with a 0-dim
+   fp32 σ ran in bf16 (two roundings); main's `[B,1,1,1]` fp32 σ promotes the
+   arithmetic to fp32 with one final bf16 cast. 3.2e-3 per step, compounding
+   to 8.2e-2 over 3 steps. Fix: non-0-dim σ in `WanDMDLoop`.
+3. **main's DMD sigma table is NOT the one the code appears to prepare.**
+   `DmdDenoisingStage.__init__` hardcodes a fresh internal
+   `FlowMatchEulerDiscreteScheduler(shift=8.0)`; the pipeline scheduler that
+   `TimestepPreparationStage.set_timesteps(n)` configured is never consulted,
+   and the config `flow_shift` is ignored. Lookups run against the 1000-entry
+   warped **init** table: σ(1000)=1.0, σ(757)=0.7567567, σ(522)=0.5217391
+   (confirmed in the capture manifests). `dmd_inference_table` reproduces
+   this exactly; a canary T0 test guards it.
+
+Also confirmed en route: the CPU-generator RNG stream (initial fp32 draw +
+bf16 renoise draws), the fp64 x0 math, and the flash/dense forward at full
+81-frame geometry are each independently bitwise (triage decomposition in
+session evidence).
+
+## Caveats
+
+- Text parity holds for ASCII prompts; main's ftfy cleaning diverges from
+  official's on CJK width-folding (see wan21 report — main measured 4.19e-1
+  vs official on the Chinese negative prompt). FastWan cards reuse the wan21
+  text stage; DMD uses no negative prompt. Add main's clean fn + a CJK golden
+  before serving non-ASCII prompts against these cards.
+- VAE decode is not bitwise-gated (shared component; wan21 anchors cover it);
+  golden videos are in the goldens dirs for SSIM-level comparison.
+- Committed goldens are trimmed (per-step model outputs and the reproducible
+  step-0 input dropped); the full set regenerates via
+  `gates/capture_fastvideo_main.py {qad,vsa}` — one command, pinned config.
+
+## SFWan (self-forcing causal) — added 2026-07-23
+
+`sfwan-t2v-1.3b` (wlsaidhi/SFWan2.1-T2V-1.3B-Diffusers) anchored bitwise on
+the FIRST complete run: all **35/35 chunk-rollout forwards** (7 blocks x
+4 warped DMD steps + context pass) hash-match main's CausalDMDDenosingStage
+exactly, text 0.0, e2e final latents 0.0 (`anchor.sfwan-main` pass).
+
+Causal-specific semantics vendored (each different from BOTH other Wan
+forwards): per-frame temb `[B, T_temb, 6, dim]`; ALL-bf16 modulation (no
+fp32 promotion anywhere); plain bf16 LayerNorms; fp64 RoPE multipliers at
+absolute positions (start_frame offsets); block-causal KV cache
+(21-frame global window, `.detach()` on writes — training rollout reuses
+this same module); cached text cross-attention; warp table =
+SelfForcingFlowMatchScheduler(shift 5, extra_one_step) rows
+`[1000, 937.5, 833.33, 625]` self-indexing their own sigmas.

fastvideo2/evidence/goldens/fastwan-qad-main/manifest.json

@@ -0,0 +1,51 @@
+{
+  "repo": "FastVideo/FastWan-QAD-FP8-1.3B",
+  "snapshot": "3de0eec0e2562923d38a87344127a86a35a3c11d",
+  "fastvideo_commit": "c459a1897899ffcec3be7765534d81000b9bb9c1",
+  "fastvideo_src": "/mnt/FastVideo",
+  "torch": "2.12.0+cu130",
+  "flash_attn": "2.8.3",
+  "python": "3.12.13",
+  "gpu": "NVIDIA GB200",
+  "attention_backend": "FLASH_ATTN",
+  "quant": "FP8 per-tensor (dynamic act, post-load weight quant from bf16)",
+  "vsa_sparsity": null,
+  "seed": 1234,
+  "e2e_prompt": "A curious raccoon peers through a vibrant field of yellow sunflowers, its eyes wide with interest. The playful yet serene atmosphere is complemented by soft natural light filtering through the petals. Mid-shot, warm and cheerful tones.",
+  "probe_prompt": "A cat and a dog baking a cake together in a kitchen.",
+  "probe_timesteps": [
+    1000,
+    757,
+    522
+  ],
+  "probe_latent_bcfhw": [
+    1,
+    16,
+    5,
+    60,
+    104
+  ],
+  "e2e_latent_btchw": [
+    1,
+    21,
+    16,
+    60,
+    104
+  ],
+  "dmd_denoising_steps": [
+    1000,
+    757,
+    522
+  ],
+  "scheduler": {
+    "class": "FlowMatchEulerDiscreteScheduler",
+    "shift": 8.0,
+    "table_len": 1000,
+    "sigma_lookup": {
+      "1000": 1.0,
+      "757": 0.7567567229270935,
+      "522": 0.52173912525177
+    }
+  },
+  "notes": "no compile, no fsdp, single GPU; DmdDenoisingStage's INTERNAL scheduler (hardcoded shift 8.0) is the sigma authority; committed goldens trimmed: e2e_step0 dropped (input is the seeded draw, reproducible) and per-step outputs dropped (triage-only) \u2014 full set regenerable via capture_fastvideo_main.py"
+}

fastvideo2/evidence/goldens/fastwan-vsa-main/manifest.json

@@ -0,0 +1,51 @@
+{
+  "repo": "FastVideo/FastWan2.1-T2V-1.3B-Diffusers",
+  "snapshot": "25e7ed7f41fd8ce2fdd108688c65e8caf0ce3aef",
+  "fastvideo_commit": "c459a1897899ffcec3be7765534d81000b9bb9c1",
+  "fastvideo_src": "/mnt/FastVideo",
+  "torch": "2.12.0+cu130",
+  "flash_attn": "2.8.3",
+  "python": "3.12.13",
+  "gpu": "NVIDIA GB200",
+  "attention_backend": "VIDEO_SPARSE_ATTN",
+  "quant": "none (bf16, VSA sparsity 0.80)",
+  "vsa_sparsity": 0.8,
+  "seed": 1234,
+  "e2e_prompt": "A curious raccoon peers through a vibrant field of yellow sunflowers, its eyes wide with interest. The playful yet serene atmosphere is complemented by soft natural light filtering through the petals. Mid-shot, warm and cheerful tones.",
+  "probe_prompt": "A cat and a dog baking a cake together in a kitchen.",
+  "probe_timesteps": [
+    1000,
+    757,
+    522
+  ],
+  "probe_latent_bcfhw": [
+    1,
+    16,
+    5,
+    60,
+    104
+  ],
+  "e2e_latent_btchw": [
+    1,
+    21,
+    16,
+    60,
+    104
+  ],
+  "dmd_denoising_steps": [
+    1000,
+    757,
+    522
+  ],
+  "scheduler": {
+    "class": "FlowMatchEulerDiscreteScheduler",
+    "shift": 8.0,
+    "table_len": 1000,
+    "sigma_lookup": {
+      "1000": 1.0,
+      "757": 0.7567567229270935,
+      "522": 0.52173912525177
+    }
+  },
+  "notes": "no compile, no fsdp, single GPU; DmdDenoisingStage's INTERNAL scheduler (hardcoded shift 8.0) is the sigma authority; committed goldens trimmed: e2e_step0 dropped (input is the seeded draw, reproducible) and per-step outputs dropped (triage-only) \u2014 full set regenerable via capture_fastvideo_main.py"
+}

fastvideo2/evidence/goldens/sfwan-main/forward_hashes.json

@@ -0,0 +1,282 @@
+[
+ {
+  "x_hash": "03ceb634cfbdc8a5",
+  "out_hash": "658efa11e9a88e87",
+  "t": [
+   1000.0
+  ],
+  "start": 0
+ },
+ {
+  "x_hash": "b986baa8885d6cb9",
+  "out_hash": "dd84656c50a4b92b",
+  "t": [
+   937.5
+  ],
+  "start": 0
+ },
+ {
+  "x_hash": "c08abf4de0fc5fc2",
+  "out_hash": "4001c9596842592d",
+  "t": [
+   833.3333129882812
+  ],
+  "start": 0
+ },
+ {
+  "x_hash": "a27dd2144f6a3c91",
+  "out_hash": "2a0f48499caa3ca5",
+  "t": [
+   625.0
+  ],
+  "start": 0
+ },
+ {
+  "x_hash": "29769211170d71a2",
+  "out_hash": "a4fe211f3fda4514",
+  "t": [
+   0.0
+  ],
+  "start": 0
+ },
+ {
+  "x_hash": "d96a639192b5aa24",
+  "out_hash": "4b1f9dd86d718170",
+  "t": [
+   1000.0
+  ],
+  "start": 4680
+ },
+ {
+  "x_hash": "13c644ac8937ac8e",
+  "out_hash": "d804417cc5fcc794",
+  "t": [
+   937.5
+  ],
+  "start": 4680
+ },
+ {
+  "x_hash": "2a9fd4b8c4362a57",
+  "out_hash": "3f996d20f583eb87",
+  "t": [
+   833.3333129882812
+  ],
+  "start": 4680
+ },
+ {
+  "x_hash": "c0bc578106311f69",
+  "out_hash": "1a2bf4336c45ebc8",
+  "t": [
+   625.0
+  ],
+  "start": 4680
+ },
+ {
+  "x_hash": "cd0c54679935f14d",
+  "out_hash": "3fcda958d74bf79a",
+  "t": [
+   0.0
+  ],
+  "start": 4680
+ },
+ {
+  "x_hash": "cd20f035b46125c5",
+  "out_hash": "9a976bbb313fc9b9",
+  "t": [
+   1000.0
+  ],
+  "start": 9360
+ },
+ {
+  "x_hash": "3332d96e01ae4004",
+  "out_hash": "ddb5cde97146b967",
+  "t": [
+   937.5
+  ],
+  "start": 9360
+ },
+ {
+  "x_hash": "1f02a448f8c27f80",
+  "out_hash": "86a4ac2b3e6624f7",
+  "t": [
+   833.3333129882812
+  ],
+  "start": 9360
+ },
+ {
+  "x_hash": "c34398a75af94118",
+  "out_hash": "e19727744ee978ee",
+  "t": [
+   625.0
+  ],
+  "start": 9360
+ },
+ {
+  "x_hash": "b8229bafed68f655",
+  "out_hash": "8a07b4778c138a91",
+  "t": [
+   0.0
+  ],
+  "start": 9360
+ },
+ {
+  "x_hash": "570ff151d9d1444e",
+  "out_hash": "1a66ace7a1d60b51",
+  "t": [
+   1000.0
+  ],
+  "start": 14040
+ },
+ {
+  "x_hash": "61bd37b3e6382f8b",
+  "out_hash": "6705d1c5591a147b",
+  "t": [
+   937.5
+  ],
+  "start": 14040
+ },
+ {
+  "x_hash": "5aaccd0e0c06d59c",
+  "out_hash": "e43adfb21fa1bc9b",
+  "t": [
+   833.3333129882812
+  ],
+  "start": 14040
+ },
+ {
+  "x_hash": "65de10d92f0d12bd",
+  "out_hash": "800293d62b41f4ae",
+  "t": [
+   625.0
+  ],
+  "start": 14040
+ },
+ {
+  "x_hash": "637bc60ba3c0b7a1",
+  "out_hash": "63fb4744b7d48b10",
+  "t": [
+   0.0
+  ],
+  "start": 14040
+ },
+ {
+  "x_hash": "ca0cccb30274219c",
+  "out_hash": "2fe6ebe902961d57",
+  "t": [
+   1000.0
+  ],
+  "start": 18720
+ },
+ {
+  "x_hash": "d4e78ae4fa1bbc1d",
+  "out_hash": "24694df9ba77685c",
+  "t": [
+   937.5
+  ],
+  "start": 18720
+ },
+ {
+  "x_hash": "2b8ddf173f274fc8",
+  "out_hash": "1156a77610e6dc1b",
+  "t": [
+   833.3333129882812
+  ],
+  "start": 18720
+ },
+ {
+  "x_hash": "6bbd2511192162cc",
+  "out_hash": "dcb87decbf4d126f",
+  "t": [
+   625.0
+  ],
+  "start": 18720
+ },
+ {
+  "x_hash": "b144c64592c830fd",
+  "out_hash": "09b00b37c56dc714",
+  "t": [
+   0.0
+  ],
+  "start": 18720
+ },
+ {
+  "x_hash": "3f11cee5b1830f29",
+  "out_hash": "ac56b4506da4e278",
+  "t": [
+   1000.0
+  ],
+  "start": 23400
+ },
+ {
+  "x_hash": "a7bc9435cd702102",
+  "out_hash": "c238bb0f2fa1b957",
+  "t": [
+   937.5
+  ],
+  "start": 23400
+ },
+ {
+  "x_hash": "6d9a5dcc9af79188",
+  "out_hash": "1b7759348b2e0a06",
+  "t": [
+   833.3333129882812
+  ],
+  "start": 23400
+ },
+ {
+  "x_hash": "42fd32612cfc36b8",
+  "out_hash": "d12e11bb03d918bb",
+  "t": [
+   625.0
+  ],
+  "start": 23400
+ },
+ {
+  "x_hash": "a7583660de097f48",
+  "out_hash": "90473cb353fbb62d",
+  "t": [
+   0.0
+  ],
+  "start": 23400
+ },
+ {
+  "x_hash": "e5c85230c382e2f4",
+  "out_hash": "6ed5d13fa54d6f85",
+  "t": [
+   1000.0
+  ],
+  "start": 28080
+ },
+ {
+  "x_hash": "f60119f243f5bbb2",
+  "out_hash": "52741bbb32a4fa39",
+  "t": [
+   937.5
+  ],
+  "start": 28080
+ },
+ {
+  "x_hash": "c12f401fafe1e333",
+  "out_hash": "a574f69e6525862d",
+  "t": [
+   833.3333129882812
+  ],
+  "start": 28080
+ },
+ {
+  "x_hash": "f68f10bfa7c33eae",
+  "out_hash": "1e2aa2baa76fdfbb",
+  "t": [
+   625.0
+  ],
+  "start": 28080
+ },
+ {
+  "x_hash": "503b0c92faec0367",
+  "out_hash": "21ea40e0d7d642e3",
+  "t": [
+   0.0
+  ],
+  "start": 28080
+ }
+]

fastvideo2/evidence/goldens/sfwan-main/manifest.json

@@ -0,0 +1,23 @@
+{
+  "repo": "wlsaidhi/SFWan2.1-T2V-1.3B-Diffusers",
+  "snapshot": "4b44356635ae5e927ca552a220f768022be76004",
+  "fastvideo_commit": "c459a1897899ffcec3be7765534d81000b9bb9c1",
+  "torch": "2.12.0+cu130",
+  "python": "3.12.13",
+  "gpu": "NVIDIA GB200",
+  "attention_backend": "FLASH_ATTN",
+  "seed": 1234,
+  "e2e_prompt": "A curious raccoon peers through a vibrant field of yellow sunflowers, its eyes wide with interest. The playful yet serene atmosphere is complemented by soft natural light filtering through the petals. Mid-shot, warm and cheerful tones.",
+  "probe_prompt": "A cat and a dog baking a cake together in a kitchen.",
+  "dmd_denoising_steps": [
+    1000,
+    750,
+    500,
+    250
+  ],
+  "warp_denoising_step": true,
+  "scheduler": "SelfForcingFlowMatchScheduler(shift=5, extra_one_step, sigma_min=0)",
+  "num_frames_per_block": 3,
+  "context_noise": 0,
+  "notes": "causal chunk rollout via main's CausalDMDDenosingStage; per-forward hashes for all 35 forwards, full tensors for the first two chunks; no compile/fsdp; FLASH_ATTN"
+}

fastvideo2/evidence/goldens/train-dmd2-main/manifest.json

@@ -0,0 +1,71 @@
+{
+  "fastvideo_commit": "c459a1897899ffcec3be7765534d81000b9bb9c1",
+  "mode": "dmd2",
+  "seed": 42,
+  "gen_losses": [
+    0.0,
+    0.33539342880249023,
+    0.0,
+    0.31753748655319214,
+    0.0
+  ],
+  "fake_losses": [
+    0.003410761244595051,
+    0.00596819119527936,
+    0.013151273131370544,
+    0.022480690851807594,
+    0.0037461533211171627
+  ],
+  "torch": "2.12.0+cu130",
+  "gpu": "NVIDIA GB200",
+  "config": "dmd2 legacy: interval2 gw3.5 lr2e-6 shift8 steps[1000,757,522] simulate nlt4 1gpu",
+  "self_noise_runs": {
+    "gen": [
+      [
+        0.0,
+        0.3357574939727783,
+        0.0,
+        0.3176053762435913,
+        0.0
+      ],
+      [
+        0.0,
+        0.33570683002471924,
+        0.0,
+        0.3168887794017792,
+        0.0
+      ],
+      [
+        0.0,
+        0.33539342880249023,
+        0.0,
+        0.31753748655319214,
+        0.0
+      ]
+    ],
+    "fake": [
+      [
+        0.003410761244595051,
+        0.0059582265093922615,
+        0.013146793469786644,
+        0.022459683939814568,
+        0.0037503200583159924
+      ],
+      [
+        0.003410761244595051,
+        0.005963137373328209,
+        0.013137918896973133,
+        0.022351054474711418,
+        0.0037392042577266693
+      ],
+      [
+        0.003410761244595051,
+        0.00596819119527936,
+        0.013151273131370544,
+        0.022480690851807594,
+        0.0037461533211171627
+      ]
+    ]
+  },
+  "self_noise_max": 0.0007165968418121338
+}

fastvideo2/evidence/goldens/train-dmd2-main/steps.json

@@ -0,0 +1,54 @@
+[
+ {
+  "targets": [
+   2
+  ],
+  "dmd_t": null,
+  "critic_t": 737.588623046875,
+  "gen_loss": 0.0,
+  "fake_loss": 0.003410761244595051,
+  "x0_student_hash": "96f01be58584097b"
+ },
+ {
+  "targets": [
+   1,
+   0
+  ],
+  "dmd_t": 386.4990234375,
+  "critic_t": 716.4179077148438,
+  "gen_loss": 0.33539342880249023,
+  "fake_loss": 0.00596819119527936,
+  "x0_student_hash": "34f51407f1b630e5"
+ },
+ {
+  "targets": [
+   2
+  ],
+  "dmd_t": null,
+  "critic_t": 967.0870971679688,
+  "gen_loss": 0.0,
+  "fake_loss": 0.013151273131370544,
+  "x0_student_hash": "2d65be80d333fd5d"
+ },
+ {
+  "targets": [
+   0,
+   1
+  ],
+  "dmd_t": 662.4631958007812,
+  "critic_t": 980.0,
+  "gen_loss": 0.31753748655319214,
+  "fake_loss": 0.022480690851807594,
+  "x0_student_hash": "822e22773ec52d1e"
+ },
+ {
+  "targets": [
+   2
+  ],
+  "dmd_t": null,
+  "critic_t": 456.45648193359375,
+  "gen_loss": 0.0,
+  "fake_loss": 0.0037461533211171627,
+  "x0_student_hash": "472a8020d513b4ea"
+ }
+]

fastvideo2/evidence/goldens/train-finetune-main/manifest.json

@@ -0,0 +1,41 @@
+{
+  "fastvideo_commit": "c459a1897899ffcec3be7765534d81000b9bb9c1",
+  "dataset": "wlsaidhi/crush-smol_processed_t2v",
+  "seed": 42,
+  "steps": 5,
+  "num_latent_t": 8,
+  "config": "1gpu bs1 accum1 lr5e-5 wd1e-4 betas(0.9,0.999) clip1.0 uniform-t cfg_rate0 dit_fp32 mixed_bf16 flow-match target=noise-latents flash_attn",
+  "torch": "2.12.0+cu130",
+  "gpu": "NVIDIA GB200",
+  "losses": [
+    0.1940414160490036,
+    0.94484943151474,
+    0.1001732274889946,
+    0.9069435000419617,
+    0.10525074601173401
+  ],
+  "self_noise_runs": [
+    [
+      0.1940414160490036,
+      0.9445295333862305,
+      0.10048552602529526,
+      0.9095064997673035,
+      0.10758557915687561
+    ],
+    [
+      0.1940414160490036,
+      0.9446913599967957,
+      0.10070198774337769,
+      0.9106038808822632,
+      0.10818696022033691
+    ],
+    [
+      0.1940414160490036,
+      0.94484943151474,
+      0.1001732274889946,
+      0.9069435000419617,
+      0.10525074601173401
+    ]
+  ],
+  "self_noise_max": 0.0036603808403015137
+}

fastvideo2/evidence/goldens/train-finetune-main/steps.json

@@ -0,0 +1,82 @@
+[
+ {
+  "caption": "A large metal cylinder is seen pressing down on a pile of colorful candies, flattening them as if they were under a hydraulic press. The candies are crushed and broken into small pieces, creating a mess on the table.",
+  "latents_hash": "93ae01bc47c0817b",
+  "embeds_hash": "53f384dfed477e28",
+  "noise_hash": "e1f135db4ff97ff8",
+  "noisy_hash": "6a0cabf3c2e98794",
+  "timesteps": [
+   118.0
+  ],
+  "sigmas": [
+   0.1181640625
+  ],
+  "pred_hash": "2903c217cc9279df",
+  "loss": 0.1940414160490036,
+  "grad_norm": 0.23514027893543243
+ },
+ {
+  "caption": "The video shows a colorful sponge being flattened as if it were under a hydraulic press, with the sponge being compressed and eventually flattened into a thin layer.",
+  "latents_hash": "b9d5abc838e815da",
+  "embeds_hash": "82c3f45fec89f678",
+  "noise_hash": "ea2e0427b4584180",
+  "noisy_hash": "5ff0bac18dd8e80e",
+  "timesteps": [
+   85.0
+  ],
+  "sigmas": [
+   0.0849609375
+  ],
+  "pred_hash": "688def082dcbfa60",
+  "loss": 0.94484943151474,
+  "grad_norm": 10.1902437210083
+ },
+ {
+  "caption": "The video shows a hydraulic press in action, flattening objects as if they were under a hydraulic press. The press is composed of a large, cylindrical metal cylinder with yellow and black stripes, and a metal base. The objects being flattened are two cylindrical blocks of cotton candy, one pink and one blue. The press is positioned on a metal table, and the background features a green wall with a yellow and red sign.",
+  "latents_hash": "840ddc5d78da4b7b",
+  "embeds_hash": "ffce0c1bf664fb3d",
+  "noise_hash": "2f512661cebc8a51",
+  "noisy_hash": "05b1746f31f8d83d",
+  "timesteps": [
+   618.0
+  ],
+  "sigmas": [
+   0.6171875
+  ],
+  "pred_hash": "963b9731aafbe2ea",
+  "loss": 0.1001732274889946,
+  "grad_norm": 0.523212730884552
+ },
+ {
+  "caption": "A watermelon wearing a helmet is crushed by a hydraulic press, causing it to flatten and burst open.",
+  "latents_hash": "c5d8005785df08ab",
+  "embeds_hash": "88eea058d58c26f7",
+  "noise_hash": "1022b2e68b615e5f",
+  "noisy_hash": "ee1750fb9fdb7094",
+  "timesteps": [
+   41.0
+  ],
+  "sigmas": [
+   0.041015625
+  ],
+  "pred_hash": "5fd1a77f3716b63b",
+  "loss": 0.9069435000419617,
+  "grad_norm": 3.6921098232269287
+ },
+ {
+  "caption": "The video shows a large, industrial press flattening objects as if they were under a hydraulic press. The press is shown in action, compressing a pile of pink objects into a pile of crumbs. The press is large and metallic, with a yellow and black striped pattern on its side. The background is a green wall with a yellow warning sign.",
+  "latents_hash": "57045eb31ae1e81a",
+  "embeds_hash": "71cee36d5ca3083d",
+  "noise_hash": "cdc1cbc4a1fed9ac",
+  "noisy_hash": "53ada1e537af47ac",
+  "timesteps": [
+   610.0
+  ],
+  "sigmas": [
+   0.609375
+  ],
+  "pred_hash": "315edc5acc47767a",
+  "loss": 0.10525074601173401,
+  "grad_norm": 0.9913093447685242
+ }
+]

fastvideo2/evidence/goldens/train-qad-main/manifest.json

@@ -0,0 +1,22 @@
+{
+  "fastvideo_commit": "c459a1897899ffcec3be7765534d81000b9bb9c1",
+  "mode": "qad",
+  "seed": 42,
+  "gen_losses": [
+    0.0,
+    0.1784808486700058,
+    0.0,
+    0.17068849503993988,
+    0.0
+  ],
+  "fake_losses": [
+    0.0031898675952106714,
+    0.005877670831978321,
+    0.015015869401395321,
+    0.023572081699967384,
+    0.0025676116347312927
+  ],
+  "torch": "2.12.0+cu130",
+  "gpu": "NVIDIA GB200",
+  "config": "dmd2 legacy: interval2 gw3.5 lr2e-6 shift8 steps[1000,757,522] simulate nlt4 1gpu"
+}