FP8 量化 Wan2.2-ReMixV3.0 图生视频模型本地部署与时序一致性优化工程实践

# 创建项目隔离虚拟环境
python -m venv wan22_remix_env
# Windows激活环境
wan22_remix_env\Scripts\activate
# Linux激活环境
source wan22_remix_env/bin/activate
# 安装匹配CUDA12.1的PyTorch
pip3 install torch==2.4.1 torchvision==0.19.1 torchaudio==2.4.1 --index-url https://download.pytorch.org/whl/cu121
# 推理依赖组件
pip install transformers==4.45.2 accelerate==0.30.1 diffusers==0.31.0 safetensors pillow bitsandbytes imageio-ffmpeg opencv-python

import torch
import transformers
import diffusers
import platform
def env_check():
    print(f"Python Version: {platform.python_version()}")
    print(f"PyTorch Version: {torch.__version__}")
    print(f"CUDA Available: {torch.cuda.is_available()}")
    if torch.cuda.is_available():
        print(f"GPU Device Name: {torch.cuda.get_device_name(0)}")
        total_mem = torch.cuda.get_device_properties(0).total_memory / (1024**3)
        print(f"GPU Total VRAM: {total_mem:.2f} GB")
        print(f"CUDA Version: {torch.version.cuda}")
    print(f"transformers: {transformers.__version__}")
    print(f"diffusers: {diffusers.__version__}")
if __name__ == "__main__":
    env_check()

# Windows PowerShell 7z解压
& "C:\Program Files\7-Zip\7z.exe" x Wan2.2‑ReMixV3.0_14B_FP8.7z -o"./wan22_remix_v3" -y

# Linux 解压
7z x Wan2.2‑ReMixV3.0_14B_FP8.7z -o./wan22_remix_v3 -y

import os
model_root = "./wan22_remix_v3"
asset_list = [
    "Wan2.2‑ReMixV3.0_fp8.safetensors",
    "lora/VBVR_consistency_lora.safetensors",
    "wan_2.1_vae.safetensors",
    "umt5_xxl_fp8_e4m3fn.safetensors"
]
def check_assets(root, filelist):
    missing = []
    for rel_path in filelist:
        abs_path = os.path.join(root, rel_path)
        if os.path.isfile(abs_path):
            print(f"[OK] {abs_path}")
        else:
            print(f"[MISS] {abs_path}")
            missing.append(rel_path)
    if missing:
        raise FileNotFoundError(f"缺失权重文件列表: {missing}")
if __name__ == "__main__":
    check_assets(model_root, asset_list)

import hashlib
def calc_file_md5(file_path: str, chunk_size=1<<20) -> str:
    md5 = hashlib.md5()
    with open(file_path, "rb") as f:
        while chunk := f.read(chunk_size):
            md5.update(chunk)
    return md5.hexdigest()
if __name__ == "__main__":
    weight_path = "./wan22_remix_v3/Wan2.2‑ReMixV3.0_fp8.safetensors"
    hash_val = calc_file_md5(weight_path)
    print(f"MD5: {hash_val}")

import torch
from PIL import Image
from diffusers import Wan22ImageToVideoPipeline
from safetensors.torch import load_file
# ===================== 全局参数配置 =====================
MODEL_CFG = {
    "unet_path": "./wan22_remix_v3/Wan2.2‑ReMixV3.0_fp8.safetensors",
    "lora_path": "./wan22_remix_v3/lora/VBVR_consistency_lora.safetensors",
    "vae_path": "./wan22_remix_v3/wan_2.1_vae.safetensors",
    "text_encoder_path": "./wan22_remix_v3/umt5_xxl_fp8_e4m3fn.safetensors",
}
INFER_CFG = {
    "input_img": "comic_ref.png",
    "output_video": "comic_output.mp4",
    "num_frames": 32,
    "guidance_scale": 6.0,
    "num_inference_steps": 24,
    "lora_scale": 0.72,
    "target_resolution": (832,480),
    "fps":16
}
PROMPT = {
    "positive": "2D comic illustration, consistent character facial feature, slow camera pan, soft global illumination, stable frame to frame, hand drawn manga style, subtle natural motion",
    "negative": "face distortion, anatomy error, frame flicker, color jitter, watermark, text, blur, high distortion, low resolution"
}
# ===================== 显存优化策略 =====================
torch.backends.cudnn.benchmark = True
quant_config = {
    "torch_dtype": torch.float8_e4m3fn,
    "device_map": "auto"
}
def build_pipeline():
    pipe = Wan22ImageToVideoPipeline.from_pretrained(
        pretrained_model_name_or_path=None,
        unet_pretrained_model_name_or_path=MODEL_CFG["unet_path"],
        vae_pretrained_model_name_or_path=MODEL_CFG["vae_path"],
        text_encoder_pretrained_model_name_or_path=MODEL_CFG["text_encoder_path"],
        torch_dtype=torch.float16,
        **quant_config
    )
    # 加载VBVR时序一致性LoRA
    lora_weights = load_file(MODEL_CFG["lora_path"])
    pipe.load_lora_weights(lora_weights, lora_scale=INFER_CFG["lora_scale"])
    pipe.enable_vae_slicing()
    pipe.enable_attention_slicing()
    pipe.enable_model_cpu_offload()
    return pipe
def preprocess_image(img_path, target_size):
    img = Image.open(img_path).convert("RGB")
    img = img.resize(target_size)
    return img
if __name__ == "__main__":
    pipe = build_pipeline()
    input_image = preprocess_image(INFER_CFG["input_img"], INFER_CFG["target_resolution"])
    result = pipe.image_to_video(
        image=input_image,
        prompt=PROMPT["positive"],
        negative_prompt=PROMPT["negative"],
        num_inference_steps=INFER_CFG["num_inference_steps"],
        guidance_scale=INFER_CFG["guidance_scale"],
        num_frames=INFER_CFG["num_frames"]
    )
    result.save(INFER_CFG["output_video"], result.frames[0], fps=INFER_CFG["fps"])
    print(f"Inference complete, artifact saved to {INFER_CFG['output_video']}")

import torch
def get_vram_stat():
    if torch.cuda.is_available():
        alloc = torch.cuda.memory_allocated(0) / 1024**3
        reserved = torch.cuda.memory_reserved(0) / 1024**3
        print(f"VRAM Allocated: {alloc:.2f} GB")
        print(f"VRAM Reserved: {reserved:.2f} GB")
    else:
        print("CUDA device unavailable")
if __name__ == "__main__":
    get_vram_stat()

# Linux
export PYTORCH_CUDA_ALLOC_CONF="expandable_segments:True,max_split_size_mb:128"

# Windows PowerShell
$env:PYTORCH_CUDA_ALLOC_CONF="expandable_segments:True,max_split_size_mb:128"

import os
def batch_inference(pipe, img_folder, out_folder):
    os.makedirs(out_folder, exist_ok=True)
    img_list = sorted([x for x in os.listdir(img_folder) if x.lower().endswith(("png","jpg","jpeg"))])
    for idx, img_name in enumerate(img_list):
        full_img_path = os.path.join(img_folder, img_name)
        out_path = os.path.join(out_folder, f"seg_{idx:03d}.mp4")
        print(f"Processing {full_img_path} -> {out_path}")
        input_img = preprocess_image(full_img_path, INFER_CFG["target_resolution"])
        res = pipe.image_to_video(
            image=input_img,
            prompt=PROMPT["positive"],
            negative_prompt=PROMPT["negative"],
            num_inference_steps=INFER_CFG["num_inference_steps"],
            guidance_scale=INFER_CFG["guidance_scale"],
            num_frames=INFER_CFG["num_frames"]
        )
        res.save(out_path, res.frames[0], fps=INFER_CFG["fps"])

# filelist.txt
# file seg_000.mp4
# file seg_001.mp4
# file seg_002.mp4
ffmpeg -f concat -safe 0 -i filelist.txt -c copy comic_final_lossless.mp4