Prism

Prism:Dynamic Sparse Attention for Native 2K Joint Video-Audio Generation Model Training
Shuyuan Tu¹, Qi Tian², Yinming Huang¹, Yue Wu², Xintong Han², Kaihang Pan³, Weijie Kong², Jiangfeng Xiong², Jian-Wei Zhang², Zuxuan Wu¹, Yu-Gang Jiang¹
[¹Fudan University; ²Tencent Hunyuan; ³Zhejiang University]

Overview

The overview of the framework of Prism.

Native training joint video-audio generation models at higher resolutions empowers them to learn richer visual details and sharper motion dynamics. However, full attention incurs quadratic cost and, as resolution increases, spreads attention over increasingly redundant tokens, diluting learning signals for informative content and disrupting pretrained priors. Existing sparse attention methods either target training-free acceleration or overlook the unique structure of joint video-audio data, where cross-modal interactions are inherently concentrated around sound-producing regions. To address this, we propose Prism, a dynamic sparse attention framework for natively training joint video-audio generation models at 2K. In particular, Prism organizes the token sequence into spatiotemporal macro-zones, enabling the attention structure to adapt to local content. For each zone, it estimates local information structure via video feature variance along the channel and feature norms from the audio-to-video cross-attention, jointly capturing how visual content varies directionally and how strongly audio influences each visual region. Based on these signals, Prism dynamically assigns a tailored block shape to each zone, applying finer partitioning along axes of rapid visual content variation and strong audio-visual coupling. This encourages tokens within each block to remain semantically coherent, allowing block-level features to capture both visual content and joint video-audio interaction patterns. Prism further adopts a hybrid block selection strategy to dynamically determine per-query sparsity. Experiments show that Prism achieves 2.5$\times$ training speedup compared to full attention, while surpassing it in generation quality.

News

• [2026-x-xx]: The project page, training/inference code, technical report anda preview model checkpoint are released. Stay tuned!

To-Do List

• [x] Prism-preview-alpha (stable)
• [x] Prism-preview-beta (motion)
• [x] Data Pre-Processing Code (Latent Extraction and Latent Decode)
• [x] Training Code
• [x] Full Finetuning Code
• [x] Inference Code
• [ ] Prism-pro

Quickstart

The Preview Model supports native joint video-audio generation at 720p, 1080p, and 2K resolutions, as well as native joint video-audio training at these resolutions.

Environment Setup

Prerequisites. Prism requires Python ≥ 3.10, CUDA ≥ 12.4, and a system-level ffmpeg installation.

# 1 — Install PyTorch (CUDA 12.4)
pip install torch==2.7.1 torchvision==0.22.1 torchaudio==2.7.1 --index-url https://download.pytorch.org/whl/cu124
# 2 — Install core dependencies
pip install -r requirements.txt
# 3 — Install FlashAttention (requires CUDA)
pip install flash-attn --no-build-isolation
# 4 — Install `ffmpeg` (system-level)
sudo apt-get install ffmpeg
# 5 — Verify the installation
python -c "
import torch, diffusers, transformers, flash_attn, triton
from audiotools import AudioSignal
from decord import VideoReader
print(f'torch {torch.__version__}')
print(f'diffusers {diffusers.__version__}')
print(f'transformers {transformers.__version__}')
print(f'flash_attn {flash_attn.__version__}')
print(f'triton {triton.__version__}')
print('All imports OK ')"

(Multi-node only) Quick cluster-wide install via pdsh

If you are running on a multi-node cluster, the following one-liner installs the key packages across all nodes in parallel:

export node_ip=$(echo ${NODE_IP_LIST} | sed 's/:8//g')
pdsh -f 256 -w $node_ip "pip install ipdb yunchang mmengine"
pdsh -f 256 -w $node_ip "pip uninstall diffusers -y && pip install diffusers==0.33.0"
pdsh -f 256 -w $node_ip "pip install descript-audiotools"
pdsh -f 256 -w $node_ip "pip install imageio[ffmpeg] imageio[pyav]"
pdsh -f 256 -w $node_ip "pip install decord"
pdsh -f 256 -w $node_ip "pip install flash-attn --no-build-isolation"

Download Weights

If you encounter connection issues with Hugging Face, you can utilize the mirror endpoint by setting the environment variable: export HF_ENDPOINT=https://hf-mirror.com. Please download weights manually as follows:

pip install "huggingface_hub[cli]"
cd Prism
mkdir checkpoints
huggingface-cli download FrancisRing/Prism --local-dir ./checkpoints

All the weights should be organized as follows. The overall file structure of this project should be organized as follows:

Prism/
├── configs/
├── hymm/
├── scripts/
├── tools/
├── checkpoints/
│   ├── pretrained_models/
│   │   └── MOVA-360p/          # base MOVA pretrained model
│   ├── preview_alpha/          # Prism-preview-alpha weights
│   │   └── diffusion_pytorch_model.safetensors
│   └── preview_beta/           # Prism-preview-beta weights
│       └── diffusion_pytorch_model.safetensors
├── mova_infer.sh
├── mova_infer_fsdp.sh
├── requirements.txt
└── README.md

Training Dataset Preparation

Training reads a plain CSV file (one row per clip). The row details are depicted as follows:

† When latent_frames/latent_height/latent_width are present in the CSV, they take priority for bucketing and num_frames/height/width become optional. fps defaults to dataloader_config.video_fps (24) when absent. We recommend always including all four columns (num_frames, height, width, fps) for clarity.

caption keeps the structured format, so the existing sampling ratios in video_caption_sample_ratio still control which fields get assembled into the prompt:

{"style_features": "...", "content_summary": "...", "background_audio": "...",
 "shots": [{"time_range": ["0", "9.0"], "static_description": "...", "dynamic_description": "..."}]}

Step 1 — Extract WAN VAE latents (offline, once per video):

python hymm/wan_vae_latent_extraction.py \
    --input_csv /path/i2va_raw.csv \
    --output_dir /path/latents \
    --model_path /path/checkpoints/pretrained_models/MOVA-360p/video_vae \
    --sample_n_frames 289 --fps 24

Step 2 — Assign multi-resolution and multi-duration buckets (offline):

The temporal bucket range must match the training config. The three resolution configs use:

# 720p
python tools/build_dataset_csv.py \
    --input  /path/i2va_raw.csv \
    --output /path/i2va_720p.csv \
    --latent-resolution 720p \
    --temporal-min-length 49 --temporal-max-length 289 --temporal-interval 12 \
    --scan-latents --workers 32

# 1080p
python tools/build_dataset_csv.py \
    --input  /path/i2va_raw.csv \
    --output /path/i2va_1080p.csv \
    --latent-resolution 1080p \
    --temporal-min-length 49 --temporal-max-length 289 --temporal-interval 12 \
    --scan-latents --workers 32

# 2k (note: temporal-max-length is 265)
python tools/build_dataset_csv.py \
    --input  /path/i2va_raw.csv \
    --output /path/i2va_2k.csv \
    --latent-resolution 2k \
    --temporal-min-length 49 --temporal-max-length 265 --temporal-interval 12 \
    --scan-latents --workers 32

--scan-latents fills latent_frames/height/width from the .npy headers, and the tool prints the per-bucket histogram so you can see how batches will fill before launching. The bucket columns are optional. The dataset derives them on the fly when they are missing, using the same bucket_* settings from the config.

Preview Model Inference

Prism provides two inference scripts: prism_infer.sh for single-GPU or DeepSpeed-based multi-GPU inference, and prism_infer_fsdp.sh for FSDP-based multi-GPU inference that shards model parameters across GPUs (recommended for 1080p and 2K).

# Single-GPU / DeepSpeed multi-GPU inference (720p recommended)
bash prism_infer.sh

# FSDP multi-GPU inference (1080p / 2K recommended)
bash prism_infer_fsdp.sh

Before running, edit the shell script to set your own paths and generation settings. The core parameters are:

Tip: mova_infer.sh uses --deepspeed launch and is suited for 720p on a single 80 GB GPU (with --offload cpu). mova_infer_fsdp.sh uses torchrun with FSDP FULL_SHARD and is recommended for 1080p / 2K on 4+ GPUs, as it shards parameters across all GPUs rather than replicating the full model.

Notably, for your convenience, we provide several ready-to-infer cases in theassets/ti2va_casesfolder. Feel free to try them out and have fun!

Native Joint Video-Audio Training at High-Resolution

Prism supports native joint video-audio training at 720p, 1080p, and 2K resolutions. The training pipeline uses FSDP and sequence parallelism via torchrun + pdsh, controlled by a two-level config system: a top-level YAML (configs/train/wan_ti2va.yaml) that holds per-resolution experiment entries (optimizer, block sparse attention flags, etc.) and a per-resolution inject-config YAML (configs/train/t2va_config/wan_15B_ti2va_*_init_top_k_p.yaml) that specifies the pretrained model path, loss weights, and all dataloader settings.

Regarding the bucketed CSV files from step2 in Training Dataset Preparation, they are the sole data manifest consumed by the trainer. Each inject-config YAML has adataloader_config.video_csv_file field. This is where you place your CSV path. For example, the 720p inject config (configs/train/t2va_config/wan_15B_ti2va_720p_init_top_k_p.yaml) contains:

dataloader_config:
  video_csv_file:
  - /path/to/your/i2va_720p.csv      # ← put your bucketed CSV path here

Replace the path with the actual location of the CSV produced by tools/build_dataset_csv.py. The 1080p and 2K inject configs follow the same pattern — update video_csv_file in configs/train/t2va_config/wan_15B_ti2va_1080p_init_top_k_p.yaml and configs/train/t2va_config/wan_15B_ti2va_2k_init_top_k_p.yaml respectively. You may also specify multiple CSV files as a list under video_csv_file to merge several datasets. At training launch, the script reads the inject_config path from the top-level YAML, loads the inject-config, and passes video_csv_file to CsvVideoAudioDataset. The dataset reads every row, derives or looks up the (bucket_frames, bucket_height, bucket_width) assignment, and groups all samples by bucket key. A DistributedBucketBatchSampler then draws each mini-batch from a single bucket so every sample in the batch shares the exact same tensor shape, avoiding shape mismatches across data-parallel ranks. The multi-resolution spatial buckets are generated by enumerating all (H, W) crops whose patch count equals (base_size / patch_size)², and each sample is matched to the bucket with the closest aspect ratio; the multi-duration temporal buckets are a series of frame counts of the form 4k + 1 from temporal_min_length to temporal_max_length at stride temporal_interval, and each sample is assigned to the largest temporal bucket that fits.

Launch training at each resolution with:

# 720p native joint video-audio training
bash scripts/pretrain/pdsh_train.sh "scripts/pretrain/train_wan_ti2va.sh configs/train/wan_ti2va.yaml wan_15B_ti2va_720p_init_top_k_p"

# 1080p native joint video-audio training
bash scripts/pretrain/pdsh_train.sh "scripts/pretrain/train_wan_ti2va.sh configs/train/wan_ti2va.yaml wan_15B_ti2va_1080p_init_top_k_p"

# 2K native joint video-audio training
bash scripts/pretrain/pdsh_train.sh "scripts/pretrain/train_wan_ti2va.sh configs/train/wan_ti2va.yaml wan_15B_ti2va_2k_init_top_k_p"

pdsh_train.sh is the inner script across all nodes listed in $NODE_IP_LIST via pdsh. On each node, train_wan_ti2va.sh parses the named config from the top-level YAML, extracts every flag, then launches torchrun with hymm/train_t2va_wan.py.

Core training parameters. The training configuration is split across two YAML files. Parameters in the top-level config (configs/train/wan_ti2va.yaml) control the optimizer, parallelism, checkpointing, and Prism sparse-attention behaviour. Parameters in the inject config (configs/train/t2va_config/wan_15B_ti2va_*_init_top_k_p.yaml) control the pretrained model, loss weighting, noise schedule, and dataloader.

Top-level config (configs/train/wan_ti2va.yaml):

Inject config (configs/train/t2va_config/wan_15B_ti2va_*_init_top_k_p.yaml):

VRAM Requirement

For native high-resolution training, 720p requires at least 32 × NVIDIA 80 GB GPUs (e.g. A100 or H100), and 1080p / 2K each require at least 64 × NVIDIA 80 GB GPUs. For inference, 720p can run on a single NVIDIA 80 GB GPU, while 1080p and 2K each require 4 or more NVIDIA 80 GB GPUs.

Contact

If you have any suggestions or find our work helpful, feel free to contact me.

Email: [email protected]

If you find our work useful, please consider giving a star to this github repository and citing it:

@article{tu2026prism,
  title={Prism:Dynamic Sparse Attention for Native 2K Joint Video-Audio Generation Model Training},
  author={Tu, Shuyuan and Tian, Qi and Huang, Yinming and Wu, Yue and Han, Xintong and Pan, Kaihang and Kong, Weijie and Xiong, Jiangfeng and Zhang, Jian-Wei and Wu, Zuxuan and Jiang, Yu-Gang},
  journal={arXiv preprint arXiv:},
  year={2026}
}