app.py

# PyTorch 2.8 (temporary hack)
import os
os.system('pip install --upgrade --pre --extra-index-url https://download.pytorch.org/whl/nightly/cu126 "torch<2.9" spaces')

# Actual demo code
import spaces
import torch
from diffusers import FlowMatchEulerDiscreteScheduler
from diffusers.pipelines.wan.pipeline_wan_i2v import WanImageToVideoPipeline
from diffusers.models.transformers.transformer_wan import WanTransformer3DModel
from diffusers.utils.export_utils import export_to_video
import gradio as gr
import tempfile
import numpy as np
from PIL import Image
import random
import gc
from optimization import optimize_pipeline_

SECRET_KEY = os.environ.get("SECRET_KEY")

# 如果在 Space 中没有设置密钥
if not SECRET_KEY:
    raise ValueError("请设置 SECRET_KEY 环境变量。")

MODEL_ID = "Wan-AI/Wan2.2-I2V-A14B-Diffusers"

# 在这里配置所有的 LoRA。
LORA_REPO_ID = "IdlecloudX/Flux_and_Wan_Lora"
LORA_SETS = {
    "NF": {
        "high_noise": {"file": "NSFW-22-H-e8.safetensors", "adapter_name": "nf_high"},
        "low_noise": {"file": "NSFW-22-L-e8.safetensors", "adapter_name": "nf_low"}
    },
    "BP": {
        "high_noise": {"file": "Wan2.2_BP-v1-HighNoise-I2V_T2V.safetensors", "adapter_name": "bp_high"},
        "low_noise": {"file": "Wan2.2_BP-v1-LowNoise-I2V_T2V.safetensors", "adapter_name": "bp_low"}
    },
    "Py-v1": {
        "high_noise": {"file": "WAN2.2-HighNoise_Pyv1-I2V_T2V.safetensors", "adapter_name": "py_high"},
        "low_noise": {"file": "WAN2.2-LowNoise_Pyv1-I2V_T2V.safetensors", "adapter_name": "py_low"}
    }
}

MAX_DIMENSION = 832
MIN_DIMENSION = 576

DIMENSION_MULTIPLE = 16
SQUARE_SIZE = 640
MAX_SEED = np.iinfo(np.int32).max
FIXED_FPS = 16
MIN_FRAMES_MODEL = 8
MAX_FRAMES_MODEL = 81
MIN_DURATION = round(MIN_FRAMES_MODEL/FIXED_FPS, 1)
MAX_DURATION = round(MAX_FRAMES_MODEL/FIXED_FPS, 1)


print("正在加载模型...")
pipe = WanImageToVideoPipeline.from_pretrained(
    MODEL_ID,
    transformer=WanTransformer3DModel.from_pretrained('cbensimon/Wan2.2-I2V-A14B-bf16-Diffusers',
        subfolder='transformer',
        torch_dtype=torch.bfloat16,
        device_map='cuda',
    ),
    transformer_2=WanTransformer3DModel.from_pretrained('cbensimon/Wan2.2-I2V-A14B-bf16-Diffusers',
        subfolder='transformer_2',
        torch_dtype=torch.bfloat16,
        device_map='cuda',
    ),
    torch_dtype=torch.bfloat16,
)
# 使用新的调度器
pipe.scheduler = FlowMatchEulerDiscreteScheduler.from_config(pipe.scheduler.config, shift=8.0)
pipe.to('cuda')
print("模型加载完成。")


print("开始优化 Pipeline...")
optimize_pipeline_(pipe,
    image=Image.new('RGB', (MAX_DIMENSION, MIN_DIMENSION)),
    last_image=Image.new('RGB', (MAX_DIMENSION, MIN_DIMENSION)), # 为首尾帧功能添加 last_image
    prompt='prompt',
    height=MIN_DIMENSION,
    width=MAX_DIMENSION,
    num_frames=MAX_FRAMES_MODEL,
)
print("优化完成。")

for name, lora_set in LORA_SETS.items():
    print(f"--- 开始加载 LoRA 集合: {name} ---")

    # 加载 High Noise
    high_noise_config = lora_set["high_noise"]
    print(f"正在加载 High Noise: {high_noise_config['file']}...")
    pipe.load_lora_weights(LORA_REPO_ID, weight_name=high_noise_config['file'], adapter_name=high_noise_config['adapter_name'])
    print("High Noise LoRA 加载完成。")

    # 加载 Low Noise
    low_noise_config = lora_set["low_noise"]
    print(f"正在加载 Low Noise: {low_noise_config['file']}...")
    pipe.load_lora_weights(LORA_REPO_ID, weight_name=low_noise_config['file'], adapter_name=low_noise_config['adapter_name'])
    print("Low Noise LoRA 加载完成。")
print("所有自定义 LoRA 加载完毕。")

for i in range(3):
    gc.collect()
    torch.cuda.synchronize()
    torch.cuda.empty_cache()

default_prompt_i2v = "make this image come alive, cinematic motion, smooth animation"
default_negative_prompt = "色调艳丽, 过曝, 静态, 细节模糊不清, 字幕, 风格, 作品, 画作, 画面, 静止, 整体发灰, 最差质量, 低质量, JPEG压缩残留, 丑陋的, 残缺的, 多余的手指, 画得不好的手部, 画得不好的脸部, 畸形的, 毁容的, 形态畸形的肢体, 手指融合, 静止不动的画面, 杂乱的背景, 三条腿, 背景人很多, 倒着走"


def process_image_for_video(image: Image.Image) -> Image.Image:
    width, height = image.size
    if width == height:
        return image.resize((SQUARE_SIZE, SQUARE_SIZE), Image.Resampling.LANCZOS)

    aspect_ratio = width / height
    new_width, new_height = width, height

    if new_width > MAX_DIMENSION or new_height > MAX_DIMENSION:
        scale = MAX_DIMENSION / (new_width if aspect_ratio > 1 else new_height)
        new_width, new_height = new_width * scale, new_height * scale

    if new_width < MIN_DIMENSION or new_height < MIN_DIMENSION:
        scale = MIN_DIMENSION / (new_height if aspect_ratio > 1 else new_width)
        new_width, new_height = new_width * scale, new_height * scale

    final_width = int(round(new_width / DIMENSION_MULTIPLE) * DIMENSION_MULTIPLE)
    final_height = int(round(new_height / DIMENSION_MULTIPLE) * DIMENSION_MULTIPLE)
    
    final_width = max(final_width, MIN_DIMENSION if aspect_ratio < 1 else SQUARE_SIZE)
    final_height = max(final_height, MIN_DIMENSION if aspect_ratio > 1 else SQUARE_SIZE)

    return image.resize((final_width, final_height), Image.Resampling.LANCZOS)

def resize_and_crop_to_match(target_image, reference_image):
    ref_width, ref_height = reference_image.size
    target_width, target_height = target_image.size
    scale = max(ref_width / target_width, ref_height / target_height)
    new_width, new_height = int(target_width * scale), int(target_height * scale)
    resized = target_image.resize((new_width, new_height), Image.Resampling.LANCZOS)
    left, top = (new_width - ref_width) // 2, (new_height - ref_height) // 2
    return resized.crop((left, top, left + ref_width, top + ref_height))

def get_duration(
    secret_key,
    start_image_pil,
    end_image_pil,
    prompt,
    steps,
    negative_prompt,
    duration_seconds,
    guidance_scale,
    guidance_scale_2,
    seed,
    randomize_seed,
    selected_loras,
    progress,
):
    return int(steps) * 15

@spaces.GPU(duration=get_duration)
def generate_video(
    secret_key,
    start_image_pil,
    end_image_pil,
    prompt,
    steps = 8,
    negative_prompt=default_negative_prompt,
    duration_seconds=3.5,
    guidance_scale=1,
    guidance_scale_2=1,
    seed=42,
    randomize_seed=False,
    selected_loras=[],
    progress=gr.Progress(track_tqdm=True),
):
    if secret_key != SECRET_KEY:
        raise gr.Error("无效的密钥！请输入正确的密钥。")

    if start_image_pil is None or end_image_pil is None:
        raise gr.Error("请上传开始帧和结束帧。")

    progress(0.1, desc="正在预处理图像...")
    processed_start_image = process_image_for_video(start_image_pil)
    processed_end_image = resize_and_crop_to_match(end_image_pil, processed_start_image)
    target_height, target_width = processed_start_image.height, processed_start_image.width

    current_seed = random.randint(0, MAX_SEED) if randomize_seed else int(seed)
    num_frames = np.clip(int(round(duration_seconds * FIXED_FPS)), MIN_FRAMES_MODEL, MAX_FRAMES_MODEL)
    num_inference_steps = int(steps)
    switch_step = num_inference_steps // 2

    progress(0.2, desc=f"正在生成 {num_frames} 帧，尺寸 {target_width}x{target_height} (seed: {current_seed})...")

    class LoraSwitcher:
        def __init__(self, selected_lora_names):
            self.switched = False
            self.high_noise_adapters = []
            self.low_noise_adapters = []
            if selected_lora_names:
                for name in selected_lora_names:
                    if name in LORA_SETS:
                        self.high_noise_adapters.append(LORA_SETS[name]["high_noise"]["adapter_name"])
                        self.low_noise_adapters.append(LORA_SETS[name]["low_noise"]["adapter_name"])

        def __call__(self, pipe, step_index, timestep, callback_kwargs):
            if step_index == 0:
                self.switched = False
                if self.high_noise_adapters:
                    print(f"激活 High Noise LoRA: {self.high_noise_adapters}")
                    pipe.set_adapters(self.high_noise_adapters, adapter_weights=[1.0] * len(self.high_noise_adapters))
                elif pipe.get_active_adapters():
                    active_adapters = pipe.get_active_adapters()
                    print(f"未选择 LoRA，通过设置权重为0来禁用残留的 LoRA: {active_adapters}")
                    pipe.set_adapters(active_adapters, adapter_weights=[0.0] * len(active_adapters))
            
            if self.low_noise_adapters and step_index >= switch_step and not self.switched:
                print(f"在第 {step_index} 步切换到 Low Noise LoRA: {self.low_noise_adapters}")
                pipe.set_adapters(self.low_noise_adapters, adapter_weights=[1.0] * len(self.low_noise_adapters))
                self.switched = True
            return callback_kwargs

    lora_switcher_callback = LoraSwitcher(selected_loras)

    output_frames_list = pipe(
        image=processed_start_image,
        last_image=processed_end_image,
        prompt=prompt,
        negative_prompt=negative_prompt,
        height=target_height,
        width=target_width,
        num_frames=num_frames,
        guidance_scale=float(guidance_scale),
        guidance_scale_2=float(guidance_scale_2),
        num_inference_steps=num_inference_steps,
        generator=torch.Generator(device="cuda").manual_seed(current_seed),
        callback_on_step_end=lora_switcher_callback,
    ).frames[0]
    
    progress(0.9, desc="正在编码和保存视频...")
    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmpfile:
        video_path = tmpfile.name
    export_to_video(output_frames_list, video_path, fps=FIXED_FPS)
    
    progress(1.0, desc="完成!")
    return video_path, current_seed


with gr.Blocks() as demo:
    gr.Markdown("# Wan 2.2 First/Last Frame with LoRA")
    with gr.Row():
        with gr.Column():
            secret_key_input = gr.Textbox(label="密钥 (Secret Key)", placeholder="Enter your key here...", type="password")

            with gr.Row():
                start_image_component = gr.Image(type="pil", label="开始帧 (Start Frame)", sources=["upload", "clipboard"])
                end_image_component = gr.Image(type="pil", label="结束帧 (End Frame)", sources=["upload", "clipboard"])

            prompt_input = gr.Textbox(label="Prompt", value=default_prompt_i2v)
            duration_seconds_input = gr.Slider(minimum=MIN_DURATION, maximum=MAX_DURATION, step=0.1, value=3.5, label="视频时长 (秒)", info=f"将在 {FIXED_FPS}fps 下被限制在模型的 {MIN_FRAMES_MODEL}-{MAX_FRAMES_MODEL} 帧范围内。")
            
            # 保留您的 LoRA 选择器
            lora_selection_checkbox = gr.CheckboxGroup(
                choices=list(LORA_SETS.keys()),
                label="选择要应用的 LoRA (可多选)",
                info="选择一个或多个 LoRA 风格进行组合。"
            )
            
            with gr.Accordion("高级设置", open=False):
                negative_prompt_input = gr.Textbox(label="负面提示词", value=default_negative_prompt, lines=3)
                seed_input = gr.Slider(label="种子", minimum=0, maximum=MAX_SEED, step=1, value=42, interactive=True)
                randomize_seed_checkbox = gr.Checkbox(label="随机种子", value=True, interactive=True)
                steps_slider = gr.Slider(minimum=1, maximum=30, step=1, value=8, label="推理步数")
                guidance_scale_input = gr.Slider(minimum=0.0, maximum=10.0, step=0.5, value=1, label="引导系数 - 高噪声阶段")
                guidance_scale_2_input = gr.Slider(minimum=0.0, maximum=10.0, step=0.5, value=1, label="引导系数 2 - 低噪声阶段")

            generate_button = gr.Button("生成视频", variant="primary")
        with gr.Column():
            video_output = gr.Video(label="生成的视频", autoplay=True, interactive=False)

    ui_inputs = [
        secret_key_input,
        start_image_component,
        end_image_component,
        prompt_input,
        steps_slider,
        negative_prompt_input,
        duration_seconds_input,
        guidance_scale_input,
        guidance_scale_2_input,
        seed_input,
        randomize_seed_checkbox,
        lora_selection_checkbox
    ]
    generate_button.click(fn=generate_video, inputs=ui_inputs, outputs=[video_output, seed_input])

if __name__ == "__main__":
    demo.queue().launch(mcp_server=True)