wan25-fp16-i2v-loras-nsfw

<!-- README Version: v1.5 -->

WAN 2.5 FP16 Image-to-Video LoRAs (NSFW)

Model Description

This repository is designed to store LoRA (Low-Rank Adaptation) adapters for the WAN 2.5 image-to-video generation model in FP16 precision. LoRAs are lightweight model adapters that enhance specific capabilities of the base WAN model without requiring full model retraining.

Current Status: Repository structure initialized, awaiting model file population. This is a storage directory for WAN 2.5 image-to-video (I2V) LoRA adapters in FP16 precision, specifically for NSFW content generation.

What are LoRAs?

LoRAs (Low-Rank Adaptations) are small adapter models that modify the behavior of a base model by learning task-specific adjustments. For image-to-video generation, LoRAs can provide:

• Camera Control: Precise control over camera movements (pan, tilt, zoom, dolly)
• Motion Enhancement: Improved motion consistency and quality from static images
• Lighting Enhancement: Better lighting consistency and quality in generated videos
• Style Transfer: Specific visual styles or aesthetics applied to video generation
• Quality Improvements: Enhanced detail, coherence, and temporal consistency
• Content Specialization: Specialized generation for specific content types (including NSFW)

Key Features

• Image-to-Video Focus: Specialized for converting static images into dynamic video sequences
• FP16 Precision: Half-precision floating-point for balanced quality and performance
• Modular Enhancement: Stack multiple LoRAs for combined effects
• Low VRAM Overhead: Minimal additional memory requirements (~100-500MB per LoRA)
• Compatible with WAN 2.5: Designed for the WAN image-to-video pipeline
• NSFW Capability: Specialized for adult content generation with appropriate safeguards

Repository Contents

Directory Structure

wan25-fp16-i2v-loras-nsfw/
├── README.md                    # This file
└── loras/                       # LoRA model directory
    └── wan/                     # WAN I2V-specific LoRAs
        └── (model files pending)

Expected Model Files

When populated, this repository will contain:

• *.safetensors: LoRA weight files in SafeTensors format
• *.json: Configuration files for each LoRA
• *.txt: Metadata and usage instructions

Example LoRA types for Image-to-Video:

• i2v_camera_control_lora.safetensors (~100-300MB)
• i2v_motion_enhancement_lora.safetensors (~150-400MB)
• i2v_lighting_enhancement_lora.safetensors (~150-400MB)
• i2v_quality_boost_lora.safetensors (~200-500MB)
• i2v_style_*_lora.safetensors (~100-400MB)

Hardware Requirements

Minimum Requirements

• VRAM: 12GB (base WAN model + 1-2 LoRAs)
• RAM: 32GB system memory
• Disk Space: 2-5GB for LoRA collection
• GPU: NVIDIA RTX 3060 12GB or better

Recommended Requirements

• VRAM: 24GB (base WAN model + multiple LoRAs)
• RAM: 64GB system memory
• Disk Space: 10GB for complete LoRA collection
• GPU: NVIDIA RTX 4090 or A6000

Performance Notes

• Each LoRA adds ~100-500MB VRAM overhead
• Multiple LoRAs can be stacked (VRAM overhead accumulates)
• FP16 precision provides good quality-to-performance balance

Usage Examples

Basic Image-to-Video LoRA Loading with Diffusers

from diffusers import DiffusionPipeline
from PIL import Image
import torch

# Load base WAN 2.5 I2V model
pipe = DiffusionPipeline.from_pretrained(
    "genmoai/wan-video-1.5b",
    torch_dtype=torch.float16,
    variant="fp16"
).to("cuda")

# Load a single I2V LoRA
pipe.load_lora_weights(
    r"E:\huggingface\wan25-fp16-i2v-loras-nsfw\loras\wan",
    weight_name="i2v_camera_control_lora.safetensors",
    adapter_name="camera"
)

# Load input image
input_image = Image.open("input_image.png")

# Generate video from image with LoRA enhancement
prompt = "A cinematic dolly shot moving through the scene"
video = pipe(
    image=input_image,
    prompt=prompt,
    num_frames=49,
    height=480,
    width=832,
    num_inference_steps=30,
    guidance_scale=7.5,
    cross_attention_kwargs={"scale": 0.8}  # LoRA strength
).frames[0]

Stacking Multiple I2V LoRAs

from PIL import Image

# Load input image
input_image = Image.open("input_image.png")

# Load multiple I2V LoRAs for combined effects
pipe.load_lora_weights(
    r"E:\huggingface\wan25-fp16-i2v-loras-nsfw\loras\wan",
    weight_name="i2v_camera_control_lora.safetensors",
    adapter_name="camera"
)

pipe.load_lora_weights(
    r"E:\huggingface\wan25-fp16-i2v-loras-nsfw\loras\wan",
    weight_name="i2v_motion_enhancement_lora.safetensors",
    adapter_name="motion"
)

pipe.load_lora_weights(
    r"E:\huggingface\wan25-fp16-i2v-loras-nsfw\loras\wan",
    weight_name="i2v_lighting_enhancement_lora.safetensors",
    adapter_name="lighting"
)

# Set adapter weights
pipe.set_adapters(["camera", "motion", "lighting"], adapter_weights=[0.8, 0.7, 0.6])

# Generate with combined enhancements
video = pipe(
    image=input_image,
    prompt="Dynamic camera movement with enhanced motion and cinematic lighting",
    num_frames=49,
    height=480,
    width=832,
    num_inference_steps=30,
    guidance_scale=7.5
).frames[0]

Adjusting LoRA Strength

# LoRA strength controls how much the adapter affects generation
# Range: 0.0 (no effect) to 1.0 (full effect), can go higher for stronger effects

# Subtle enhancement
pipe.set_adapters(["camera"], adapter_weights=[0.3])

# Standard enhancement
pipe.set_adapters(["camera"], adapter_weights=[0.8])

# Strong enhancement
pipe.set_adapters(["camera"], adapter_weights=[1.2])

Saving Videos

from diffusers.utils import export_to_video

# Generate video
video_frames = pipe(prompt="...").frames[0]

# Export to MP4
export_to_video(
    video_frames,
    output_video_path="output_video.mp4",
    fps=8
)

Model Specifications

Format Details

• Format: SafeTensors (.safetensors)
• Precision: FP16 (16-bit floating-point)
• Architecture: LoRA adapters for WAN 2.5 DiT (Diffusion Transformer)
• Compatibility: WAN 2.5, WAN 1.5B models

LoRA Architecture

• Rank: Typically 4-64 (lower = smaller file, higher = more capacity)
• Alpha: Scaling parameter for LoRA strength
• Target Modules: Attention layers, feed-forward layers
• Merge Strategy: Additive (combines with base model weights)

Supported Resolutions

• 480x832 (standard landscape)
• 832x480 (portrait)
• 512x512 (square)
• Custom: Other aspect ratios may work with varying quality

Performance Tips

Optimization Strategies

1. LoRA Selection: Use only LoRAs needed for your task
2. Strength Tuning: Lower LoRA weights (0.5-0.8) often provide better balance
3. Memory Management: Unload unused LoRAs with pipe.unload_lora_weights()
4. Batch Processing: Process multiple prompts in sequence to amortize loading costs

Quality vs Performance Trade-offs

VRAM Optimization

# Enable memory-efficient attention
pipe.enable_attention_slicing()

# Enable VAE tiling for higher resolutions
pipe.enable_vae_tiling()

# Use CPU offloading if VRAM is limited
pipe.enable_model_cpu_offload()

# Clear CUDA cache between generations
import torch
torch.cuda.empty_cache()

License

This repository contains LoRA adapters for the WAN video generation model. Usage is governed by the WAN model license.

License Type: Custom WAN License Commercial Use: Check base model license for restrictions Attribution: Required when redistributing or publishing generated content Modifications: Allowed for personal and research use

NSFW Content Notice: This repository may contain or be designed to generate NSFW (Not Safe For Work) content. Users must comply with applicable laws and platform policies.

Base Model License

LoRAs are derivative works of the base WAN model. Review the base model license:

• https://huggingface.co/genmoai/wan-video-1.5b

Citation

If you use these LoRAs in your research or projects, please cite both the base WAN model and this LoRA collection:

@software{wan25_fp16_loras,
  title = {WAN 2.5 FP16 LoRA Collection (NSFW)},
  author = {Community Contributors},
  year = {2025},
  url = {https://huggingface.co/[your-username]/wan25-fp16-loras-nsfw}
}

@software{wan_video,
  title = {WAN: World Animated Network},
  author = {Genmo AI},
  year = {2024},
  url = {https://huggingface.co/genmoai/wan-video-1.5b}
}

Resources

Official Documentation

• WAN Model: https://huggingface.co/genmoai/wan-video-1.5b
• Diffusers Library: https://huggingface.co/docs/diffusers/
• LoRA Guide: https://huggingface.co/docs/diffusers/training/lora

Community Resources

• WAN Discord: Community support and discussions
• Example Notebooks: Coming soon
• Video Gallery: Generated video examples

Related Repositories

• WAN Base Models: E:\huggingface\wan\ (if available)
• WAN VAE Models: For encoding/decoding video frames
• FLUX Models: For image generation and video frame initialization

Changelog

Version 1.5 (2025-10-28)

• Updated to v1.5 specification with image-to-video (I2V) focus
• Clarified repository purpose as image-to-video LoRA collection
• Updated all code examples to include image input for I2V pipeline
• Enhanced LoRA descriptions for motion enhancement capabilities
• Updated directory naming and file naming conventions for I2V
• Verified YAML frontmatter compliance
• Validated metadata accuracy for Hugging Face compatibility

Version 1.4 (2025-10-28)

• Updated to v1.4 specification
• Verified YAML frontmatter compliance
• Confirmed comprehensive documentation structure
• Validated metadata accuracy for Hugging Face compatibility

Version 1.3 (2025-10-14)

• Fixed YAML frontmatter to remove base_model fields (LoRA adapters, not derived models)
• Simplified metadata to core required fields only
• Maintained comprehensive documentation structure

Version 1.2 (2025-10-14)

• Updated README to v1.2 with enhanced metadata compliance
• Clarified repository purpose and current status
• Improved documentation structure

Version 1.1 (2025-10-13)

• Enhanced YAML frontmatter with comprehensive tags
• Added base_model relationship metadata

Version 1.0 (2025-10-13)

• Initial repository structure created
• README documentation prepared
• Awaiting model file population

---

Repository Status: 🚧 Structure initialized, pending model files Last Updated: 2025-10-28 Maintained By: Local Hugging Face Repository Collection Total Size: ~15KB (directory structure only, no model files yet)