Release WAN Fun Control LoRA: training step 1600, 4-step CFG-free inference

README.md

@@ -0,0 +1,178 @@
+---
+license: other
+base_model: alibaba-pai/Wan2.2-Fun-5B-Control
+base_model_relation: adapter
+library_name: peft
+pipeline_tag: video-to-video
+model_name: WAN Fun LoRA - 5B Control - train step 1600 - 4-step CFG-free (CFG 1)
+language:
+  - en
+  - zh
+datasets:
+  - Yanbin99/Depth-Normal-Videos-42K
+  - fal/cosmos-openvid-1m
+tags:
+  - wan2.2
+  - wan-fun
+  - controlnet
+  - depth-control
+  - lora
+  - dmd
+  - non-ar
+  - four-step
+  - cfg-free
+  - cfg1
+  - step1600
+  - rank64
+---
+
+# WAN Fun LoRA: 5B Control, step 1600, 4-step, CFG 1
+
+This is the **training-step-1600 generator LoRA** distilled directly on
+[alibaba-pai/Wan2.2-Fun-5B-Control](https://huggingface.co/alibaba-pai/Wan2.2-Fun-5B-Control)
+using prompt + dynamic Depth video pairs. It is intended for **four denoising
+steps with `guidance_scale=1.0`**, which disables classifier-free guidance.
+
+中文：这是专门在 **Wan2.2-Fun-5B-Control** 上训练的 DMD LoRA。发布训练
+**1600 step** 检查点；推理 **4 steps、CFG=1（关闭 CFG）**。它就是本次
+PAI-Bench-C Depth 评测使用的权重。训练时 generator、teacher、critic 均加载
+完整 Fun-Control 模型；发布文件仅包含推理所需的 generator LoRA。
+
+| Setting | Value |
+| --- | --- |
+| Training checkpoint | **step 1600** |
+| Inference denoising steps | **4** |
+| Inference CFG | **1.0, conditional-only, no CFG branch** |
+| LoRA strength | **1.0** |
+| Rank / alpha | 64 / 64 |
+| Scheduler | VideoX-Fun `FlowUniPCMultistepScheduler` |
+| Scheduler configuration shift / runtime shift | 1.0 / 5.0 |
+| Observed four timesteps | `[999, 937, 833, 624]` |
+| TeaCache | Disabled for four-step inference |
+| Base revision used | `b8bc1a65ab71d054ba4636dc0dac104aa4df2686` |
+
+`step1600` describes the saved training iteration. `4Step` describes inference.
+CFG and LoRA strength are separate settings. The LoRA residual is
+`strength * (alpha/rank) * (B @ A)`.
+
+During DMD training the teacher used `real_guidance_scale=3`, with the formula
+`conditional + 3 * (conditional - unconditional)`. This corresponds to a
+conventional teacher CFG scale of **4**, while the student/critic branch and
+the released inference recipe use conventional **CFG 1**.
+
+## Training and provenance
+
+The run used two nodes with eight H100 GPUs each, microbatch one per GPU,
+gradient accumulation two, and effective global batch 32. It reused the exact
+5,000 prompt + dynamic-depth pairs from the preceding ControlNet Depth run:
+
+- Depth videos: [Yanbin99/Depth-Normal-Videos-42K](https://huggingface.co/datasets/Yanbin99/Depth-Normal-Videos-42K), revision `9c5d205edd71077bbab7d96cae971a25a1fbf91f`.
+- Corresponding captions: [fal/cosmos-openvid-1m](https://huggingface.co/datasets/fal/cosmos-openvid-1m), revision `10b41fc29006eff62ff64b8795b8ae8ef7ff9cde`.
+- Training geometry: 832 x 480, 93 raw video frames, 24 latent frames.
+- Generator, frozen teacher, and trainable critic each load the full Fun-Control DiT.
+- Generator and critic have independent rank-64 adapters; the teacher is frozen.
+
+The published adapter contains 600 FP32 tensors over 300 Linear layers in
+30 blocks: self-attention q/k/v/o, cross-attention q/k/v/o, and FFN 0/2.
+There are 161,218,560 adapter parameters. The full Fun-Control backbone and
+its learned control conditioning remain required.
+
+The source training bundle SHA256 is
+`47f94f7fc85ed53b5480b28c2bfa3a05659bcf4aeb1278004c0860224787e78a`.
+Both exported formats were compared tensor-by-tensor to its `generator_lora`
+state. All 3,600 LoRA video inference receipts from this evaluation record
+the same source checksum, complete loading of 600 tensors / 300 target layers,
+four denoising steps and CFG 1.
+
+## Loading
+
+Use the native VideoX-Fun Wan2.2-Fun-5B-Control pipeline. The evaluated
+VideoX-Fun source revision was `1fd9ed9208ba280f6b48c542a7739e636f4e2a14`.
+Start from its [5B Control example](https://github.com/aigc-apps/VideoX-Fun/blob/1fd9ed9208ba280f6b48c542a7739e636f4e2a14/examples/wan2.2_fun/predict_v2v_control_5b.py).
+
+Download the adapter and loader:
+
+```python
+from huggingface_hub import snapshot_download
+
+release = snapshot_download(
+    "Perflow-Shuai/WAN-Fun-LoRA-5B-Control-4Step-CFG1-step1600",
+    allow_patterns=["generator_lora.pt", "perflow_lora.py", "load_wan_fun_lora.py"],
+)
+```
+
+After the example loads the full Control transformer, and **before** applying
+CPU/group offloading, attach this adapter once:
+
+```python
+import sys
+from pathlib import Path
+
+sys.path.insert(0, release)
+from load_wan_fun_lora import load_wan_fun_lora
+
+receipt = load_wan_fun_lora(
+    transformer,
+    Path(release) / "generator_lora.pt",
+    strength=1.0,
+)
+assert receipt["loaded_targets"] == 300
+assert receipt["loaded_tensors"] == 600
+```
+
+In that example, set `sampler_name="Flow_Unipc"`, `num_inference_steps=4`,
+`guidance_scale=1.0`, `shift=5`, and `enable_teacache=False`. Its UniPC branch
+sets the scheduler constructor's shift to 1 and the pipeline call applies
+runtime shift 5. Supply your prompt and dynamic depth video via its existing
+control-video inputs. Preserve the model's depth/inpainting/reference
+conditioning preprocessing, including the learned `ref_conv` behavior.
+
+`adapter_model.safetensors` plus `adapter_config.json` is the equivalent
+PEFT/native-Wan export. Keys use `blocks.*.self_attn.*`, `cross_attn.*`, and
+`ffn.*`. Diffusers-specific key conversion and generic ComfyUI LoRA loading
+were not validated for this release. The included loader takes
+`generator_lora.pt`; its shared implementation is in `perflow_lora.py`.
+
+## PAI-Bench-C Depth evaluation
+
+We evaluated 600 Depth cases, with six prompt variants per control for
+diversity (3,600 generated videos per local model). Local outputs use 121
+frames at 24 FPS and seed 43. The four-step variants use identical inputs,
+resolution, seed and scheduler; their difference is this adapter at strength 1.
+
+| Model | Blur SSIM ↑ | Edge F1 ↑ | Depth si-RMSE ↓ | Mask mIoU ↑ | Quality ↑ | Diversity ↑ |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: |
+| Official reported Wan2.2-Fun-5B-Control | 0.556 | 0.106 | 1.819 | 0.615 | 9.317 | 0.481 |
+| Local base, 40 steps, CFG 6, TeaCache | 0.557 | 0.099 | 4.836 | 0.600 | 8.962 | 0.474 |
+| Local base, 4 steps, CFG 1 | 0.682 | 0.089 | 2.654 | 0.637 | 8.896 | 0.248 |
+| **WAN Fun LoRA step1600, 4 steps, CFG 1** | **0.544** | **0.092** | **1.805** | **0.589** | **9.290** | **0.458** |
+
+The official row is quoted from [PAI-Bench](https://github.com/SHI-Labs/physical-ai-bench)
+and was not run by us. Local main metrics use its contemporaneous legacy
+evaluator; diversity uses the current implementation, whose source is identical
+across the two snapshots. Exact revisions and values are in `evaluation.json`.
+The official run's private configuration is unavailable, so the local multistep
+row is a best-effort reproduction. Legacy depth RMSE has outliers; these rows
+should not be read as proof that the LoRA surpasses the official base overall.
+
+Compared with direct four-step inference, this LoRA improves Depth, Quality,
+Diversity and slightly Edge F1, while Blur SSIM and Mask mIoU decrease.
+Blur SSIM measures similarity after blurring and is not a sharpness metric.
+The adapter was trained for Depth; other control modalities and transfer to
+unmodified Wan backbones are not established by these results.
+
+## Files and terms
+
+- `generator_lora.pt`: generator-only payload with `generator_lora` and `step`.
+- `adapter_model.safetensors`, `adapter_config.json`: equivalent FP32 adapter.
+- `load_wan_fun_lora.py`, `perflow_lora.py`: strict native-Wan loader.
+- `training_config.yaml`, `inference_config.yaml`: training and inference settings.
+- `release_metadata.json`, `provenance.json`, `evaluation.json`, `SHA256SUMS`: provenance, measured results and checksums.
+
+The upstream [Fun-Control model card](https://huggingface.co/alibaba-pai/Wan2.2-Fun-5B-Control)
+declares Apache-2.0; the linked depth dataset declares MIT and the caption
+dataset declares Apache-2.0. This release follows the preceding depth-conditioned
+adapter's `license: other` designation because upstream source-video rights
+are not established by those dataset labels alone. Consult the respective
+upstream terms. Original training videos, captions, base-model weights and
+critic weights are not redistributed here.

SHA256SUMS

@@ -0,0 +1,11 @@
+f9497abecbce0e35c2a8242066adbbbb41b9b2a94829d8fdc4200cf6e6790a72  README.md
+13c103b922401eeb48aeb84d1c8533c3aa4a8a514aaad329d4f960ed7d01bd56  adapter_config.json
+cb06b699fe5bdbb9e5750ca177bf61e74fbb32d150e4dcaf55f9141b0f169278  adapter_model.safetensors
+e173b37254baa5945aa52d23dd2faf28f0f49a41f9c24e3864d9100ef9967150  evaluation.json
+12946fdfac2a99643f259e721764b728e6e905c1e838e104c24b87b0757facc8  generator_lora.pt
+6fafca458ab88bc032c17c8ade3a24e2861143a9cd0aab70f1e7cfb1cc0203f7  inference_config.yaml
+73748f6691dc826acaf87ef2bc1c0ae5b9dea79c0bdc3418f40bf480dded3be4  load_wan_fun_lora.py
+4ee88e7cfb4d803f97622809d5f483187a061b7f53d77748b5850e438dba08b8  perflow_lora.py
+7ba884eb930d768d626385261e7a8d6ab8c645ef064b9b07da57347d84c32a85  provenance.json
+7fe349696daf2c5574f2cc74615684bd9e74aa9f9ed44416cbc050a3fd905836  release_metadata.json
+2e7640e256ca8192cc4988ab19119f86d350440438cac2d3a782dc43a1166108  training_config.yaml

adapter_config.json

@@ -0,0 +1,317 @@
+{
+  "base_model_name_or_path": "alibaba-pai/Wan2.2-Fun-5B-Control",
+  "bias": "none",
+  "fan_in_fan_out": false,
+  "inference_mode": true,
+  "init_lora_weights": true,
+  "lora_alpha": 64,
+  "lora_dropout": 0.0,
+  "modules_to_save": null,
+  "peft_type": "LORA",
+  "r": 64,
+  "revision": "b8bc1a65ab71d054ba4636dc0dac104aa4df2686",
+  "target_modules": [
+    "blocks.0.cross_attn.k",
+    "blocks.0.cross_attn.o",
+    "blocks.0.cross_attn.q",
+    "blocks.0.cross_attn.v",
+    "blocks.0.ffn.0",
+    "blocks.0.ffn.2",
+    "blocks.0.self_attn.k",
+    "blocks.0.self_attn.o",
+    "blocks.0.self_attn.q",
+    "blocks.0.self_attn.v",
+    "blocks.1.cross_attn.k",
+    "blocks.1.cross_attn.o",
+    "blocks.1.cross_attn.q",
+    "blocks.1.cross_attn.v",
+    "blocks.1.ffn.0",
+    "blocks.1.ffn.2",
+    "blocks.1.self_attn.k",
+    "blocks.1.self_attn.o",
+    "blocks.1.self_attn.q",
+    "blocks.1.self_attn.v",
+    "blocks.10.cross_attn.k",
+    "blocks.10.cross_attn.o",
+    "blocks.10.cross_attn.q",
+    "blocks.10.cross_attn.v",
+    "blocks.10.ffn.0",
+    "blocks.10.ffn.2",
+    "blocks.10.self_attn.k",
+    "blocks.10.self_attn.o",
+    "blocks.10.self_attn.q",
+    "blocks.10.self_attn.v",
+    "blocks.11.cross_attn.k",
+    "blocks.11.cross_attn.o",
+    "blocks.11.cross_attn.q",
+    "blocks.11.cross_attn.v",
+    "blocks.11.ffn.0",
+    "blocks.11.ffn.2",
+    "blocks.11.self_attn.k",
+    "blocks.11.self_attn.o",
+    "blocks.11.self_attn.q",
+    "blocks.11.self_attn.v",
+    "blocks.12.cross_attn.k",
+    "blocks.12.cross_attn.o",
+    "blocks.12.cross_attn.q",
+    "blocks.12.cross_attn.v",
+    "blocks.12.ffn.0",
+    "blocks.12.ffn.2",
+    "blocks.12.self_attn.k",
+    "blocks.12.self_attn.o",
+    "blocks.12.self_attn.q",
+    "blocks.12.self_attn.v",
+    "blocks.13.cross_attn.k",
+    "blocks.13.cross_attn.o",
+    "blocks.13.cross_attn.q",
+    "blocks.13.cross_attn.v",
+    "blocks.13.ffn.0",
+    "blocks.13.ffn.2",
+    "blocks.13.self_attn.k",
+    "blocks.13.self_attn.o",
+    "blocks.13.self_attn.q",
+    "blocks.13.self_attn.v",
+    "blocks.14.cross_attn.k",
+    "blocks.14.cross_attn.o",
+    "blocks.14.cross_attn.q",
+    "blocks.14.cross_attn.v",
+    "blocks.14.ffn.0",
+    "blocks.14.ffn.2",
+    "blocks.14.self_attn.k",
+    "blocks.14.self_attn.o",
+    "blocks.14.self_attn.q",
+    "blocks.14.self_attn.v",
+    "blocks.15.cross_attn.k",
+    "blocks.15.cross_attn.o",
+    "blocks.15.cross_attn.q",
+    "blocks.15.cross_attn.v",
+    "blocks.15.ffn.0",
+    "blocks.15.ffn.2",
+    "blocks.15.self_attn.k",
+    "blocks.15.self_attn.o",
+    "blocks.15.self_attn.q",
+    "blocks.15.self_attn.v",
+    "blocks.16.cross_attn.k",
+    "blocks.16.cross_attn.o",
+    "blocks.16.cross_attn.q",
+    "blocks.16.cross_attn.v",
+    "blocks.16.ffn.0",
+    "blocks.16.ffn.2",
+    "blocks.16.self_attn.k",
+    "blocks.16.self_attn.o",
+    "blocks.16.self_attn.q",
+    "blocks.16.self_attn.v",
+    "blocks.17.cross_attn.k",
+    "blocks.17.cross_attn.o",
+    "blocks.17.cross_attn.q",
+    "blocks.17.cross_attn.v",
+    "blocks.17.ffn.0",
+    "blocks.17.ffn.2",
+    "blocks.17.self_attn.k",
+    "blocks.17.self_attn.o",
+    "blocks.17.self_attn.q",
+    "blocks.17.self_attn.v",
+    "blocks.18.cross_attn.k",
+    "blocks.18.cross_attn.o",
+    "blocks.18.cross_attn.q",
+    "blocks.18.cross_attn.v",
+    "blocks.18.ffn.0",
+    "blocks.18.ffn.2",
+    "blocks.18.self_attn.k",
+    "blocks.18.self_attn.o",
+    "blocks.18.self_attn.q",
+    "blocks.18.self_attn.v",
+    "blocks.19.cross_attn.k",
+    "blocks.19.cross_attn.o",
+    "blocks.19.cross_attn.q",
+    "blocks.19.cross_attn.v",
+    "blocks.19.ffn.0",
+    "blocks.19.ffn.2",
+    "blocks.19.self_attn.k",
+    "blocks.19.self_attn.o",
+    "blocks.19.self_attn.q",
+    "blocks.19.self_attn.v",
+    "blocks.2.cross_attn.k",
+    "blocks.2.cross_attn.o",
+    "blocks.2.cross_attn.q",
+    "blocks.2.cross_attn.v",
+    "blocks.2.ffn.0",
+    "blocks.2.ffn.2",
+    "blocks.2.self_attn.k",
+    "blocks.2.self_attn.o",
+    "blocks.2.self_attn.q",
+    "blocks.2.self_attn.v",
+    "blocks.20.cross_attn.k",
+    "blocks.20.cross_attn.o",
+    "blocks.20.cross_attn.q",
+    "blocks.20.cross_attn.v",
+    "blocks.20.ffn.0",
+    "blocks.20.ffn.2",
+    "blocks.20.self_attn.k",
+    "blocks.20.self_attn.o",
+    "blocks.20.self_attn.q",
+    "blocks.20.self_attn.v",
+    "blocks.21.cross_attn.k",
+    "blocks.21.cross_attn.o",
+    "blocks.21.cross_attn.q",
+    "blocks.21.cross_attn.v",
+    "blocks.21.ffn.0",
+    "blocks.21.ffn.2",
+    "blocks.21.self_attn.k",
+    "blocks.21.self_attn.o",
+    "blocks.21.self_attn.q",
+    "blocks.21.self_attn.v",
+    "blocks.22.cross_attn.k",
+    "blocks.22.cross_attn.o",
+    "blocks.22.cross_attn.q",
+    "blocks.22.cross_attn.v",
+    "blocks.22.ffn.0",
+    "blocks.22.ffn.2",
+    "blocks.22.self_attn.k",
+    "blocks.22.self_attn.o",
+    "blocks.22.self_attn.q",
+    "blocks.22.self_attn.v",
+    "blocks.23.cross_attn.k",
+    "blocks.23.cross_attn.o",
+    "blocks.23.cross_attn.q",
+    "blocks.23.cross_attn.v",
+    "blocks.23.ffn.0",
+    "blocks.23.ffn.2",
+    "blocks.23.self_attn.k",
+    "blocks.23.self_attn.o",
+    "blocks.23.self_attn.q",
+    "blocks.23.self_attn.v",
+    "blocks.24.cross_attn.k",
+    "blocks.24.cross_attn.o",
+    "blocks.24.cross_attn.q",
+    "blocks.24.cross_attn.v",
+    "blocks.24.ffn.0",
+    "blocks.24.ffn.2",
+    "blocks.24.self_attn.k",
+    "blocks.24.self_attn.o",
+    "blocks.24.self_attn.q",
+    "blocks.24.self_attn.v",
+    "blocks.25.cross_attn.k",
+    "blocks.25.cross_attn.o",
+    "blocks.25.cross_attn.q",
+    "blocks.25.cross_attn.v",
+    "blocks.25.ffn.0",
+    "blocks.25.ffn.2",
+    "blocks.25.self_attn.k",
+    "blocks.25.self_attn.o",
+    "blocks.25.self_attn.q",
+    "blocks.25.self_attn.v",
+    "blocks.26.cross_attn.k",
+    "blocks.26.cross_attn.o",
+    "blocks.26.cross_attn.q",
+    "blocks.26.cross_attn.v",
+    "blocks.26.ffn.0",
+    "blocks.26.ffn.2",
+    "blocks.26.self_attn.k",
+    "blocks.26.self_attn.o",
+    "blocks.26.self_attn.q",
+    "blocks.26.self_attn.v",
+    "blocks.27.cross_attn.k",
+    "blocks.27.cross_attn.o",
+    "blocks.27.cross_attn.q",
+    "blocks.27.cross_attn.v",
+    "blocks.27.ffn.0",
+    "blocks.27.ffn.2",
+    "blocks.27.self_attn.k",
+    "blocks.27.self_attn.o",
+    "blocks.27.self_attn.q",
+    "blocks.27.self_attn.v",
+    "blocks.28.cross_attn.k",
+    "blocks.28.cross_attn.o",
+    "blocks.28.cross_attn.q",
+    "blocks.28.cross_attn.v",
+    "blocks.28.ffn.0",
+    "blocks.28.ffn.2",
+    "blocks.28.self_attn.k",
+    "blocks.28.self_attn.o",
+    "blocks.28.self_attn.q",
+    "blocks.28.self_attn.v",
+    "blocks.29.cross_attn.k",
+    "blocks.29.cross_attn.o",
+    "blocks.29.cross_attn.q",
+    "blocks.29.cross_attn.v",
+    "blocks.29.ffn.0",
+    "blocks.29.ffn.2",
+    "blocks.29.self_attn.k",
+    "blocks.29.self_attn.o",
+    "blocks.29.self_attn.q",
+    "blocks.29.self_attn.v",
+    "blocks.3.cross_attn.k",
+    "blocks.3.cross_attn.o",
+    "blocks.3.cross_attn.q",
+    "blocks.3.cross_attn.v",
+    "blocks.3.ffn.0",
+    "blocks.3.ffn.2",
+    "blocks.3.self_attn.k",
+    "blocks.3.self_attn.o",
+    "blocks.3.self_attn.q",
+    "blocks.3.self_attn.v",
+    "blocks.4.cross_attn.k",
+    "blocks.4.cross_attn.o",
+    "blocks.4.cross_attn.q",
+    "blocks.4.cross_attn.v",
+    "blocks.4.ffn.0",
+    "blocks.4.ffn.2",
+    "blocks.4.self_attn.k",
+    "blocks.4.self_attn.o",
+    "blocks.4.self_attn.q",
+    "blocks.4.self_attn.v",
+    "blocks.5.cross_attn.k",
+    "blocks.5.cross_attn.o",
+    "blocks.5.cross_attn.q",
+    "blocks.5.cross_attn.v",
+    "blocks.5.ffn.0",
+    "blocks.5.ffn.2",
+    "blocks.5.self_attn.k",
+    "blocks.5.self_attn.o",
+    "blocks.5.self_attn.q",
+    "blocks.5.self_attn.v",
+    "blocks.6.cross_attn.k",
+    "blocks.6.cross_attn.o",
+    "blocks.6.cross_attn.q",
+    "blocks.6.cross_attn.v",
+    "blocks.6.ffn.0",
+    "blocks.6.ffn.2",
+    "blocks.6.self_attn.k",
+    "blocks.6.self_attn.o",
+    "blocks.6.self_attn.q",
+    "blocks.6.self_attn.v",
+    "blocks.7.cross_attn.k",
+    "blocks.7.cross_attn.o",
+    "blocks.7.cross_attn.q",
+    "blocks.7.cross_attn.v",
+    "blocks.7.ffn.0",
+    "blocks.7.ffn.2",
+    "blocks.7.self_attn.k",
+    "blocks.7.self_attn.o",
+    "blocks.7.self_attn.q",
+    "blocks.7.self_attn.v",
+    "blocks.8.cross_attn.k",
+    "blocks.8.cross_attn.o",
+    "blocks.8.cross_attn.q",
+    "blocks.8.cross_attn.v",
+    "blocks.8.ffn.0",
+    "blocks.8.ffn.2",
+    "blocks.8.self_attn.k",
+    "blocks.8.self_attn.o",
+    "blocks.8.self_attn.q",
+    "blocks.8.self_attn.v",
+    "blocks.9.cross_attn.k",
+    "blocks.9.cross_attn.o",
+    "blocks.9.cross_attn.q",
+    "blocks.9.cross_attn.v",
+    "blocks.9.ffn.0",
+    "blocks.9.ffn.2",
+    "blocks.9.self_attn.k",
+    "blocks.9.self_attn.o",
+    "blocks.9.self_attn.q",
+    "blocks.9.self_attn.v"
+  ],
+  "use_dora": false,
+  "use_rslora": false
+}

adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb06b699fe5bdbb9e5750ca177bf61e74fbb32d150e4dcaf55f9141b0f169278
+size 644949344

evaluation.json

@@ -0,0 +1,166 @@
+{
+  "benchmark": {
+    "comparability_note": "The official row predates the current deterministic/original-byte DOVER and capped depth-residual fixes; no official run-level artifact identifies the exact private evaluator or generation configuration.",
+    "contemporaneous_legacy": {
+      "commit": "1b84911a64d9d73c3267fa74baa640fab336b7e0",
+      "source_files": {
+        "conditional_generation/benchmark_pipelines/scores/transfer_bench/metrics_canny_blur_depth.py": {
+          "bytes": 11376,
+          "sha256": "63b9178580a72395be8ffdd841a5717a8d84f43e9f80e8736d6d802adc15bfb3"
+        },
+        "conditional_generation/compute_diversity_score.py": {
+          "bytes": 11408,
+          "sha256": "c3c48fefcf8fd3b31692869300d43feeca4b95a67a65f5b6a9039a7e9140b0f1"
+        },
+        "conditional_generation/compute_metrics.py": {
+          "bytes": 30773,
+          "sha256": "7cbb66e4c5fea2a4ac4a538614577c6ccc42f92f5f5c825fb86241f5538b0d13"
+        },
+        "conditional_generation/models/dover.py": {
+          "bytes": 8856,
+          "sha256": "8e0729e2d37b34f0ee4f1d055a0863c1f6fd49f2bea7b705c7843fb87b4b0ed2"
+        },
+        "conditional_generation/pyproject.toml": {
+          "bytes": 1206,
+          "sha256": "646ec4e39a9946eaab8e93f4aa4cf3fab10c9aea85e08257e920f1c255233b28"
+        }
+      }
+    },
+    "current": {
+      "commit": "2f3b687410029b98397fbc51fa4de36bfd45627d",
+      "source_files": {
+        "conditional_generation/benchmark_pipelines/scores/transfer_bench/metrics_canny_blur_depth.py": {
+          "bytes": 11616,
+          "sha256": "5aa1beabc56d7f0df23b4ef7b049d4adb41c4cab803de3cb620460827a283962"
+        },
+        "conditional_generation/compute_diversity_score.py": {
+          "bytes": 11408,
+          "sha256": "c3c48fefcf8fd3b31692869300d43feeca4b95a67a65f5b6a9039a7e9140b0f1"
+        },
+        "conditional_generation/compute_metrics.py": {
+          "bytes": 30882,
+          "sha256": "5001d3bdc81e579c7792b7f737e6620960e2057e638f2e75d419fb06d3d5556d"
+        },
+        "conditional_generation/models/dover.py": {
+          "bytes": 9354,
+          "sha256": "9473cbb64744a7436c377eab11fa779c52f85cd0782b2db8d7d29539307e9cb3"
+        },
+        "conditional_generation/pyproject.toml": {
+          "bytes": 1206,
+          "sha256": "646ec4e39a9946eaab8e93f4aa4cf3fab10c9aea85e08257e920f1c255233b28"
+        }
+      }
+    },
+    "repository": "https://github.com/SHI-Labs/physical-ai-bench"
+  },
+  "condition": "Depth",
+  "diversity_videos_per_variant": 3600,
+  "main_cases": 600,
+  "metric_definitions": {
+    "blur_ssim": "SSIM between bilaterally blurred source and generated RGB videos; higher is better and it is not a sharpness score",
+    "depth_si_rmse": "Median-scale-aligned depth RMSE per frame using Video Depth Anything estimates; lower is better",
+    "diversity": "Mean VGG-LPIPS over 30 ordered pairs from six prompts sharing one Depth control; higher means more variation",
+    "edge_f1": "F1 between Canny edge maps over all video pixels; higher is better",
+    "mask_miou": "Prompt-grounded SAM2 mask IoU after Hungarian matching; higher is better",
+    "quality_score": "DOVER technical video quality score; higher is better"
+  },
+  "protocol": {
+    "diversity_evaluator": "current",
+    "lora_checkpoint_sha256": "47f94f7fc85ed53b5480b28c2bfa3a05659bcf4aeb1278004c0860224787e78a",
+    "main_evaluator": "legacy",
+    "output_fps": 24,
+    "run_contract_sha256": "0fa06f59d3f8a54041ffd9d0982f4f3608fdd6d3fa024bc9d4e7dde403aaf489",
+    "shared_frames": 121,
+    "shared_seed": 43
+  },
+  "resolution_buckets": [
+    {
+      "count": 200,
+      "generation": "640x480",
+      "input": "640x480",
+      "source": "AgiBot"
+    },
+    {
+      "count": 195,
+      "generation": "1280x704",
+      "input": "1280x720",
+      "source": "OpenDV"
+    },
+    {
+      "count": 3,
+      "generation": "1280x672",
+      "input": "1920x1016",
+      "source": "OpenDV"
+    },
+    {
+      "count": 2,
+      "generation": "1280x544",
+      "input": "1920x808",
+      "source": "OpenDV"
+    },
+    {
+      "count": 200,
+      "generation": "1280x704",
+      "input": "1920x1080",
+      "source": "Ego-Exo4D"
+    }
+  ],
+  "rows": [
+    {
+      "classification": "official_quoted_not_locally_measured",
+      "id": "official_reported",
+      "label": "Wan2.2-Fun-5B-Control (official leaderboard)",
+      "metrics": {
+        "blur_ssim": 0.556,
+        "depth_si_rmse": 1.819,
+        "diversity": 0.481,
+        "edge_f1": 0.106,
+        "mask_miou": 0.615,
+        "quality_score": 9.317
+      },
+      "protocol": "\u5b98\u65b9 leaderboard\uff1b\u914d\u7f6e\u672a\u62ab\u9732"
+    },
+    {
+      "classification": "local_measured",
+      "id": "local_multistep",
+      "label": "Wan2.2-Fun-5B-Control (local multistep)",
+      "metrics": {
+        "blur_ssim": 0.5572094391287489,
+        "depth_si_rmse": 4.836493481093092,
+        "diversity": 0.4744977790738146,
+        "edge_f1": 0.09937129978006591,
+        "mask_miou": 0.6002169333646695,
+        "quality_score": 8.961508704821268
+      },
+      "protocol": "\u672c\u5730 40-step \u00b7 CFG 6 \u00b7 TeaCache"
+    },
+    {
+      "classification": "local_measured",
+      "id": "base4_cfgfree",
+      "label": "Wan2.2-Fun-5B-Control (local direct 4-step)",
+      "metrics": {
+        "blur_ssim": 0.6823773058925994,
+        "depth_si_rmse": 2.6539159381803015,
+        "diversity": 0.24838090770112145,
+        "edge_f1": 0.0889015064608313,
+        "mask_miou": 0.636834080417951,
+        "quality_score": 8.89601070801417
+      },
+      "protocol": "\u672c\u5730 4-step \u00b7 CFG-free \u00b7 no LoRA"
+    },
+    {
+      "classification": "local_measured",
+      "id": "lora1600_4step_cfgfree",
+      "label": "Wan2.2-Fun-5B-Control + DMD LoRA step 1600 (4-step)",
+      "metrics": {
+        "blur_ssim": 0.5439233481351533,
+        "depth_si_rmse": 1.8050484347511278,
+        "diversity": 0.4581396648420228,
+        "edge_f1": 0.09165980415187946,
+        "mask_miou": 0.5890168254077435,
+        "quality_score": 9.290268224477767
+      },
+      "protocol": "\u672c\u5730 4-step \u00b7 CFG-free \u00b7 LoRA step 1600"
+    }
+  ]
+}

generator_lora.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:12946fdfac2a99643f259e721764b728e6e905c1e838e104c24b87b0757facc8
+size 645089990

inference_config.yaml

@@ -0,0 +1,24 @@
+base_model: alibaba-pai/Wan2.2-Fun-5B-Control
+base_model_revision: b8bc1a65ab71d054ba4636dc0dac104aa4df2686
+training_checkpoint_step: 1600
+adapter_file: generator_lora.pt
+num_inference_steps: 4
+guidance_scale: 1.0
+classifier_free_guidance: false
+lora_strength: 1.0
+lora_rank: 64
+lora_alpha: 64
+scheduler: FlowUniPCMultistepScheduler
+scheduler_config_shift: 1.0
+runtime_shift: 5.0
+observed_timesteps:
+- 999
+- 937
+- 833
+- 624
+enable_teacache: false
+evaluation_frames: 121
+evaluation_fps: 24
+training_width: 832
+training_height: 480
+training_raw_frames: 93

load_wan_fun_lora.py

@@ -0,0 +1,25 @@
+"""Load the step-1600 Wan-Fun generator adapter through the evaluated loader."""
+
+from perflow_lora import apply_adapter_strength, attach_wan_lora
+
+
+def load_wan_fun_lora(transformer, checkpoint_path, strength=1.0):
+    """Attach once to a freshly loaded native VideoX-Fun 5B Control transformer.
+
+    ``checkpoint_path`` is the downloaded ``generator_lora.pt``. The returned
+    receipt proves exact target coverage. Call before CPU/group offloading.
+    Safetensors is a separate PEFT-format export, not this function's input.
+    """
+    name = "wan_fun_dmd_step1600"
+    if any(name in getattr(m, "lora_A", {}) for m in transformer.modules()):
+        raise ValueError("Adapter already installed; load a fresh transformer")
+    conv = transformer.patch_embedding
+    if conv.in_channels != 148:
+        raise ValueError("Expected the complete 148-channel Wan2.2-Fun-5B-Control transformer")
+    report = attach_wan_lora(
+        transformer, checkpoint_path, style="native", expected_rank=64,
+        lora_alpha=64, adapter_name=name, checkpoint_kind="wan_fun_control_dmd",
+        report_prefix="WAN_FUN_LORA", expected_step=1600, enabled=True,
+    )
+    report.update(apply_adapter_strength(transformer, adapter_name=name, strength=strength))
+    return report

perflow_lora.py

@@ -0,0 +1,546 @@
+#!/usr/bin/env python3
+"""Strict loaders for Wan2.2-TI2V-5B four-step LoRA checkpoints.
+
+Both the published Perflow checkpoint and the local non-AR DMD checkpoint are
+torch ``model.pt`` files containing ``generator_lora`` and ``critic_lora``.
+Inference must load only the former.  This helper validates all 300 expected
+Wan linear targets before installing a PEFT adapter, and supports both native
+Wan and Diffusers module names.
+"""
+
+from __future__ import annotations
+
+import json
+import hashlib
+import math
+import os
+import re
+from pathlib import Path
+from typing import Any
+
+import torch
+from torch import nn
+
+
+PERFLOW_ADAPTER_NAME = "perflow_step4"
+LOCAL_NONAR_ADAPTER_NAME = "local_nonar_step4"
+# Backward-compatible import for existing callers.
+ADAPTER_NAME = PERFLOW_ADAPTER_NAME
+EXPECTED_BLOCKS = tuple(range(30))
+EXPECTED_SUFFIXES = (
+    "self_attn.q",
+    "self_attn.k",
+    "self_attn.v",
+    "self_attn.o",
+    "cross_attn.q",
+    "cross_attn.k",
+    "cross_attn.v",
+    "cross_attn.o",
+    "ffn.0",
+    "ffn.2",
+)
+_LORA_KEY = re.compile(
+    r"^(?:base_model\.model\.)?(blocks\.(\d+)\.(.+))\.lora_([AB])\.weight$"
+)
+
+
+def _sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(8 * 1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _target_name(source_name: str, style: str) -> str:
+    if style == "native":
+        return source_name
+    if style != "diffusers":
+        raise ValueError(f"Unknown Wan module style: {style!r}")
+
+    replacements = {
+        ".self_attn.q": ".attn1.to_q",
+        ".self_attn.k": ".attn1.to_k",
+        ".self_attn.v": ".attn1.to_v",
+        ".self_attn.o": ".attn1.to_out.0",
+        ".cross_attn.q": ".attn2.to_q",
+        ".cross_attn.k": ".attn2.to_k",
+        ".cross_attn.v": ".attn2.to_v",
+        ".cross_attn.o": ".attn2.to_out.0",
+        ".ffn.0": ".ffn.net.0.proj",
+        ".ffn.2": ".ffn.net.2",
+    }
+    for suffix, replacement in replacements.items():
+        if source_name.endswith(suffix):
+            return source_name[: -len(suffix)] + replacement
+    raise ValueError(f"Unsupported Wan LoRA target: {source_name}")
+
+
+def inspect_wan_lora_checkpoint(
+    checkpoint_path: str | Path,
+    *,
+    expected_rank: int,
+    lora_alpha: int | None = None,
+    checkpoint_kind: str,
+    expected_step: int | None = None,
+) -> dict[str, Any]:
+    """Read and strictly validate one 30-block Wan generator LoRA."""
+    if expected_rank <= 0:
+        raise ValueError(f"expected_rank must be positive, got {expected_rank}")
+    alpha = expected_rank if lora_alpha is None else lora_alpha
+    if alpha <= 0:
+        raise ValueError(f"lora_alpha must be positive, got {alpha}")
+    checkpoint_path = Path(checkpoint_path).resolve()
+    payload = torch.load(
+        checkpoint_path,
+        map_location="cpu",
+        weights_only=True,
+        mmap=True,
+    )
+    if not isinstance(payload, dict):
+        raise TypeError(f"Expected a dict checkpoint, got {type(payload).__name__}")
+    if "generator_lora" not in payload:
+        raise KeyError(f"Missing generator_lora; top-level keys: {list(payload)}")
+    checkpoint_step = int(payload.get("step", -1))
+    if expected_step is not None and checkpoint_step != expected_step:
+        raise ValueError(
+            f"Expected step {expected_step} for {checkpoint_kind}, "
+            f"got {checkpoint_step}"
+        )
+    state = payload["generator_lora"]
+    if not isinstance(state, dict):
+        raise TypeError("generator_lora must be a state dict")
+
+    pairs: dict[str, dict[str, torch.Tensor]] = {}
+    bad_keys: list[str] = []
+    for key, tensor in state.items():
+        match = _LORA_KEY.match(key)
+        if match is None or not isinstance(tensor, torch.Tensor):
+            bad_keys.append(key)
+            continue
+        source_name, block_text, suffix, side = match.groups()
+        block = int(block_text)
+        if block not in EXPECTED_BLOCKS or suffix not in EXPECTED_SUFFIXES:
+            bad_keys.append(key)
+            continue
+        pairs.setdefault(source_name, {})[side] = tensor
+
+    expected_names = {
+        f"blocks.{block}.{suffix}"
+        for block in EXPECTED_BLOCKS
+        for suffix in EXPECTED_SUFFIXES
+    }
+    missing_names = sorted(expected_names - set(pairs))
+    extra_names = sorted(set(pairs) - expected_names)
+    incomplete = sorted(name for name, pair in pairs.items() if set(pair) != {"A", "B"})
+    if bad_keys or missing_names or extra_names or incomplete or len(state) != 600:
+        raise ValueError(
+            f"Invalid {checkpoint_kind} generator_lora structure: "
+            f"tensors={len(state)}, bad={len(bad_keys)}, missing={len(missing_names)}, "
+            f"extra={len(extra_names)}, incomplete={len(incomplete)}"
+        )
+
+    ranks = set()
+    parameter_count = 0
+    for name, pair in pairs.items():
+        a, b = pair["A"], pair["B"]
+        if a.ndim != 2 or b.ndim != 2 or a.shape[0] != b.shape[1]:
+            raise ValueError(f"Invalid A/B shapes for {name}: A={tuple(a.shape)}, B={tuple(b.shape)}")
+        ranks.add(int(a.shape[0]))
+        parameter_count += a.numel() + b.numel()
+    if ranks != {expected_rank}:
+        raise ValueError(
+            f"Expected rank {expected_rank} throughout for {checkpoint_kind}, "
+            f"got {sorted(ranks)}"
+        )
+
+    metadata = {
+        "checkpoint_kind": checkpoint_kind,
+        "checkpoint": str(checkpoint_path),
+        "checkpoint_bytes": checkpoint_path.stat().st_size,
+        "checkpoint_sha256": _sha256_file(checkpoint_path),
+        "top_level_keys": sorted(payload),
+        "step": checkpoint_step,
+        "selected_state": "generator_lora",
+        "ignored_state": "critic_lora" if "critic_lora" in payload else None,
+        "tensor_count": len(state),
+        "target_count": len(pairs),
+        "blocks": len(EXPECTED_BLOCKS),
+        "targets_per_block": len(EXPECTED_SUFFIXES),
+        "rank": expected_rank,
+        "alpha": alpha,
+        "scale": alpha / expected_rank,
+        "parameter_count": parameter_count,
+    }
+    return {"metadata": metadata, "pairs": pairs}
+
+
+def inspect_perflow_checkpoint(checkpoint_path: str | Path) -> dict[str, Any]:
+    """Validate the published rank-128 Perflow generator LoRA."""
+    return inspect_wan_lora_checkpoint(
+        checkpoint_path,
+        expected_rank=128,
+        lora_alpha=128,
+        checkpoint_kind="perflow_step4",
+        expected_step=None,
+    )
+
+
+def inspect_local_nonar_checkpoint(
+    checkpoint_path: str | Path,
+    *,
+    expected_step: int | None = 1600,
+    expected_rank: int | None = None,
+) -> dict[str, Any]:
+    """Validate a local non-AR generator LoRA with a uniform inferred rank.
+
+    ``1600`` remains the fail-closed default for the historical four-step DMD
+    artifact. Native-step CFG-distillation callers must pass their checkpoint
+    identity explicitly instead of being silently coupled to that old step.
+    Rank is inferred by default so matched rank sweeps are not incorrectly
+    rejected by the historical rank-64 assumption.
+    """
+    checkpoint_path = Path(checkpoint_path).resolve()
+    if expected_rank is None:
+        payload = torch.load(
+            checkpoint_path,
+            map_location="cpu",
+            weights_only=True,
+            mmap=True,
+        )
+        if not isinstance(payload, dict) or not isinstance(
+            payload.get("generator_lora"), dict
+        ):
+            raise TypeError(f"Expected generator_lora state dict in {checkpoint_path}")
+        state = payload["generator_lora"]
+        ranks = {
+            int(tensor.shape[0])
+            for key, tensor in state.items()
+            if key.endswith(".lora_A.weight")
+            and isinstance(tensor, torch.Tensor)
+            and tensor.ndim == 2
+        }
+        if len(ranks) != 1:
+            raise ValueError(
+                f"Expected one uniform LoRA rank in {checkpoint_path}, "
+                f"got {sorted(ranks)}"
+            )
+        expected_rank = next(iter(ranks))
+        del state, payload
+    return inspect_wan_lora_checkpoint(
+        checkpoint_path,
+        expected_rank=expected_rank,
+        lora_alpha=expected_rank,
+        checkpoint_kind="local_nonar_step4",
+        expected_step=expected_step,
+    )
+
+
+def attach_wan_lora(
+    model: nn.Module,
+    checkpoint_path: str | Path,
+    *,
+    style: str,
+    expected_rank: int,
+    lora_alpha: int,
+    adapter_name: str,
+    checkpoint_kind: str,
+    report_prefix: str,
+    expected_step: int | None = None,
+    enabled: bool = False,
+) -> dict[str, Any]:
+    """Install the generator LoRA on a native-Wan or Diffusers Wan backbone.
+
+    Every source tensor and every destination module must match.  Any missing or
+    shape-mismatched layer aborts the run instead of silently producing a partial
+    LoRA load.
+    """
+    inspected = inspect_wan_lora_checkpoint(
+        checkpoint_path,
+        expected_rank=expected_rank,
+        lora_alpha=lora_alpha,
+        checkpoint_kind=checkpoint_kind,
+        expected_step=expected_step,
+    )
+    metadata = inspected["metadata"]
+    pairs = inspected["pairs"]
+
+    destinations: dict[str, tuple[str, dict[str, torch.Tensor], nn.Linear]] = {}
+    for source_name, pair in pairs.items():
+        target_name = _target_name(source_name, style)
+        try:
+            target = model.get_submodule(target_name)
+        except AttributeError as exc:
+            raise ValueError(f"Missing LoRA destination {target_name} (from {source_name})") from exc
+        if not isinstance(target, nn.Linear):
+            raise TypeError(f"LoRA destination {target_name} is {type(target).__name__}, not nn.Linear")
+        a, b = pair["A"], pair["B"]
+        expected_a = (a.shape[0], target.in_features)
+        expected_b = (target.out_features, a.shape[0])
+        if tuple(a.shape) != expected_a or tuple(b.shape) != expected_b:
+            raise ValueError(
+                f"Shape mismatch for {target_name}: target={tuple(target.weight.shape)}, "
+                f"A={tuple(a.shape)} expected={expected_a}, B={tuple(b.shape)} expected={expected_b}"
+            )
+        destinations[target_name] = (source_name, pair, target)
+
+    if len(destinations) != 300:
+        raise ValueError(f"Expected 300 unique LoRA destinations, got {len(destinations)}")
+
+    # PEFT 0.19 probes torchao before checking whether a layer is quantized.  The
+    # inherited environment has torchao 0.11, so explicitly disable that optional
+    # dispatcher; ordinary torch.nn.Linear layers use PEFT's native dispatcher.
+    import peft.tuners.lora.torchao as peft_torchao
+    from peft import LoraConfig, inject_adapter_in_model
+
+    peft_torchao.is_torchao_available = lambda: False
+    config = LoraConfig(
+        r=expected_rank,
+        lora_alpha=lora_alpha,
+        lora_dropout=0.0,
+        bias="none",
+        target_modules=sorted(destinations),
+        init_lora_weights=True,
+    )
+    inject_adapter_in_model(config, model, adapter_name=adapter_name)
+
+    copied_tensors = 0
+    nonzero_b = 0
+    adapter_dtypes: set[str] = set()
+    with torch.no_grad():
+        for target_name, (_source_name, pair, _old_target) in destinations.items():
+            layer = model.get_submodule(target_name)
+            if adapter_name not in layer.lora_A or adapter_name not in layer.lora_B:
+                raise RuntimeError(f"PEFT did not create adapter tensors for {target_name}")
+            a_param = layer.lora_A[adapter_name].weight
+            b_param = layer.lora_B[adapter_name].weight
+            a_param.copy_(pair["A"].to(device=a_param.device, dtype=a_param.dtype))
+            b_param.copy_(pair["B"].to(device=b_param.device, dtype=b_param.dtype))
+            copied_tensors += 2
+            nonzero_b += int(torch.count_nonzero(pair["B"]).item() > 0)
+            adapter_dtypes.add(str(a_param.dtype).replace("torch.", ""))
+            scale = float(layer.scaling[adapter_name])
+            expected_scale = lora_alpha / expected_rank
+            if scale != expected_scale:
+                raise RuntimeError(
+                    f"Unexpected LoRA scale for {target_name}: {scale}; "
+                    f"expected {expected_scale}"
+                )
+
+    toggled = _set_adapter_enabled(
+        model,
+        adapter_name=adapter_name,
+        enabled=enabled,
+        report_prefix=report_prefix,
+        allow_absent=False,
+    )
+    if toggled != 300 or copied_tensors != 600 or nonzero_b != 300:
+        raise RuntimeError(
+            f"Incomplete LoRA installation: layers={toggled}, tensors={copied_tensors}, "
+            f"nonzero_B={nonzero_b}"
+        )
+
+    report = {
+        **metadata,
+        "module_style": style,
+        "adapter_name": adapter_name,
+        "loaded_tensors": copied_tensors,
+        "loaded_targets": toggled,
+        "missing_targets": 0,
+        "shape_mismatches": 0,
+        "nonzero_B_targets": nonzero_b,
+        "adapter_dtypes": sorted(adapter_dtypes),
+        "enabled": bool(enabled),
+    }
+    print(report_prefix + "_LOAD_REPORT=" + json.dumps(report, sort_keys=True), flush=True)
+    return report
+
+
+def attach_perflow_lora(
+    model: nn.Module,
+    checkpoint_path: str | Path,
+    *,
+    style: str,
+    enabled: bool = False,
+) -> dict[str, Any]:
+    """Install the published rank-128 Perflow generator LoRA."""
+    return attach_wan_lora(
+        model,
+        checkpoint_path,
+        style=style,
+        expected_rank=128,
+        lora_alpha=128,
+        adapter_name=PERFLOW_ADAPTER_NAME,
+        checkpoint_kind="perflow_step4",
+        report_prefix="PERFLOW_LORA",
+        expected_step=None,
+        enabled=enabled,
+    )
+
+
+def apply_adapter_strength(
+    model: nn.Module,
+    *,
+    adapter_name: str,
+    strength: float,
+    expected_targets: int = 300,
+) -> dict[str, Any]:
+    """Apply one linear inference multiplier through PEFT's scaling value."""
+
+    strength = float(strength)
+    if not math.isfinite(strength) or strength <= 0:
+        raise ValueError(f"LoRA inference strength must be positive and finite, got {strength}")
+    base_scalings: set[float] = set()
+    effective_scalings: set[float] = set()
+    scaled_targets = 0
+    for layer in model.modules():
+        scaling = getattr(layer, "scaling", None)
+        if scaling is None or adapter_name not in scaling:
+            continue
+        base_scale = float(scaling[adapter_name])
+        effective_scale = base_scale * strength
+        scaling[adapter_name] = effective_scale
+        base_scalings.add(base_scale)
+        effective_scalings.add(effective_scale)
+        scaled_targets += 1
+    if scaled_targets != expected_targets:
+        raise RuntimeError(
+            "Incomplete LoRA inference-strength application: "
+            f"targets={scaled_targets}, expected={expected_targets}"
+        )
+    return {
+        "inference_strength": strength,
+        "base_adapter_scaling": sorted(base_scalings),
+        "effective_adapter_scaling": sorted(effective_scalings),
+        "scaled_targets": scaled_targets,
+        "scale_semantics": "delta_W = inference_strength * (B @ A) * alpha/r",
+    }
+
+
+def attach_local_nonar_lora(
+    model: nn.Module,
+    checkpoint_path: str | Path,
+    *,
+    style: str,
+    enabled: bool = True,
+    strength: float | None = None,
+) -> dict[str, Any]:
+    """Install a local four-step non-AR DMD generator LoRA.
+
+    The transfer study compares independently trained WAN, SCOPE and TheDenk
+    adapters. They intentionally use different ranks and checkpoint steps, so
+    infer those provenance fields from the checkpoint while retaining the
+    strict 600-tensor / 300-target / destination-shape validation performed by
+    :func:`attach_wan_lora`.
+    """
+    checkpoint_path = Path(checkpoint_path).resolve()
+    payload = torch.load(
+        checkpoint_path,
+        map_location="cpu",
+        weights_only=True,
+        mmap=True,
+    )
+    if not isinstance(payload, dict) or not isinstance(payload.get("generator_lora"), dict):
+        raise TypeError(f"Expected generator_lora state dict in {checkpoint_path}")
+    state = payload["generator_lora"]
+    ranks = {
+        int(tensor.shape[0])
+        for key, tensor in state.items()
+        if key.endswith(".lora_A.weight") and isinstance(tensor, torch.Tensor) and tensor.ndim == 2
+    }
+    if len(ranks) != 1:
+        raise ValueError(f"Expected one uniform LoRA rank in {checkpoint_path}, got {sorted(ranks)}")
+    rank = next(iter(ranks))
+    step = payload.get("step")
+    expected_step = int(step) if step is not None else None
+    del state, payload
+    if strength is None:
+        strength = float(os.environ.get("LOCAL_NONAR_LORA_SCALE", "1"))
+    strength = float(strength)
+    if not math.isfinite(strength) or strength <= 0:
+        raise ValueError(f"LoRA inference strength must be positive and finite, got {strength}")
+
+    report = attach_wan_lora(
+        model,
+        checkpoint_path,
+        style=style,
+        expected_rank=rank,
+        lora_alpha=rank,
+        adapter_name=LOCAL_NONAR_ADAPTER_NAME,
+        checkpoint_kind="local_nonar_step4",
+        report_prefix="LOCAL_NONAR_LORA",
+        expected_step=expected_step,
+        enabled=enabled,
+    )
+    report = {
+        **report,
+        **apply_adapter_strength(
+            model,
+            adapter_name=LOCAL_NONAR_ADAPTER_NAME,
+            strength=strength,
+            expected_targets=300,
+        ),
+    }
+    report_path_raw = os.environ.get("LOCAL_NONAR_LORA_REPORT_PATH")
+    if report_path_raw:
+        report_path = Path(report_path_raw).resolve()
+        report_path.parent.mkdir(parents=True, exist_ok=True)
+        temporary = report_path.with_suffix(report_path.suffix + ".tmp")
+        temporary.write_text(
+            json.dumps(report, indent=2, sort_keys=True) + "\n",
+            encoding="utf-8",
+        )
+        temporary.replace(report_path)
+    print(
+        "LOCAL_NONAR_LORA_SCALE_REPORT="
+        + json.dumps(report, sort_keys=True),
+        flush=True,
+    )
+    return report
+
+
+def _set_adapter_enabled(
+    model: nn.Module,
+    *,
+    adapter_name: str,
+    enabled: bool,
+    report_prefix: str,
+    allow_absent: bool,
+) -> int:
+    count = 0
+    for module in model.modules():
+        lora_a = getattr(module, "lora_A", None)
+        if lora_a is None or adapter_name not in lora_a:
+            continue
+        module.enable_adapters(enabled=enabled)
+        count += 1
+    expected_counts = (0, 300) if allow_absent else (300,)
+    if count not in expected_counts:
+        raise RuntimeError(
+            f"Expected {'0 or ' if allow_absent else ''}300 {adapter_name} layers "
+            f"while toggling, found {count}"
+        )
+    print(f"{report_prefix}_ENABLED={int(enabled)} layers={count}", flush=True)
+    return count
+
+
+def set_perflow_enabled(model: nn.Module, enabled: bool) -> int:
+    """Enable/disable only the installed Perflow tuner layers."""
+    return _set_adapter_enabled(
+        model,
+        adapter_name=PERFLOW_ADAPTER_NAME,
+        enabled=enabled,
+        report_prefix="PERFLOW_LORA",
+        allow_absent=True,
+    )
+
+
+def set_local_nonar_enabled(model: nn.Module, enabled: bool) -> int:
+    """Enable/disable only the installed local non-AR tuner layers."""
+    return _set_adapter_enabled(
+        model,
+        adapter_name=LOCAL_NONAR_ADAPTER_NAME,
+        enabled=enabled,
+        report_prefix="LOCAL_NONAR_LORA",
+        allow_absent=True,
+    )

provenance.json

@@ -0,0 +1,50 @@
+{
+  "artifacts": {
+    "adapter_model.safetensors": {
+      "bytes": 644949344,
+      "sha256": "cb06b699fe5bdbb9e5750ca177bf61e74fbb32d150e4dcaf55f9141b0f169278"
+    },
+    "generator_lora.pt": {
+      "bytes": 645089990,
+      "sha256": "12946fdfac2a99643f259e721764b728e6e905c1e838e104c24b87b0757facc8"
+    },
+    "perflow_lora.py": {
+      "bytes": 19487,
+      "sha256": "4ee88e7cfb4d803f97622809d5f483187a061b7f53d77748b5850e438dba08b8"
+    }
+  },
+  "base_model": {
+    "id": "alibaba-pai/Wan2.2-Fun-5B-Control",
+    "revision": "b8bc1a65ab71d054ba4636dc0dac104aa4df2686",
+    "weights_sha256": "ace4718a7c87ee3e5606a68ab79142c4395e81aece76b8120bc886f0fbbe1d16"
+  },
+  "evaluation_receipts": {
+    "all_600_tensors_loaded": true,
+    "all_fourstep_cfgfree": true,
+    "all_loaded_source_sha256": "47f94f7fc85ed53b5480b28c2bfa3a05659bcf4aeb1278004c0860224787e78a",
+    "count": 3600
+  },
+  "source_checkpoint": {
+    "bytes": 1290171290,
+    "relative_path": "wanfun_lora/experiments/dmd_4step/logs/checkpoint_model_001600/model.pt",
+    "sha256": "47f94f7fc85ed53b5480b28c2bfa3a05659bcf4aeb1278004c0860224787e78a",
+    "step": 1600
+  },
+  "source_metadata_sha256": "048f724b06350bbb0dfb1e65efe175182cad924cbab3691fa34d92c61e441b89",
+  "source_training_config_sha256": "4a2246e0186fcaceff47b860d262796078ba5ed19c3abdd51981e7409bd3d203",
+  "training_data": {
+    "caption_repository": "fal/cosmos-openvid-1m",
+    "caption_revision": "10b41fc29006eff62ff64b8795b8ae8ef7ff9cde",
+    "depth_repository": "Yanbin99/Depth-Normal-Videos-42K",
+    "depth_revision": "9c5d205edd71077bbab7d96cae971a25a1fbf91f",
+    "manifest_sha256": "53844eda18ca75ae22c377354cf37b5e968f47f4452a6130de9f5c18782e3f20",
+    "pair_count": 5000,
+    "reuses_previous_controlnet_depth_manifest": true
+  },
+  "training_source": {
+    "longlive_revision": "52e9fce478ef1c3eed4c3f918c63f9895c2c61e4",
+    "trainer_source_sha256": "7db33c34c1b48f8a14a5709f2420f73adeabf2e668b0af424addf11260e17f01",
+    "videox_revision": "1fd9ed9208ba280f6b48c542a7739e636f4e2a14",
+    "wrapper_source_sha256": "c27b7f63715af3a92c20fec8bf2d50d7b4019150ba9af6d3e5637556d88c58ee"
+  }
+}

release_metadata.json

@@ -0,0 +1,39 @@
+{
+  "all_target_shapes_match_pinned_base": true,
+  "base_model": "alibaba-pai/Wan2.2-Fun-5B-Control",
+  "base_model_revision": "b8bc1a65ab71d054ba4636dc0dac104aa4df2686",
+  "classifier_free_guidance": false,
+  "display_name": "WAN Fun LoRA",
+  "effective_global_batch": 32,
+  "evaluation_video_receipts_checked": 3600,
+  "excluded_states": [
+    "critic_lora"
+  ],
+  "gpus_per_node": 8,
+  "inference_guidance_scale": 1.0,
+  "inference_steps": 4,
+  "lora_alpha": 64,
+  "lora_rank": 64,
+  "lora_strength": 1.0,
+  "parameter_count": 161218560,
+  "repo_id": "Perflow-Shuai/WAN-Fun-LoRA-5B-Control-4Step-CFG1-step1600",
+  "schema_version": 1,
+  "selected_state": "generator_lora",
+  "source_to_native_tensor_identity": true,
+  "source_to_safetensors_tensor_identity": true,
+  "storage_dtype": "float32",
+  "target_count": 300,
+  "tensor_count": 600,
+  "training_latent_frames": 24,
+  "training_nodes": 2,
+  "training_pair_count": 5000,
+  "training_raw_frames": 93,
+  "training_resolution": [
+    832,
+    480
+  ],
+  "training_step": 1600,
+  "training_teacher_conventional_cfg": 4.0,
+  "training_teacher_formula": "conditional + 3 * (conditional - unconditional)",
+  "training_teacher_real_guidance_scale": 3.0
+}

training_config.yaml

@@ -0,0 +1,96 @@
+# Training configuration; local asset paths normalized for publication.
+# model_name selects shared VAE/text assets; fun_control_model_path selects the trained DiT.
+infra:
+  expected_world_size: 16
+  expected_nodes: 2
+  expected_gpus_per_node: 8
+  required_gpu_name: H100
+  sharding_strategy: hybrid_full
+  mixed_precision: true
+  vae_dtype: float32
+  gradient_checkpointing: true
+  generator_fsdp_wrap_strategy: size
+  real_score_fsdp_wrap_strategy: size
+  fake_score_fsdp_wrap_strategy: size
+  text_encoder_fsdp_wrap_strategy: size
+model_kwargs:
+  model_name: Wan2.2-TI2V-5B
+  fun_control_model_path: models/Wan2.2-Fun-5B-Control
+  timestep_shift: 5.0
+  num_frame_per_block: 8
+  local_attn_size: -1
+  control_raw_frames: 93
+checkpoints:
+  generator_ckpt: null
+  real_score_ckpt: null
+  fake_score_ckpt: null
+algorithm:
+  trainer: score_distillation
+  distribution_loss: dmd
+  generator_is_causal: false
+  real_score_is_causal: false
+  fake_score_is_causal: false
+  all_causal: false
+  backward_simulation: true
+  independent_first_frame: false
+  ts_schedule: false
+  real_guidance_scale: 3.0
+  fake_guidance_scale: 0.0
+training:
+  lr: 1.0e-05
+  lr_critic: 2.0e-06
+  weight_decay: 0.0
+  beta1: 0.0
+  beta2: 0.999
+  beta1_critic: 0.0
+  beta2_critic: 0.999
+  batch_size: 1
+  gradient_accumulation_steps: 2
+  ema_weight: 0.99
+  ema_start_step: 200
+  log_iters: 100
+  max_checkpoints: 20
+  max_iters: 3000
+  gc_interval: 100
+  dfake_gen_update_ratio: 5
+  min_num_training_frames: 24
+  num_training_frames: 24
+  slice_last_frames: 24
+data:
+  data_path: data/depth_video_5k/manifest.jsonl
+  eval_data_path: data/depth_video_5k/manifest.jsonl
+  control_manifest: data/depth_video_5k/manifest.jsonl
+  eval_control_manifest: data/depth_video_5k/manifest.jsonl
+  control_raw_frames: 93
+  control_min_temporal_difference: 0.0001
+  control_num_workers: 2
+  image_or_video_shape:
+  - 1
+  - 24
+  - 48
+  - 30
+  - 52
+  full_ref_mode: zero_through_ref_conv
+inference:
+  sampling_steps: 4
+  guidance_scale: 1.0
+  inference_guidance_scale: 1.0
+  sink_size: 0
+  multi_shot_rope_offset: 0
+evaluation:
+  interval: -1
+  num_frames: 24
+  use_ema: false
+  val_batch_size: 1
+  save_latents_only: true
+adapter:
+  type: lora
+  rank: 64
+  alpha: 64
+  dropout: 0.0
+  apply_to_critic: true
+  verbose: false
+logging:
+  seed: 17
+  wandb_entity: null
+  wandb_project: LongLive-WanFun5B-Control-DMD