Hugging Face's logo

wangkanai
/
wan25-fp8-i2v-loras-nsfw

Text-to-Video
Diffusers
wan
image-to-video
video-generation
lora
Not-For-All-Audiences
Model card Files
xet
Community

WAN 2.5 FP8 Image-to-Video LoRAs (NSFW Collection)

Status: Repository initialized - Empty structure (no model files present)

High-quality LoRA adapters for the WAN (World Action Network) 2.5 image-to-video generation model, optimized in FP8 precision for enhanced performance and memory efficiency. This collection focuses on specialized enhancements including camera control, lighting adjustment, motion dynamics, and quality improvements for image-to-video synthesis.

⚠️ Content Warning: This repository is intended to contain NSFW (Not Safe For Work) content. Models may generate adult or sensitive content. Use responsibly and in accordance with applicable laws and regulations.

Model Description

WAN LoRAs are lightweight adapter models that enhance the base WAN image-to-video generation model with specialized capabilities:

  • Camera Control LoRAs: Precise control over camera movements, angles, and perspectives in generated videos
  • Motion Dynamics LoRAs: Enhanced movement quality, temporal consistency, and animation smoothness
  • Lighting LoRAs: Advanced lighting effects, mood control, and atmospheric enhancements
  • Quality Enhancement LoRAs: Improved detail, consistency, and visual fidelity in video outputs
  • FP8 Optimization: 8-bit floating point precision for faster inference with minimal quality loss

These LoRAs can be combined and weighted to achieve specific artistic and technical goals in image-to-video generation workflows.

Repository Contents

Current Structure 

wan25-fp8-i2v-loras-nsfw/
├── README.md              # This documentation file (12 KB)
├── .cache/                # Hugging Face cache directory
│   └── huggingface/
│       └── upload/        # Upload metadata
└── loras/                 # LoRA model storage (empty - awaiting models)
    └── wan/               # WAN-specific LoRAs subdirectory (empty)

Current Repository Size: ~12 KB (documentation only)

Expected Model Files

When populated, this repository will contain:

File Pattern Purpose Typical Size Status
camera_*.safetensors Camera control LoRAs 50-200 MB Pending
motion_*.safetensors Motion dynamics LoRAs 50-200 MB Pending
lighting_*.safetensors Lighting enhancement LoRAs 50-200 MB Pending
quality_*.safetensors Quality improvement LoRAs 50-200 MB Pending
style_*.safetensors Style-specific LoRAs 50-200 MB Pending

Total Repository Size (when populated): ~500 MB - 2 GB (estimated)

Hardware Requirements

Minimum Requirements

  • VRAM: 16 GB (for base WAN model + LoRAs)
  • RAM: 32 GB system memory
  • Disk Space: 3 GB (2 GB for LoRAs + workspace)
  • GPU: NVIDIA RTX 3090 or equivalent (FP8 support recommended)

Recommended Requirements

  • VRAM: 24 GB (NVIDIA RTX 4090, A5000)
  • RAM: 64 GB system memory
  • Disk Space: 5 GB (with headroom for multiple models)
  • GPU: NVIDIA RTX 4090 or H100 (native FP8 acceleration)

Optimal Performance

  • VRAM: 48+ GB (NVIDIA A6000, H100)
  • RAM: 128 GB system memory
  • Storage: NVMe SSD for fast model loading
  • GPU: NVIDIA H100 or multiple RTX 4090s

Usage Examples

Loading LoRAs with Diffusers 

import torch
from diffusers import DiffusionPipeline
from PIL import Image

# Load base WAN image-to-video model
pipe = DiffusionPipeline.from_pretrained(
    "genmo/mochi-1-preview",
    torch_dtype=torch.float16,
    variant="fp16"
)
pipe.to("cuda")

# Load input image
input_image = Image.open("E:/images/input_frame.png")

# Load LoRA adapters (absolute paths)
lora_path = "E:/huggingface/wan25-fp8-i2v-loras-nsfw/loras/wan"

# Example: Load camera control LoRA
pipe.load_lora_weights(
    f"{lora_path}/camera_cinematic_v1.safetensors",
    adapter_name="camera_control"
)

# Example: Load motion dynamics LoRA
pipe.load_lora_weights(
    f"{lora_path}/motion_smooth_v1.safetensors",
    adapter_name="motion"
)

# Set LoRA weights (0.0 to 1.0 scale)
pipe.set_adapters(
    ["camera_control", "motion"],
    adapter_weights=[0.8, 0.7]
)

# Generate video from image with LoRAs applied
prompt = "Cinematic camera slowly zooming in with smooth motion"
video = pipe(
    image=input_image,
    prompt=prompt,
    num_frames=48,
    height=480,
    width=848,
    num_inference_steps=50,
    guidance_scale=7.5
).frames[0]

# Save video
from diffusers.utils import export_to_video
export_to_video(video, "output.mp4", fps=24)

Advanced LoRA Composition for Image-to-Video 

# Combine multiple LoRAs for complex image-to-video effects
lora_configs = [
    {"path": f"{lora_path}/camera_pan_v1.safetensors", "weight": 0.7, "name": "camera"},
    {"path": f"{lora_path}/motion_fluid_v1.safetensors", "weight": 0.8, "name": "motion"},
    {"path": f"{lora_path}/lighting_sunset_v1.safetensors", "weight": 0.6, "name": "lighting"},
    {"path": f"{lora_path}/quality_enhance_v1.safetensors", "weight": 0.5, "name": "quality"}
]

# Load all LoRAs
for config in lora_configs:
    pipe.load_lora_weights(config["path"], adapter_name=config["name"])

# Set adapter weights
adapter_names = [c["name"] for c in lora_configs]
adapter_weights = [c["weight"] for c in lora_configs]
pipe.set_adapters(adapter_names, adapter_weights=adapter_weights)

# Load input image
input_image = Image.open("E:/images/beach_scene.png")

# Generate with combined effects
video = pipe(
    image=input_image,
    prompt="Golden hour beach scene animating with smooth camera pan across the horizon",
    num_frames=72,
    height=480,
    width=848,
    guidance_scale=7.5
).frames[0]

export_to_video(video, "animated_beach.mp4", fps=24)

Memory-Efficient Loading (FP8) 

# Use FP8 quantization for memory efficiency
from transformers import BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    load_in_8bit=True,
    llm_int8_threshold=6.0
)

# Load with FP8 optimization
pipe = DiffusionPipeline.from_pretrained(
    "genmo/mochi-1-preview",
    quantization_config=quantization_config,
    torch_dtype=torch.float16,
    low_cpu_mem_usage=True
)

# LoRAs automatically work with FP8 base model
pipe.load_lora_weights(f"{lora_path}/camera_control_v1.safetensors")

# Generate image-to-video with reduced memory footprint
input_image = Image.open("E:/images/portrait.png")
video = pipe(image=input_image, prompt="Cinematic portrait with subtle camera movement")

Model Specifications

Format

  • File Format: SafeTensors (secure, efficient)
  • Precision: FP8 (8-bit floating point)
  • Architecture: LoRA adapters for WAN transformer blocks
  • Compatibility: WAN 2.5, Mochi-1-preview image-to-video models

LoRA Configuration

  • Rank (r): Typically 16-64 (balance between quality and size)
  • Alpha: 16-32 (controls adaptation strength)
  • Target Modules: Attention layers, feed-forward networks, temporal blocks
  • Trainable Parameters: 5-50M per LoRA (vs 3B+ for full model)

Performance Characteristics

  • Memory Savings: 70-85% vs FP16 (8-bit vs 16-bit)
  • Speed Improvement: 1.5-2.5x faster inference on FP8-capable GPUs
  • Quality: Minimal degradation (<5% perceptual difference from FP16)
  • Composability: Multiple LoRAs can be stacked with cumulative effects
  • Temporal Consistency: Specialized training for smooth video generation

Performance Tips and Optimization

Memory Optimization

  1. Use FP8 Base Model: Combine FP8 LoRAs with FP8 base model for maximum efficiency
  2. Enable xFormers: pip install xformers for memory-efficient attention
  3. Gradient Checkpointing: Trade compute for memory when needed
  4. Sequential Loading: Load and unload LoRAs as needed rather than keeping all in memory
  5. Frame Budget: Start with 24-48 frames, increase as VRAM allows

Speed Optimization

  1. NVIDIA FP8 Acceleration: Use RTX 40-series or H100 for native FP8 Tensor Cores
  2. Compile Models: Use torch.compile() for 20-30% speedup (PyTorch 2.0+)
  3. Reduce Steps: Start with 30 steps, increase if quality insufficient
  4. Batch Processing: Process multiple images in batch when possible
  5. Frame Interpolation: Generate fewer frames and interpolate for longer videos

Quality Optimization

  1. LoRA Weight Tuning: Start at 0.7-0.8, adjust based on desired effect strength
  2. Avoid Over-composition: Use 2-3 LoRAs max to prevent conflicting effects
  3. Balanced Guidance: Use guidance_scale 6.5-8.5 for best quality/creativity balance
  4. Resolution Matching: Use resolution multiples trained on (typically 480p, 720p)
  5. Input Image Quality: Higher quality input images produce better video results

Recommended LoRA Combinations

Cinematic Animation:

adapters = ["camera_cinematic", "motion_smooth", "lighting_dramatic", "quality_enhance"]
weights = [0.8, 0.7, 0.7, 0.5]

Natural Motion:

adapters = ["camera_handheld", "motion_natural", "lighting_natural", "quality_enhance"]
weights = [0.6, 0.8, 0.6, 0.6]

Artistic Style:

adapters = ["camera_dynamic", "motion_fluid", "lighting_creative", "style_artistic"]
weights = [0.9, 0.8, 0.9, 0.7]

License

License Type: Custom WAN License (other)

This repository uses a custom license for WAN model derivatives. Key terms:

  • ✅ Permitted: Research use, personal projects, non-commercial applications
  • ⚠️ Restricted: Commercial use may require separate licensing
  • ❌ Prohibited: Redistribution without attribution, malicious use

NSFW Content Warning:

  • Models in this repository may generate adult or sensitive content
  • Users are responsible for compliance with local laws and regulations
  • Not suitable for minors or workplace environments
  • Use appropriate content filtering in production applications

Please review the full license terms before use. For commercial licensing inquiries, contact the model authors.

Citation

If you use these LoRAs in your research or projects, please cite:

@misc{wan25-fp8-i2v-loras-nsfw,
  title={WAN 2.5 FP8 LoRA Adapters for Enhanced Image-to-Video Generation},
  author={Community Contributors},
  year={2025},
  howpublished={\url{https://huggingface.co/wan25-fp8-i2v-loras-nsfw}},
  note={FP8-optimized LoRA adapters for camera control, motion dynamics, lighting, and quality enhancement in image-to-video synthesis}
}

Related Resources

Official Documentation

Community Resources

  • WAN Discord: Community discussions and support
  • Model Card: Detailed specifications and training details
  • Example Notebooks: Colab notebooks with image-to-video usage examples

Related Repositories

  • wan25-base-fp8/: Base WAN 2.5 model in FP8 precision
  • wan25-vae/: WAN video autoencoder models
  • flux-dev-fp8/: FLUX image generation models (compatible workflows)

Changelog

v1.5 (2025-10-28)

  • ✅ YAML frontmatter tags corrected: Removed incorrect "image-generation" tag
  • ✅ Added accurate tags: "image-to-video", "video-generation", "lora"
  • ✅ Version header updated to v1.5
  • ✅ Tags now accurately reflect image-to-video LoRA functionality
  • ✅ Comprehensive tag coverage for Hugging Face discoverability

v1.4 (2025-10-28)

  • ✅ YAML frontmatter validation: Simplified tags array to core categories
  • ✅ Removed base_model/base_model_relation (not applicable for base model collections)
  • ✅ Tag optimization: Retained wan, text-to-video, image-generation as primary tags
  • ✅ Version header updated to v1.4
  • ✅ Ensured proper YAML format with exact three-dash markers

v1.3 (2025-10-14)

  • ✅ Updated title to clarify Image-to-Video (I2V) focus
  • ✅ Enhanced tags: Added "video-generation", "lora", "image-to-video"
  • ✅ Removed "image-generation" tag (incorrect for video models)
  • ✅ Updated model description to emphasize image-to-video capabilities
  • ✅ Enhanced usage examples with image input workflows
  • ✅ Added motion dynamics LoRAs to expected files
  • ✅ Updated LoRA combinations with motion-specific recommendations
  • ✅ Added temporal consistency to performance characteristics
  • ✅ Updated citation to reflect image-to-video focus
  • ✅ Version header updated to v1.3

v1.2 (2025-10-14)

  • ✅ YAML frontmatter compliance: Removed base_model/base_model_relation fields
  • ✅ Simplified tags to core categories
  • ✅ Updated repository status to reflect empty structure
  • ✅ Version header updated to v1.2

v1.1 (2025-10-14)

  • ✅ Enhanced README with accurate directory structure
  • ✅ Updated YAML frontmatter with proper tag ordering
  • ✅ Documented current repository size
  • ✅ Added detailed file status tracking

v1.0 (2025-10-13)

  • 📝 Initial repository structure created
  • 📋 README documentation with comprehensive usage guide
  • 🚧 Awaiting model file population
  • 📦 Directory structure: loras/wan/ prepared

Future Updates

  • 🔜 Camera control LoRAs addition (pan, zoom, tilt, dolly, orbit)
  • 🔜 Motion dynamics LoRAs (smooth, fluid, natural, dynamic)
  • 🔜 Lighting enhancement LoRAs (dramatic, natural, creative, sunset, cinematic)
  • 🔜 Quality improvement LoRAs (detail, consistency, temporal stability)
  • 🔜 Style-specific LoRAs (cinematic, realistic, artistic, anime)
  • 🔜 Example videos and image-to-video comparison benchmarks
  • 🔜 Training scripts and fine-tuning guides
  • 🔜 Performance benchmarks across different hardware configurations

Contact and Support

Issues and Questions

  • Repository Issues: Report technical issues or request features
  • Model Questions: Consult WAN model documentation and Diffusers I2V guides
  • Usage Support: Check examples and community resources first

Contributing

Contributions of additional LoRAs, improved documentation, or usage examples are welcome. Please ensure all contributions comply with the license terms and content guidelines.

Last Updated: 2025-10-28 README Version: v1.5 Repository Status: Empty structure (no model files) Current Size: 18 KB (documentation only) Maintained By: Community Contributors

Downloads last month
-
Inference Providers NEW
Text-to-Video
This model isn't deployed by any Inference Provider. 🙋 Ask for provider support

Collection including wangkanai/wan25-fp8-i2v-loras-nsfw