WAN 2.1 I2V 720p FP8 - High-Resolution Image-to-Video Model
This repository contains the WAN (Wan An) 2.1 Image-to-Video 720p model in FP8 E4M3FN precision for high-resolution video generation from static images. The FP8 quantization provides approximately 50% memory savings compared to FP16 while maintaining high-quality video output.
Model Description
WAN 2.1 I2V 720p FP8 is a 14-billion parameter transformer-based image-to-video model optimized for generating 720p resolution videos from input images. The FP8 E4M3FN quantization format reduces model size and VRAM requirements while preserving generation quality, making it suitable for deployment on consumer GPUs with 24GB+ VRAM.
Key Capabilities:
Generate 720p resolution videos from static images
Support for camera control LoRAs (rotation, arc shots, drone perspectives)
FP8 quantization for efficient inference (~40% VRAM savings vs FP16)
Compatible with diffusers library and standard image-to-video workflows
Architecture: Transformer-based image-to-video diffusion model
Format: SafeTensors (secure, efficient)
Hardware Requirements
VRAM: 24GB+ recommended for 720p generation
Minimum: 20GB with optimizations (gradient checkpointing, attention slicing)
Recommended: RTX 4090 (24GB), RTX A5000 (24GB), or higher
Disk Space: 16 GB for model file
System RAM: 32GB+ recommended for optimal performance
GPU: NVIDIA GPU with FP8 tensor support preferred
Best performance: Ada Lovelace (RTX 40 series) or Hopper architecture
Compatible: Ampere (RTX 30 series) with automatic FP16 fallback
Operating System: Windows 10/11, Linux (Ubuntu 20.04+)
FP8 Performance Benefits
VRAM Usage: ~40% reduction compared to FP16 variant
Inference Speed: Up to 1.5-2x faster on FP8-capable GPUs (RTX 40 series)
Model Size: 50% smaller than FP16 (16GB vs 32GB)
Quality: >95% generation quality preservation vs FP16
Usage
Basic Image-to-Video Generation
python
1from diffusers import DiffusionPipeline
2import torch
3from PIL import Image
45# Load the WAN 2.1 I2V 720p FP8 model6pipe = DiffusionPipeline.from_single_file(7"E:/huggingface/wan21-fp8-720p/diffusion_models/wan/wan21-i2v-720p-14b-fp8-e4m3fn.safetensors",8 torch_dtype=torch.float8_e4m3fn,# FP8 precision9 use_safetensors=True10)1112pipe.to("cuda")1314# Load input image15input_image = Image.open("path/to/your/image.jpg")1617# Generate 720p video from image18video_frames = pipe(19 image=input_image,20 prompt="smooth camera movement, cinematic lighting",21 num_frames=24,22 num_inference_steps=50,23 guidance_scale=7.5,24 height=720,25 width=128026).frames[0]2728# Save video29from diffusers.utils import export_to_video
30export_to_video(video_frames,"output_720p.mp4", fps=8)
Memory-Optimized Generation
python
1# Enable memory optimizations for 20GB VRAM GPUs2pipe.enable_attention_slicing()3pipe.enable_vae_slicing()45# Optional: Enable gradient checkpointing (slower but uses less memory)6# pipe.unet.enable_gradient_checkpointing()78# Generate with reduced memory footprint9video_frames = pipe(10 image=input_image,11 prompt="your prompt here",12 num_frames=16,# Reduce frames for lower memory usage13 num_inference_steps=30,# Reduce steps for faster generation14 guidance_scale=7.515).frames[0]
Integration with Camera Control LoRAs
This model is compatible with WAN 2.1 camera control LoRAs (sold/distributed separately):
python
1# Load camera control LoRA (example - requires separate LoRA file)2pipe.load_lora_weights(3"path/to/wan21-camera-rotation-rank16-v1.safetensors"4)56# Generate with camera control7video_frames = pipe(8 image=input_image,9 prompt="rotating camera around the subject, 720p quality",10 num_frames=24,11 num_inference_steps=50,12 guidance_scale=7.513).frames[0]
Compatible LoRAs:
wan21-camera-rotation-rank16-v1.safetensors - Orbital camera movements
GPU Selection: Best performance on RTX 4090, RTX 4080, or newer GPUs with native FP8 support
Memory Optimization: Enable attention slicing and VAE slicing for 20-22GB VRAM GPUs
Batch Size: Generate single videos sequentially to avoid VRAM exhaustion
Frame Count: Start with 16-24 frames, increase if VRAM permits
Inference Steps: 30-50 steps provide good quality; higher steps improve quality marginally
Guidance Scale: 7.0-8.5 works well; adjust based on prompt strength needed
Mixed Precision: Model automatically falls back to FP16 on non-FP8 GPUs (VRAM usage increases)
Resolution: This is the 720p variant - use 480p model for lower VRAM requirements
Installation
Prerequisites
bash
1# Python 3.8 or higher2python --version
34# CUDA 11.8 or higher (for NVIDIA GPUs)5nvcc --version
Install Dependencies
bash
1# Install PyTorch with CUDA support (adjust CUDA version as needed)2pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
34# Install diffusers and dependencies5pip install diffusers transformers accelerate safetensors
67# Optional: Install xformers for memory-efficient attention8pip install xformers
Recommendation: Use FP8 for production deployment and efficient inference. Use FP16 only if you have 40GB+ VRAM and need maximum quality for research purposes.
License
This model is released under a custom WAN license. Please review the license terms before use:
Commercial Use: Check official WAN license documentation
Research Use: Generally permitted with attribution
Redistribution: May have restrictions - consult license
Ethical Use: Follow ethical AI guidelines and avoid generating harmful content
License Name: wan-license
License Type: other (proprietary/custom)
For detailed license information, refer to the official WAN model documentation.
Citation
If you use this model in your research or projects, please cite:
bibtex
1@software{wan21_i2v_720p_fp8,
2 title={WAN 2.1 Image-to-Video 720p FP8: High-Resolution Video Generation},
3 author={WAN Development Team},
4 year={2024},
5 note={FP8 quantized 14B parameter image-to-video diffusion model for 720p generation},
6 url={https://huggingface.co/models}
7}
Troubleshooting
Out of Memory Errors
python
1# Enable all memory optimizations2pipe.enable_attention_slicing(slice_size=1)3pipe.enable_vae_slicing()4pipe.enable_model_cpu_offload()# Offload to CPU when not in use56# Reduce generation parameters7num_frames =16# Instead of 248num_inference_steps =30# Instead of 50
Slow Generation Speed
Ensure FP8 support: Check GPU architecture (RTX 40 series recommended)
Install xformers: pip install xformers for optimized attention
Check PyTorch version: PyTorch 2.1+ required for FP8 support
Quality Issues
Increase inference steps: 50+ steps for better quality
Adjust guidance scale: Try 7.0-8.5 range
Check input image quality: Higher quality inputs produce better outputs
Verify model integrity: Ensure complete download (16GB exactly)
Related Resources
WAN 2.1 I2V 480p FP8 - Lower resolution variant for faster generation
WAN 2.1 I2V FP16 - Full precision models for maximum quality
WAN 2.2 Models - Next generation with enhanced controls
WAN Camera Control LoRAs - Additional camera movement capabilities
Official Documentation - Complete usage guides and API reference
Model Card Contact
For questions, issues, or feedback about the WAN 2.1 I2V 720p FP8 model:
Official Website: Check WAN model official documentation
Community Forum: Hugging Face model discussions
Technical Issues: Report through official channels
Research Inquiries: Contact WAN development team
Changelog
v1.0 (Current)
Initial release of WAN 2.1 I2V 720p FP8 model
14B parameter transformer architecture
FP8 E4M3FN quantization for efficiency
720p resolution support
Compatible with camera control LoRAs
SafeTensors format for security and efficiency
Version: v1.0
Last Updated: 2024-10
Model Type: Image-to-Video Diffusion Model
Resolution: 720p (1280x720)
Precision: FP8 E4M3FN
Size: 16 GB
Note: This is a quantized model optimized for efficient deployment on consumer GPUs. For maximum quality requirements, consider the FP16 variant. Please use responsibly and follow ethical AI guidelines.
