Files
hao-ai-lab-FastVideo/examples/inference/basic
SolitaryThinker 620e100af4 [feat] magi-human: SR-1080p with block-sparse local-window attention
Ports the daVinci-MagiHuman SR-1080p inference flow to FastVideo. Builds
on the SR-540p two-stage pipeline plus block-sparse local-window
video->video attention on 32 of 40 SR DiT layers. Mirrors upstream
SR2_1080 config override at inference/common/config.py:225-244 and
calc_local_qk_range at inference/pipeline/data_proxy.py:31-79.

Files added:
  * tests/local_tests/magi_human/test_magi_human_sr1080p_pipeline_parity.py:
    parametric parity test for both T2V and TI2V modes. Both pass
    diff_max=0.0000 / diff_mean=0.0000 -- BIT-EXACT.

Files modified (key changes):
  * fastvideo/models/dits/magi_human.py:
    - AttentionSubConfig.use_local_attn / frame_receptive_field
    - MagiAttention.configure_local_attention(): per-layer toggle
    - MagiAttention._sdpa(): thin SDPA wrapper for [L,H,D] tensors
    - MagiAttention._local_window_attention(): 3-block accumulator
      mirroring upstream FFA semantics with vanilla SDPA segments
      (per-frame video window + all video->audio+text + audio+text->all).
    - MagiAttention.forward() dispatches to _local_window_attention
      when use_local_attn flag is set.
    - MagiTransformerLayer wires use_local_attn from arch.local_attn_layers.
    - MagiHumanDiT.configure_local_attention() top-level toggle.
  * pipeline_configs.py: MagiHumanSR1080pConfig + I2V variant with
    sr_local_attn_layers populated to upstream's 32 indices.
  * presets.py: MAGI_HUMAN_SR_1080P + MAGI_HUMAN_SR_1080P_TI2V presets.
  * registry.py: SR-1080p config entries with detectors.
  * magi_human_pipeline.py: SR-1080p pipeline classes activating
    local_attn_layers on the SR DiT at construction.
  * scripts/checkpoint_conversion/convert_magi_human_to_diffusers.py:
    --sr-subfolder 1080p_sr support.
  * tests/local_tests/helpers/magi_human_upstream.py: arch override
    support for SR-1080p parity test.
  * test_magi_human_pipeline_smoke.py: preset set expanded.
  * basic_magi_human_sr1080p{,_ti2v}.py: stubs -> runnable.

Verification:
  * pytest tests/local_tests/magi_human/ -v -s: 14 passed, 0 failed.
    All bit-exact including SR-1080p T2V and TI2V parity. The
    block-sparse SDPA-segmented implementation matches upstream FFA's
    q_ranges/k_ranges accumulator semantics exactly for the 3-block
    layout (overlap accumulation handled by explicit '+' at
    magi_human.py:421-425).
  * basic_magi_human.py (T2V regression check): mp4 byte-identical
    md5 dcf5f2bf6534c7c0d91e7353e42b23db.
  * Base/Distill/TI2V/SR-540p flows untouched.

Notes:
  * Converted SR-1080p artifact at /raid/.../magi_human_sr_1080p
    (~58 GB), symlinked at converted_weights/magi_human_sr_1080p
    (gitignored).
  * Upstream's flex_flash_attn_func via SandAI-org/MagiAttention is
    NOT a dependency; FV's pure-SDPA segmented implementation is
    mathematically equivalent for this 3-block layout.
2026-05-05 10:55:49 -07:00
..
2026-02-21 16:06:55 -08:00

Basic Video Generation Tutorial

The VideoGenerator class provides the primary Python interface for doing offline video generation, which is interacting with a diffusion pipeline without using a separate inference api server.

Requirements

  • At least a single NVIDIA GPU with CUDA 12.4.
  • Python 3.10-3.12

Installation

If you have not installed FastVideo, please following these instructions first.

Usage

The first script in this example shows the most basic usage of FastVideo. If you are new to Python and FastVideo, you should start here.

# if you have not cloned the directory:
git clone https://github.com/hao-ai-lab/FastVideo.git && cd FastVideo

python examples/inference/basic/basic.py

For an example on Apple silicon:

python examples/inference/basic/basic_mps.py

For an example running DMD+VSA inference:

python examples/inference/basic/basic_dmd.py

For the typed config/request path added during the inference API refactor:

python examples/inference/basic/basic_dmd_new_api.py

Basic Walkthrough

All you need to generate videos using multi-gpus from state-of-the-art diffusion pipelines is the following few lines!

from fastvideo import VideoGenerator

def main():
    generator = VideoGenerator.from_pretrained(
        "Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
        num_gpus=1,
    )

    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.")
    video = generator.generate_video(prompt)

if __name__ == "__main__":
    main()