Spaces:
Sleeping
Sleeping
Download model/pipeline.py from opieme/HighQualityVideoGeneration: direct link, hf CLI and curl.
- Browser
- Download file 7.88 kB
-
https://huggingface.co/spaces/opieme/HighQualityVideoGeneration/resolve/main/model/pipeline.py
- Command line
-
hf download hf://spaces/opieme/HighQualityVideoGeneration/model/pipeline.py
-
curl -L -o pipeline.py https://huggingface.co/spaces/opieme/HighQualityVideoGeneration/resolve/main/model/pipeline.py
7.88 kB
| """WAMU_v3 image-to-video pipeline loading and sizing helpers. | |
| Weight quantization (below) shrinks the full bf16 pipe from ~69GB, which made ZeroGPU's per-call | |
| GPU init (loading the packed weights onto the GPU) exceed the requested call duration. The | |
| transformers additionally get an AOT-compiled forward (FR-6) via `spaces.aoti_load()`, matching | |
| the reference project: this is what makes `Float8DynamicActivationFloat8WeightConfig` (fp8x8 | |
| matmuls, both weights and activations quantized) safe to run. AOTInductor pre-plans a single | |
| memory pool for every op in the compiled graph, including that config's per-layer | |
| activation-quantize casts; run the same config eagerly (no AOT), as an earlier version of this | |
| file did, and every one of those casts is an unplanned CUDA allocator request instead — that | |
| churn reliably crashed ZeroGPU with an NVML assert (#35), fixed at the time by downgrading to | |
| weight-only fp8 (no runtime activation quantization) as a stopgap. See #36 for the AOT | |
| investigation (package-reuse feasibility) that unblocked switching back. | |
| """ | |
| from __future__ import annotations | |
| import spaces | |
| import torch | |
| import torch._dynamo | |
| from diffusers.pipelines.wan.pipeline_wan_i2v import WanImageToVideoPipeline | |
| from PIL import Image | |
| from torchao.quantization import Float8DynamicActivationFloat8WeightConfig, Int8WeightOnlyConfig, quantize_ | |
| MODEL_ID = "thornmaze/WAMU_v3_WAN2.2_I2V_LIGHTNING" | |
| # Precompiled AOT package for the transformer, from the reference project (zerogpu-aoti's | |
| # wan2-2-fp8da-aoti-faster Space). Confirmed reusable for WAMU_v3 without recompiling (#36): | |
| # WAMU_v3's transformer/transformer_2 share the exact same config (layer count, head dims, etc.) | |
| # as the Wan2.2-I2V-A14B base model this package was compiled against — `spaces.aoti_load()` | |
| # applies compiled kernels to an already-loaded model rather than embedding weights, so | |
| # compatibility hinges on that shape/architecture match, not on WAMU_v3's fine-tuned weight | |
| # values. "sm120" in the name matches ZeroGPU's current hardware (RTX Pro 6000 Blackwell). | |
| AOTI_TRANSFORMER_REPO = "thornmaze/WanTransformer3DModel-sm120-cu130-raa" | |
| MAX_DIM = 832 | |
| MIN_DIM = 480 | |
| SQUARE_DIM = 640 | |
| MULTIPLE_OF = 16 | |
| FIXED_FPS = 16 | |
| MIN_FRAMES_MODEL = 8 | |
| MAX_FRAMES_MODEL = 321 | |
| MIN_DURATION = round(MIN_FRAMES_MODEL / FIXED_FPS, 1) | |
| MAX_DURATION = round(MAX_FRAMES_MODEL / FIXED_FPS, 1) | |
| DEFAULT_PROMPT = "make this image come alive, cinematic motion, smooth animation" | |
| DEFAULT_NEGATIVE_PROMPT = ( | |
| "色调艳丽, 过曝, 静态, 细节模糊不清, 字幕, 风格, 作品, 画作, 画面, 静止, 整体发灰, " | |
| "最差质量, 低质量, JPEG压缩残留, 丑陋的, 残缺的, 多余的手指, 画得不好的手部, " | |
| "画得不好的脸部, 畸形的, 毁容的, 形态畸形的肢体, 手指融合, 静止不动的画面, " | |
| "杂乱的背景, 三条腿, 背景人很多, 倒着走" | |
| ) | |
| def load_pipeline() -> WanImageToVideoPipeline: | |
| pipe = WanImageToVideoPipeline.from_pretrained(MODEL_ID, torch_dtype=torch.bfloat16).to("cuda") | |
| # Quantize to shrink the ~69GB bf16 pipe (drops per-call ZeroGPU init time and peak memory). | |
| quantize_(pipe.text_encoder, Int8WeightOnlyConfig()) | |
| torch._dynamo.reset() | |
| quantize_(pipe.transformer, Float8DynamicActivationFloat8WeightConfig()) | |
| torch._dynamo.reset() | |
| quantize_(pipe.transformer_2, Float8DynamicActivationFloat8WeightConfig()) | |
| torch._dynamo.reset() | |
| # AOT-compile the transformers (FR-6) — see module docstring and #36 for why this must come | |
| # after the dynamic-activation quantize_() calls above, not before: the compiled graph is | |
| # built from (and expects) that config's op layout, matching how the reference project's own | |
| # usage example sequences it. | |
| # | |
| # Not yet validated against this repo's pinned torch==2.11.0: the package was compiled with | |
| # torch==2.9.1+cu130, and AOTInductor artifacts can be ABI-sensitive across torch minor | |
| # versions. Needs real-GPU testing on the dev Space — if loading fails here, the fallback is | |
| # either pinning torch back to 2.9.1 or recompiling this package against 2.11.0. | |
| spaces.aoti_load(module=pipe.transformer, repo_id=AOTI_TRANSFORMER_REPO) | |
| spaces.aoti_load(module=pipe.transformer_2, repo_id=AOTI_TRANSFORMER_REPO) | |
| return pipe | |
| def resize_image(image: Image.Image) -> Image.Image: | |
| """Resize/crop to the model's supported dimension range, keeping a multiple-of-16 size.""" | |
| width, height = image.size | |
| if width == height: | |
| return image.resize((SQUARE_DIM, SQUARE_DIM), Image.Resampling.LANCZOS) | |
| aspect_ratio = width / height | |
| max_ar = MAX_DIM / MIN_DIM | |
| min_ar = MIN_DIM / MAX_DIM | |
| image_to_resize = image | |
| if aspect_ratio > max_ar: | |
| crop_width = int(round(height * max_ar)) | |
| left = (width - crop_width) // 2 | |
| image_to_resize = image.crop((left, 0, left + crop_width, height)) | |
| target_w, target_h = MAX_DIM, MIN_DIM | |
| elif aspect_ratio < min_ar: | |
| crop_height = int(round(width / min_ar)) | |
| top = (height - crop_height) // 2 | |
| image_to_resize = image.crop((0, top, width, top + crop_height)) | |
| target_w, target_h = MIN_DIM, MAX_DIM | |
| else: | |
| if width > height: | |
| target_w = MAX_DIM | |
| target_h = int(round(target_w / aspect_ratio)) | |
| else: | |
| target_h = MAX_DIM | |
| target_w = int(round(target_h * aspect_ratio)) | |
| final_w = max(MIN_DIM, min(MAX_DIM, round(target_w / MULTIPLE_OF) * MULTIPLE_OF)) | |
| final_h = max(MIN_DIM, min(MAX_DIM, round(target_h / MULTIPLE_OF) * MULTIPLE_OF)) | |
| return image_to_resize.resize((final_w, final_h), Image.Resampling.LANCZOS) | |
| def resize_and_crop_to_match(target_image: Image.Image, reference_image: Image.Image) -> Image.Image: | |
| """Resize/crop `target_image` to exactly match `reference_image`'s size (the pipeline requires | |
| the first and last frame to share dimensions).""" | |
| 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_num_frames(duration_seconds: float) -> int: | |
| raw = int(round(duration_seconds * FIXED_FPS)) | |
| raw = max(MIN_FRAMES_MODEL, min(MAX_FRAMES_MODEL, raw)) | |
| return ((raw - 1) // 4) * 4 + 1 | |
| def estimate_generation_seconds( | |
| width: int, height: int, num_frames: int, steps: int, guidance_scale: float | |
| ) -> float: | |
| """Rough @spaces.GPU duration budget, calibrated from the reference wan2-2-i2v-v3 Space. | |
| Exact limits are still an open item (SRS Section 4, #3) pending empirical testing on the | |
| dev Space; this heuristic is a starting point, not a final calibration. | |
| Kept conservative even now that the transformers are AOT-compiled (#36): the reference | |
| project's numbers below assume a validated AOT setup, and ours hasn't been measured on real | |
| GPU yet (see load_pipeline's AOT caveat) — recalibrate once that's confirmed working. | |
| """ | |
| base_frames_height_width = 81 * 832 * 624 | |
| base_step_duration = 5.0 | |
| factor = num_frames * width * height / base_frames_height_width | |
| step_duration = base_step_duration * float(factor**1.5) | |
| gen_time = steps * step_duration | |
| if guidance_scale > 1: | |
| gen_time *= 2.4 | |
| # Padded well above the reference project's flat overhead (its pipe loads a validated AOT | |
| # setup already proven on its own GPU quota) until ours is confirmed working and measured | |
| # empirically on the dev Space (#36). | |
| init_overhead = 60 | |
| return init_overhead + gen_time | |