Colorizer round5: baseline checkpoint and source before GPU work

experiments/round5-20260927/SHA256SUMS.json

@@ -1,5 +1,38 @@
 {
-  "initial/config.json": "90299ee25ee3c3e645b362ddbd5a859b9e739c2a0a1c8a5e9ea79df171288bff",
-  "initial/model.safetensors": "0e4c417375684a044860f8af3ac3a2fb44e1a5729254ca33abda758ea71aea6e",
-  "source.zip": "e5e91e575dfe5a5d4b50c60a3e8f831be5c09693d2d6256044f31d853114618f"
+  "best/README.md": "fb835cbd31ee2df2d88d83f69354f0d82fc6213f24efbc6b3e92e1238a191493",
+  "best/config.json": "90299ee25ee3c3e645b362ddbd5a859b9e739c2a0a1c8a5e9ea79df171288bff",
+  "best/model.safetensors": "0e4c417375684a044860f8af3ac3a2fb44e1a5729254ca33abda758ea71aea6e",
+  "selection.json": "a714182d0a1985452e9ad7bb7a44729325382bde322edcc34b55f6680e2d9004",
+  "source/PROTOCOL.md": "cb34624b5f431b859c31f583f96f5ab531f0248dea2f33271947523c5ec4aa07",
+  "source/data.py": "eb43b886fe45435841439c36646985f914386a48faa712fb6806accac2ad48e0",
+  "source/inference.py": "e2b98bd98a15eb0c5beb4e9a2e64afb1cc4f381567f3ef213119f9bb21401a32",
+  "source/metrics.py": "af0ac996f6be0a351a55e372fab637a0d06740afe4a744cb80d0eae56ec97f66",
+  "source/model.py": "4cc57f82ffd6378bdf23a088ce7a1ed56c09e5673de3ee5232b8ee1cacc9be0a",
+  "source/persistence.py": "9ccfc8d5908cef98078422049e8caaaf558ac8293792cd77e8b483f92ad908be",
+  "source/previous_manifest.json": "24bc081bf48f1109d9dfa217ae0d8593c0c06af6785a5cbfc5dc5d9e25461f5c",
+  "source/spatial.py": "d13abe399ef049e21a6459a7003461afaae0c00e0c560262c6cf375de4c9884a",
+  "source/train.py": "03e11298fdc8668042c61caee5cf5789ce4675cacc881cb214d5d9bbb64ad056",
+  "source/vendor_ddcolor/LICENSE": "43070e2d4e532684de521b885f385d0841030efa2b1a20bafb76133a5e1379c1",
+  "source/vendor_ddcolor/basicsr/__init__.py": "376dd0503a4853c5f9831a15ce29a821eb668689efaf1c1a6a87d09f7696a9db",
+  "source/vendor_ddcolor/basicsr/archs/__init__.py": "6b0ddbe90c089837eeca316425bb708e30d75c89efa2015f5aba41dc820cf1c9",
+  "source/vendor_ddcolor/basicsr/archs/ddcolor_arch_utils/__init__.py": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+  "source/vendor_ddcolor/basicsr/archs/ddcolor_arch_utils/convnext.py": "f03e339488570aa79e0690719546317a375ca85bd8a9e1e5f2c797cda033db45",
+  "source/vendor_ddcolor/basicsr/archs/ddcolor_arch_utils/position_encoding.py": "beb5b3b52f2cc4f2dfc9f312cdc5d712468ff1d2985be7471a94a0c37a8c01d6",
+  "source/vendor_ddcolor/basicsr/archs/ddcolor_arch_utils/transformer.py": "95548deb6125bb42801e9be5569007256cc50f5a19f7b6591348e4aea9ee1a5d",
+  "source/vendor_ddcolor/basicsr/archs/ddcolor_arch_utils/transformer_utils.py": "61d99be451ef0717eaa1bf84ecfd29f9c4224ac1e5a35d68a963c4b97f4dbd0b",
+  "source/vendor_ddcolor/basicsr/archs/ddcolor_arch_utils/unet.py": "2b72fd6ef60d73f033cd3b2a3b4737d5371d4190b6410883e4d987d8417df1b2",
+  "source/vendor_ddcolor/basicsr/archs/ddcolor_arch_utils/util.py": "a771c34a643735107ee0788ceab15fd5baa39e4e6417149194c7255ad39d2169",
+  "source/vendor_ddcolor/basicsr/utils/__init__.py": "d06ae0685849d5090788f2d5ebaf93b2c8a67e1ef0284c98e6efeb70dbe3ec77",
+  "source/vendor_ddcolor/basicsr/utils/diffjpeg.py": "ac20cc17c29684b27cf08a0d0c12ad6aee3811a9333ccfc3a45dd96d29b8bbbf",
+  "source/vendor_ddcolor/basicsr/utils/dist_util.py": "e6a6d7fced5146ff2e1f16cb0ce1c922171fe7e8b28c011178695ebed4f477b8",
+  "source/vendor_ddcolor/basicsr/utils/file_client.py": "0a48e9073e2813651303003dc212579098764e62a2e58fcf889832ddf9c00a25",
+  "source/vendor_ddcolor/basicsr/utils/img_process_util.py": "e92f3ee102bca3b7dd8f2c2b196a40c15c7cd181c782455ec4e71f4331ccd625",
+  "source/vendor_ddcolor/basicsr/utils/img_util.py": "ca32b89d12de4494640d5ed0160f827aa1cfc55a3c0b5aea4b6e72118311199e",
+  "source/vendor_ddcolor/basicsr/utils/logger.py": "5361d5d9bcb92ed9b8a81278c6acc4d2dcb57bef29da92f16c0693023edb4abe",
+  "source/vendor_ddcolor/basicsr/utils/misc.py": "4e94ff742db4938d636cfcc096dec4707a036ef1aa5312925944b21d0e306dff",
+  "source/vendor_ddcolor/basicsr/utils/registry.py": "21c23bd3bf727eb2decd99035120fc47316db92486d73116cca18e9fa8b6c854",
+  "source/vendor_ddcolor/ddcolor/__init__.py": "2606a3377189bda8beb1a2075c7bd789961163bca3e1e53b01bbe325dc561c30",
+  "source/vendor_ddcolor/ddcolor/model.py": "e8e30115aa65a9558db33641c999001d1735c444402890898b47b2cc52b37c25",
+  "source/vendor_ddcolor/ddcolor/pipeline.py": "61fb3a7642309d1dc5069fb8089dcdff13ab5680c78269013b579bfa654ce005",
+  "status.json": "756d10f0138e6fd95b56a37010d0ea857f12f9d53ca695523ea11f8b75e821b6"
 }

experiments/round5-20260927/best/README.md

@@ -0,0 +1,16 @@
+---
+license: apache-2.0
+pipeline_tag: image-to-image
+tags:
+- classification
+- colorization
+- image-to-image
+- model_hub_mixin
+- pytorch_model_hub_mixin
+- unet
+---
+
+This model has been pushed to the Hub using the [PytorchModelHubMixin](https://huggingface.co/docs/huggingface_hub/package_reference/mixins#huggingface_hub.PyTorchModelHubMixin) integration:
+- Code: [More Information Needed]
+- Paper: [More Information Needed]
+- Docs: [More Information Needed]

experiments/round5-20260927/best/config.json

@@ -0,0 +1,956 @@
+{
+  "base": 44,
+  "bin_centers": [
+    [
+      -75.0,
+      25.0
+    ],
+    [
+      -75.0,
+      35.0
+    ],
+    [
+      -75.0,
+      45.0
+    ],
+    [
+      -75.0,
+      55.0
+    ],
+    [
+      -75.0,
+      65.0
+    ],
+    [
+      -75.0,
+      75.0
+    ],
+    [
+      -65.0,
+      25.0
+    ],
+    [
+      -65.0,
+      35.0
+    ],
+    [
+      -65.0,
+      45.0
+    ],
+    [
+      -65.0,
+      55.0
+    ],
+    [
+      -65.0,
+      65.0
+    ],
+    [
+      -65.0,
+      75.0
+    ],
+    [
+      -55.0,
+      5.0
+    ],
+    [
+      -55.0,
+      15.0
+    ],
+    [
+      -55.0,
+      25.0
+    ],
+    [
+      -55.0,
+      35.0
+    ],
+    [
+      -55.0,
+      45.0
+    ],
+    [
+      -55.0,
+      55.0
+    ],
+    [
+      -55.0,
+      65.0
+    ],
+    [
+      -55.0,
+      75.0
+    ],
+    [
+      -45.0,
+      -15.0
+    ],
+    [
+      -45.0,
+      -5.0
+    ],
+    [
+      -45.0,
+      5.0
+    ],
+    [
+      -45.0,
+      15.0
+    ],
+    [
+      -45.0,
+      25.0
+    ],
+    [
+      -45.0,
+      35.0
+    ],
+    [
+      -45.0,
+      45.0
+    ],
+    [
+      -45.0,
+      55.0
+    ],
+    [
+      -45.0,
+      65.0
+    ],
+    [
+      -45.0,
+      75.0
+    ],
+    [
+      -45.0,
+      85.0
+    ],
+    [
+      -35.0,
+      -35.0
+    ],
+    [
+      -35.0,
+      -25.0
+    ],
+    [
+      -35.0,
+      -15.0
+    ],
+    [
+      -35.0,
+      -5.0
+    ],
+    [
+      -35.0,
+      5.0
+    ],
+    [
+      -35.0,
+      15.0
+    ],
+    [
+      -35.0,
+      25.0
+    ],
+    [
+      -35.0,
+      35.0
+    ],
+    [
+      -35.0,
+      45.0
+    ],
+    [
+      -35.0,
+      55.0
+    ],
+    [
+      -35.0,
+      65.0
+    ],
+    [
+      -35.0,
+      75.0
+    ],
+    [
+      -35.0,
+      85.0
+    ],
+    [
+      -35.0,
+      95.0
+    ],
+    [
+      -25.0,
+      -35.0
+    ],
+    [
+      -25.0,
+      -25.0
+    ],
+    [
+      -25.0,
+      -15.0
+    ],
+    [
+      -25.0,
+      -5.0
+    ],
+    [
+      -25.0,
+      5.0
+    ],
+    [
+      -25.0,
+      15.0
+    ],
+    [
+      -25.0,
+      25.0
+    ],
+    [
+      -25.0,
+      35.0
+    ],
+    [
+      -25.0,
+      45.0
+    ],
+    [
+      -25.0,
+      55.0
+    ],
+    [
+      -25.0,
+      65.0
+    ],
+    [
+      -25.0,
+      75.0
+    ],
+    [
+      -25.0,
+      85.0
+    ],
+    [
+      -25.0,
+      95.0
+    ],
+    [
+      -15.0,
+      -45.0
+    ],
+    [
+      -15.0,
+      -35.0
+    ],
+    [
+      -15.0,
+      -25.0
+    ],
+    [
+      -15.0,
+      -15.0
+    ],
+    [
+      -15.0,
+      -5.0
+    ],
+    [
+      -15.0,
+      5.0
+    ],
+    [
+      -15.0,
+      15.0
+    ],
+    [
+      -15.0,
+      25.0
+    ],
+    [
+      -15.0,
+      35.0
+    ],
+    [
+      -15.0,
+      45.0
+    ],
+    [
+      -15.0,
+      55.0
+    ],
+    [
+      -15.0,
+      65.0
+    ],
+    [
+      -15.0,
+      75.0
+    ],
+    [
+      -15.0,
+      85.0
+    ],
+    [
+      -15.0,
+      95.0
+    ],
+    [
+      -5.0,
+      -55.0
+    ],
+    [
+      -5.0,
+      -45.0
+    ],
+    [
+      -5.0,
+      -35.0
+    ],
+    [
+      -5.0,
+      -25.0
+    ],
+    [
+      -5.0,
+      -15.0
+    ],
+    [
+      -5.0,
+      -5.0
+    ],
+    [
+      -5.0,
+      5.0
+    ],
+    [
+      -5.0,
+      15.0
+    ],
+    [
+      -5.0,
+      25.0
+    ],
+    [
+      -5.0,
+      35.0
+    ],
+    [
+      -5.0,
+      45.0
+    ],
+    [
+      -5.0,
+      55.0
+    ],
+    [
+      -5.0,
+      65.0
+    ],
+    [
+      -5.0,
+      75.0
+    ],
+    [
+      -5.0,
+      85.0
+    ],
+    [
+      5.0,
+      -65.0
+    ],
+    [
+      5.0,
+      -55.0
+    ],
+    [
+      5.0,
+      -45.0
+    ],
+    [
+      5.0,
+      -35.0
+    ],
+    [
+      5.0,
+      -25.0
+    ],
+    [
+      5.0,
+      -15.0
+    ],
+    [
+      5.0,
+      -5.0
+    ],
+    [
+      5.0,
+      5.0
+    ],
+    [
+      5.0,
+      15.0
+    ],
+    [
+      5.0,
+      25.0
+    ],
+    [
+      5.0,
+      35.0
+    ],
+    [
+      5.0,
+      45.0
+    ],
+    [
+      5.0,
+      55.0
+    ],
+    [
+      5.0,
+      65.0
+    ],
+    [
+      5.0,
+      75.0
+    ],
+    [
+      5.0,
+      85.0
+    ],
+    [
+      15.0,
+      -75.0
+    ],
+    [
+      15.0,
+      -65.0
+    ],
+    [
+      15.0,
+      -55.0
+    ],
+    [
+      15.0,
+      -45.0
+    ],
+    [
+      15.0,
+      -35.0
+    ],
+    [
+      15.0,
+      -25.0
+    ],
+    [
+      15.0,
+      -15.0
+    ],
+    [
+      15.0,
+      -5.0
+    ],
+    [
+      15.0,
+      5.0
+    ],
+    [
+      15.0,
+      15.0
+    ],
+    [
+      15.0,
+      25.0
+    ],
+    [
+      15.0,
+      35.0
+    ],
+    [
+      15.0,
+      45.0
+    ],
+    [
+      15.0,
+      55.0
+    ],
+    [
+      15.0,
+      65.0
+    ],
+    [
+      15.0,
+      75.0
+    ],
+    [
+      15.0,
+      85.0
+    ],
+    [
+      25.0,
+      -75.0
+    ],
+    [
+      25.0,
+      -65.0
+    ],
+    [
+      25.0,
+      -55.0
+    ],
+    [
+      25.0,
+      -45.0
+    ],
+    [
+      25.0,
+      -35.0
+    ],
+    [
+      25.0,
+      -25.0
+    ],
+    [
+      25.0,
+      -15.0
+    ],
+    [
+      25.0,
+      -5.0
+    ],
+    [
+      25.0,
+      5.0
+    ],
+    [
+      25.0,
+      15.0
+    ],
+    [
+      25.0,
+      25.0
+    ],
+    [
+      25.0,
+      35.0
+    ],
+    [
+      25.0,
+      45.0
+    ],
+    [
+      25.0,
+      55.0
+    ],
+    [
+      25.0,
+      65.0
+    ],
+    [
+      25.0,
+      75.0
+    ],
+    [
+      25.0,
+      85.0
+    ],
+    [
+      35.0,
+      -85.0
+    ],
+    [
+      35.0,
+      -75.0
+    ],
+    [
+      35.0,
+      -65.0
+    ],
+    [
+      35.0,
+      -55.0
+    ],
+    [
+      35.0,
+      -45.0
+    ],
+    [
+      35.0,
+      -35.0
+    ],
+    [
+      35.0,
+      -25.0
+    ],
+    [
+      35.0,
+      -15.0
+    ],
+    [
+      35.0,
+      -5.0
+    ],
+    [
+      35.0,
+      5.0
+    ],
+    [
+      35.0,
+      15.0
+    ],
+    [
+      35.0,
+      25.0
+    ],
+    [
+      35.0,
+      35.0
+    ],
+    [
+      35.0,
+      45.0
+    ],
+    [
+      35.0,
+      55.0
+    ],
+    [
+      35.0,
+      65.0
+    ],
+    [
+      35.0,
+      75.0
+    ],
+    [
+      45.0,
+      -95.0
+    ],
+    [
+      45.0,
+      -85.0
+    ],
+    [
+      45.0,
+      -75.0
+    ],
+    [
+      45.0,
+      -65.0
+    ],
+    [
+      45.0,
+      -55.0
+    ],
+    [
+      45.0,
+      -45.0
+    ],
+    [
+      45.0,
+      -35.0
+    ],
+    [
+      45.0,
+      -25.0
+    ],
+    [
+      45.0,
+      -15.0
+    ],
+    [
+      45.0,
+      -5.0
+    ],
+    [
+      45.0,
+      5.0
+    ],
+    [
+      45.0,
+      15.0
+    ],
+    [
+      45.0,
+      25.0
+    ],
+    [
+      45.0,
+      35.0
+    ],
+    [
+      45.0,
+      45.0
+    ],
+    [
+      45.0,
+      55.0
+    ],
+    [
+      45.0,
+      65.0
+    ],
+    [
+      45.0,
+      75.0
+    ],
+    [
+      55.0,
+      -95.0
+    ],
+    [
+      55.0,
+      -85.0
+    ],
+    [
+      55.0,
+      -75.0
+    ],
+    [
+      55.0,
+      -65.0
+    ],
+    [
+      55.0,
+      -55.0
+    ],
+    [
+      55.0,
+      -45.0
+    ],
+    [
+      55.0,
+      -35.0
+    ],
+    [
+      55.0,
+      -25.0
+    ],
+    [
+      55.0,
+      -15.0
+    ],
+    [
+      55.0,
+      -5.0
+    ],
+    [
+      55.0,
+      5.0
+    ],
+    [
+      55.0,
+      15.0
+    ],
+    [
+      55.0,
+      25.0
+    ],
+    [
+      55.0,
+      35.0
+    ],
+    [
+      55.0,
+      45.0
+    ],
+    [
+      55.0,
+      55.0
+    ],
+    [
+      55.0,
+      65.0
+    ],
+    [
+      55.0,
+      75.0
+    ],
+    [
+      65.0,
+      -105.0
+    ],
+    [
+      65.0,
+      -95.0
+    ],
+    [
+      65.0,
+      -85.0
+    ],
+    [
+      65.0,
+      -75.0
+    ],
+    [
+      65.0,
+      -65.0
+    ],
+    [
+      65.0,
+      -55.0
+    ],
+    [
+      65.0,
+      -45.0
+    ],
+    [
+      65.0,
+      -35.0
+    ],
+    [
+      65.0,
+      -25.0
+    ],
+    [
+      65.0,
+      -15.0
+    ],
+    [
+      65.0,
+      -5.0
+    ],
+    [
+      65.0,
+      5.0
+    ],
+    [
+      65.0,
+      15.0
+    ],
+    [
+      65.0,
+      25.0
+    ],
+    [
+      65.0,
+      35.0
+    ],
+    [
+      65.0,
+      45.0
+    ],
+    [
+      65.0,
+      55.0
+    ],
+    [
+      65.0,
+      65.0
+    ],
+    [
+      75.0,
+      -105.0
+    ],
+    [
+      75.0,
+      -95.0
+    ],
+    [
+      75.0,
+      -45.0
+    ],
+    [
+      75.0,
+      -35.0
+    ],
+    [
+      75.0,
+      -25.0
+    ],
+    [
+      75.0,
+      -15.0
+    ],
+    [
+      75.0,
+      -5.0
+    ],
+    [
+      75.0,
+      5.0
+    ],
+    [
+      75.0,
+      15.0
+    ],
+    [
+      75.0,
+      25.0
+    ],
+    [
+      75.0,
+      35.0
+    ],
+    [
+      75.0,
+      45.0
+    ],
+    [
+      75.0,
+      55.0
+    ],
+    [
+      75.0,
+      65.0
+    ],
+    [
+      85.0,
+      -45.0
+    ],
+    [
+      85.0,
+      -35.0
+    ],
+    [
+      85.0,
+      -25.0
+    ],
+    [
+      85.0,
+      -15.0
+    ],
+    [
+      85.0,
+      -5.0
+    ],
+    [
+      85.0,
+      5.0
+    ],
+    [
+      85.0,
+      35.0
+    ],
+    [
+      85.0,
+      45.0
+    ],
+    [
+      85.0,
+      65.0
+    ],
+    [
+      95.0,
+      -55.0
+    ],
+    [
+      95.0,
+      -45.0
+    ],
+    [
+      95.0,
+      -35.0
+    ]
+  ],
+  "context_dilations": [
+    2,
+    4,
+    8
+  ],
+  "context_mid_ch": 96,
+  "in_ch": 1
+}

experiments/round5-20260927/best/model.safetensors

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

experiments/round5-20260927/selection.json

@@ -0,0 +1,5 @@
+{
+  "arm": "v2_baseline",
+  "step": 0,
+  "accepted": false
+}

experiments/round5-20260927/source/PROTOCOL.md

@@ -0,0 +1,36 @@
+# Round 4 — semantic guidance and broad color patches
+
+Status: experiment protocol, not a result or release claim.
+
+## Research and rationale
+
+DDColor uses multi-scale semantic features and color queries to reduce color bleeding: https://arxiv.org/abs/2212.11613 . The authors' model notes warn that their colorfulness loss can generate unwanted color blocks and describe an artistic checkpoint trained without that loss: https://github.com/piddnad/DDColor/blob/master/MODEL_ZOO.md . This does not prove that our different round-3 chroma-retention loss caused all artifacts, but it motivates removing extra saturation pressure and measuring the effect.
+
+The previous fine-edge proxy missed broad colored clouds. Round 3 reduced missed color but increased neutral-region spill, and its actual images still contained patches. This run therefore measures color differences across regions separated by 4–64 pixels, in areas where ground-truth color is locally consistent, before and after the existing guided decoder. It still requires visual review: no scalar proxy proves that blotches are gone.
+
+## Design
+
+- Start from v2 revision 704fa80d792c3d759db91daa00b2dcfe6f0f6412, checked against SHA256 0e4c417375684a044860f8af3ac3a2fb44e1a5729254ca33abda758ea71aea6e. Do not continue the round-3 color-strength loss.
+- Compare matched 3,000-step structure-only and structure-plus-distillation arms: seed 409, batch 16, learning rate 3e-5 decaying to 3e-6, frozen BatchNorm, BF16 student convolution, gradient clipping 1.
+- Use the existing 16,230-image training pool; fixed 150 validation and 300 test memberships. These are previous development holdouts. Teacher pretraining overlap is unknown, especially for Imagenette derived from ImageNet.
+- Ordinary-gray training inputs with flips and mild luminance augmentation. Gray and deterministic film-style inputs for validation/test.
+- Remove inverse-frequency class reweighting and explicit chroma-strength pressure. Keep soft color-bin classification; add supervised multiscale color-gradient matching and a neutral-target penalty.
+- Distillation arm also learns local ab predictions from piddnad/ddcolor_artistic, with confidence reduced when teacher colors strongly disagree with original ground truth. Teacher predictions are fallible and are not labels for original historical colors.
+- Teacher: upstream DDColor code pinned at 2adb63f2656ac41cbdf7b894cddd94121a3faf13, checkpoint revision resolved once and recorded. Neutral sRGB input at 512 square, raw teacher Lab ab output. Full precision inference. Training teacher targets cached at 64 square after area pooling; student remains 256 square. The grayscale input contract follows the upstream pipeline; fixed 256-to-512 resizing is an experimental comparison choice.
+- Evaluate the full pretrained teacher independently as a possible larger deployment option. No claim that distilling it guarantees the small model inherits its semantic capabilities.
+
+## Selection gates
+
+Every 500 steps, both gray/film validation conditions must satisfy all gates relative to v2: at least 15% less broad-patch excess after guided decoding; at least 10% less raw broad-patch excess; ab error no more than 5% higher; neutral spill and missed color no more than 1 percentage point higher; color coverage at least 95% of baseline. Rank eligible checkpoints by broad-patch proxy with smaller neutral/error terms. Keep baseline if none qualifies. Final test and real grayscale diagnostic montage are required before release.
+
+## Persistence and compute
+
+One L4 job, four-hour hard timeout and internal 3.5-hour graceful deadline checked through cache/training/evaluation loops. Expected roughly 1–3 hours, dependent on teacher inference speed. At the verified $0.80/hour L4 rate, four hours is about $3.20. No automatic write to main or stable: current direct-write permission was rejected in the previous attempt.
+
+The job's finally block exports selected weights (or baseline if rejected), metrics, provenance, source and visual probes as a ZIP in ARTIFACT_BEGIN/ARTIFACT_CHUNK/ARTIFACT_END log records with SHA256. An ordinary failure is exported with status.json; hardware failure or a hard kill can still interrupt export. The teacher checkpoint is referenced by immutable Hub revision rather than duplicated. Optimizer state and the disposable teacher cache are not exported. Recover logs with an adequate tail and verify checksum before extraction.
+
+Known limitation: the matched experiment isolates the extra teacher term, not every other change from v2. No claim of a clean causal attribution to any one of the shared changes.
+
+
+## Round5 rerun — 2026-09-27
+The previous round4 result was lost because stdout exceeded the archive cap. This rerun keeps the matched experiment design. Every 250 steps it commits model/config, optimizer and scheduler states to main under experiments/round5-20260927 and downloads changed files at the returned commit to verify SHA256. Evaluation and best selection are saved every 500 steps. Initial baseline and sources are saved before teacher/GPU work. Failed persistence aborts training after three attempts. The app's root checkpoint is only replaced after visual review; all candidates are available on main. Stdout contains compact status and metrics only. Optimizer state is saved for manual continuation, not an exact data-order resume implementation.

experiments/round5-20260927/source/data.py

@@ -0,0 +1,116 @@
+"""Fixed color-bin semantics and reproducible dataset membership."""
+import hashlib
+import io
+import json
+from pathlib import Path
+import numpy as np
+from PIL import Image
+import pyarrow.parquet as pq
+from scipy.spatial import cKDTree
+from skimage.color import rgb2lab
+import torch
+from torch.utils.data import Dataset
+
+class ColorBins:
+    def __init__(self, centers, weights=None):
+        self.centers = np.asarray(centers, np.float32)
+        if self.centers.ndim != 2 or self.centers.shape[1] != 2:
+            raise ValueError("Expected Q by 2 color centers")
+        self.tree = cKDTree(self.centers)
+        self.weights = np.ones(len(self.centers), np.float32) if weights is None else np.asarray(weights,np.float32)
+
+    def encode(self, ab, k=5, sigma=5):
+        k = min(k, len(self.centers))
+        if sigma <= 0 or k < 1:
+            raise ValueError("Invalid encoding parameters")
+        dist, idx = self.tree.query(ab.reshape(-1,2), k=k)
+        dist, idx = dist.reshape(-1,k), idx.reshape(-1,k)
+        logw = -dist**2/(2*sigma**2)
+        logw -= logw.max(1, keepdims=True)
+        weight = np.exp(logw); weight /= weight.sum(1,keepdims=True)
+        shape = (*ab.shape[:-1], k)
+        return idx.reshape(shape).astype(np.int64), weight.reshape(shape).astype(np.float32)
+
+def load_table(path):
+    table = pq.read_table(path)
+    return table
+
+def validate_manifest(path, table, manifest):
+    with open(path,'rb') as f:
+        digest=hashlib.file_digest(f,'sha256').hexdigest()
+    if digest!=manifest['dataset_sha256'] or len(table)!=manifest['rows']:
+        raise ValueError('Dataset differs from pinned split manifest')
+    groups=[list(map(int,manifest[k])) for k in ['train','validation','test']]
+    if any(not g or len(g)!=len(set(g)) or min(g)<0 or max(g)>=len(table) for g in groups):
+        raise ValueError('Invalid or repeated indices in manifest')
+    if any(set(groups[i])&set(groups[j]) for i,j in [(0,1),(0,2),(1,2)]):
+        raise ValueError('Train/validation/test overlap')
+
+def decode_image(table, index):
+    obj = table['image'][int(index)].as_py()
+    return Image.open(io.BytesIO(obj['bytes'])).convert('RGB')
+
+def legacy_split(n, seed=0):
+    # Exactly reproduce datasets.Dataset.train_test_split(test_size=.05, seed=0).
+    order = np.random.default_rng(seed).permutation(n)
+    nval = int(np.ceil(.05*n))
+    return order[nval:], order[:nval]
+
+def stratified_subset(indices, labels, per_class, seed):
+    rng = np.random.default_rng(seed)
+    selected = []
+    for label in sorted(set(labels)):
+        group = np.asarray([i for i in indices if labels[i] == label])
+        selected.extend(rng.choice(group, min(per_class,len(group)), replace=False).tolist())
+    return np.asarray(selected, dtype=np.int64)
+
+class PhotoDataset(Dataset):
+    def __init__(self, table, indices, bins, size=256, augment=False):
+        self.table, self.indices, self.bins = table, list(map(int,indices)), bins
+        self.size, self.augment = size, augment
+
+    def __len__(self):
+        return len(self.indices)
+
+    def __getitem__(self, item):
+        # Keep square preprocessing for controlled comparison with historical runs.
+        # Production inference preserves aspect ratio separately.
+        image = decode_image(self.table,self.indices[item]).resize((self.size,self.size),Image.Resampling.BILINEAR)
+        arr = np.asarray(image,dtype=np.float32)/255
+        if self.augment and torch.rand(()) < .5:
+            arr = arr[:,::-1].copy()
+        lab = rgb2lab(arr).astype(np.float32)
+        idx, weight = self.bins.encode(lab[...,1:])
+        return (torch.from_numpy((lab[...,:1]/50-1).transpose(2,0,1).copy()),
+                torch.from_numpy(lab[...,1:].transpose(2,0,1).copy()),
+                torch.from_numpy(idx),torch.from_numpy(weight))
+
+def estimate_weights(table, indices, bins, mix=.7, limit=1000, seed=0):
+    """Re-estimate the prior ON checkpoint bins; never replace the bin vocabulary."""
+    if not 0 <= mix <= 1:
+        raise ValueError("Rebalance mixture must be in [0,1]")
+    rng=np.random.default_rng(seed)
+    chosen=rng.choice(indices,min(limit,len(indices)),replace=False)
+    counts=np.ones(len(bins.centers),np.float64)*1e-3
+    for index in chosen:
+        image=decode_image(table,index).resize((32,32))
+        ab=rgb2lab(np.asarray(image,dtype=np.float32)/255)[...,1:]
+        # Low chroma is a heuristic, not proof that an image was originally B&W.
+        if np.linalg.norm(ab,axis=-1).mean()<3:
+            continue
+        idx,weight=bins.encode(ab)
+        np.add.at(counts,idx.ravel(),weight.ravel())
+    prior=counts/counts.sum()
+    weights=1/((1-mix)*prior+mix/len(prior))
+    weights/=np.sum(prior*weights)
+    return weights.astype(np.float32),prior.astype(np.float32)
+
+def write_manifest(path, table, train, validation, test, dataset_sha256):
+    groups=[set(map(int,g)) for g in [train,validation,test]]
+    assert not groups[0]&groups[1] and not groups[0]&groups[2] and not groups[1]&groups[2]
+    content={'dataset':'johnowhitaker/imagenette2-320','dataset_sha256':dataset_sha256,
+        'rows':len(table),'split_seed':0,'legacy_holdout_fraction':.05,
+        'train':list(map(int,train)),'validation':list(map(int,validation)), 'test':list(map(int,test)),
+        'caveat':'Matches the recent seed-0 holdout; older upstream training exposure is not established.'}
+    Path(path).write_text(json.dumps(content,indent=2))
+    return content

experiments/round5-20260927/source/inference.py

@@ -0,0 +1,64 @@
+"""Aspect-preserving inference; infer chroma globally and retain original luminance."""
+import argparse
+import math
+from pathlib import Path
+import numpy as np
+from PIL import Image, ImageOps
+import torch
+import torch.nn.functional as F
+from skimage.color import rgb2lab, lab2rgb
+from model import load_model
+from spatial import guided_chroma
+
+@torch.inference_mode()
+def colorize(model, image, size=256, temperature=0.38, saturation=1.0, flip_tta=False,
+             guided_radius=8, guided_epsilon=.001):
+    if size < 8 or not math.isfinite(saturation) or saturation < 0:
+        raise ValueError("size must be >=8 and saturation finite and nonnegative")
+    image = ImageOps.exif_transpose(image).convert("RGB")
+    rgb = np.asarray(image, dtype=np.float32) / 255.0
+    luminance = rgb2lab(rgb)[..., 0].astype(np.float32)
+    h, w = luminance.shape
+    scale = min(size / max(h, w), 1.0)
+    target = (max(8, round(h*scale)), max(8, round(w*scale)))
+    device = next(model.parameters()).device
+    L = torch.from_numpy(luminance)[None, None].to(device) / 50 - 1
+    small = F.interpolate(L, size=target, mode="bilinear", align_corners=False, antialias=True)
+    logits = model(small)
+    if flip_tta:
+        logits = (logits + model(small.flip(-1)).flip(-1)) * 0.5
+    ab = model.decode(logits, temperature)
+    ab = guided_chroma(small, ab, guided_radius, guided_epsilon)
+    ab = F.interpolate(ab, size=(h,w), mode="bilinear", align_corners=False)
+    ab = ab[0].permute(1,2,0).cpu().numpy() * saturation
+    lab = np.concatenate([luminance[...,None], ab], axis=-1)
+    result = np.clip(lab2rgb(lab), 0, 1)
+    return Image.fromarray(np.rint(result * 255).astype(np.uint8))
+
+def main():
+    p = argparse.ArgumentParser(__doc__)
+    p.add_argument("images", nargs="+")
+    p.add_argument("--model", required=True)
+    p.add_argument("--revision", default=None)
+    p.add_argument("--size", type=int, default=256)
+    p.add_argument("--temperature", type=float, default=.38)
+    p.add_argument("--saturation", type=float, default=1)
+    p.add_argument("--flip-tta", action="store_true")
+    p.add_argument("--guided-radius",type=int,default=8,help="Chroma smoothing radius at model resolution;0 disables")
+    p.add_argument("--guided-epsilon",type=float,default=.001)
+    p.add_argument("--output-dir", default="colorized")
+    p.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
+    a = p.parse_args()
+    torch.set_num_threads(min(torch.get_num_threads(),4))
+    model = load_model(a.model, a.revision, a.device)
+    out = Path(a.output_dir); out.mkdir(parents=True, exist_ok=True)
+    for file in a.images:
+        with Image.open(file) as im:
+            result = colorize(model, im, a.size, a.temperature, a.saturation, a.flip_tta,
+                              a.guided_radius,a.guided_epsilon)
+        dest = out / (Path(file).stem + "_colorized.png")
+        result.save(dest); print(dest)
+
+if __name__ == "__main__":
+    main()
+

experiments/round5-20260927/source/metrics.py

@@ -0,0 +1,35 @@
+"""Metrics are fidelity/artifact proxies; none certifies plausible color by itself."""
+import numpy as np
+import torch
+
+def soft_ce(logits, idx, weights, class_weights=None):
+    # FP32 reduction under autocast; no full target distribution materialized.
+    logits=logits.float()
+    idx=idx.permute(0,3,1,2)
+    weights=weights.permute(0,3,1,2)
+    nll=-((logits.gather(1,idx)-logits.logsumexp(1,keepdim=True))*weights).sum(1)
+    if class_weights is not None:
+        nll=nll*class_weights[idx[:,0]]
+    return nll.mean()
+
+def per_image_metrics(L, pred, target):
+    error=(pred-target).square().sum(1).sqrt().mean((1,2))
+    chroma=pred.square().sum(1).sqrt().mean((1,2))
+    true_chroma=target.square().sum(1).sqrt().mean((1,2))
+    seams=[]
+    for dim in [-1,-2]:
+        dp=pred.diff(dim=dim).square().sum(1).sqrt()
+        dt=target.diff(dim=dim).square().sum(1).sqrt()
+        dl=L.diff(dim=dim).abs()[:,0]*50
+        # Penalize excess chroma discontinuity where luminance is flat.
+        mask=(dl<2).float()
+        seams.append(((dp-dt).relu()*mask).sum((1,2))/mask.sum((1,2)).clamp_min(1))
+    return {'ab_error':error,'chroma':chroma,'target_chroma':true_chroma,
+            'excess_chroma_edge':sum(seams)/2}
+
+def summarize(rows):
+    keys=['ce','ab_error','chroma','target_chroma','excess_chroma_edge']
+    result={k:float(np.mean([r[k] for r in rows])) for k in keys}
+    result['n']=len(rows)
+    result['chroma_ratio']=result['chroma']/max(result['target_chroma'],1e-9)
+    return result

experiments/round5-20260927/source/model.py

@@ -0,0 +1,122 @@
+"""Shared, checkpoint-compatible Mini U-Net. Parameters remain under 4M."""
+import json
+import math
+from pathlib import Path
+import numpy as np
+import torch
+from torch import nn
+import torch.nn.functional as F
+from huggingface_hub import PyTorchModelHubMixin, snapshot_download
+from safetensors.torch import load_file, save_file
+def double_conv(in_ch, out_ch):
+    return nn.Sequential(
+        nn.Conv2d(in_ch, out_ch, 3, padding=1, bias=False),
+        nn.BatchNorm2d(out_ch),
+        nn.ReLU(inplace=True),
+        nn.Conv2d(out_ch, out_ch, 3, padding=1, bias=False),
+        nn.BatchNorm2d(out_ch),
+        nn.ReLU(inplace=True),
+    )
+
+
+class DilatedContextBlock(nn.Module):
+    def __init__(self, channels, mid_ch=96, dilations=(2, 4, 8)):
+        super().__init__()
+        self.proj_in = nn.Sequential(
+            nn.Conv2d(channels, mid_ch, 1, bias=False),
+            nn.BatchNorm2d(mid_ch),
+            nn.ReLU(inplace=True),
+        )
+        layers = []
+        for d in dilations:
+            layers += [
+                nn.Conv2d(mid_ch, mid_ch, 3, padding=d, dilation=d, bias=False),
+                nn.BatchNorm2d(mid_ch),
+                nn.ReLU(inplace=True),
+            ]
+        self.dilated = nn.Sequential(*layers)
+        self.proj_out = nn.Sequential(
+            nn.Conv2d(mid_ch, channels, 1, bias=False),
+            nn.BatchNorm2d(channels),
+        )
+        nn.init.zeros_(self.proj_out[-1].weight)
+        self.relu = nn.ReLU(inplace=True)
+
+    def forward(self, x):
+        y = self.proj_in(x)
+        y = self.dilated(y)
+        y = self.proj_out(y)
+        return self.relu(x + y)
+
+
+class SmallUNetColorizer(
+    nn.Module,
+    PyTorchModelHubMixin,
+    pipeline_tag="image-to-image",
+    license="apache-2.0",
+    tags=["colorization", "unet", "image-to-image", "classification"],
+):
+    def __init__(self, bin_centers, in_ch: int = 1, base: int = 44,
+                 context_mid_ch: int = 96, context_dilations=(2, 4, 8)):
+        super().__init__()
+        self.in_ch, self.base = in_ch, base
+        num_bins = len(bin_centers)
+        self.num_bins = num_bins
+        self.register_buffer("bin_centers", torch.tensor(bin_centers, dtype=torch.float32))
+
+        self.enc1 = double_conv(in_ch, base)
+        self.enc2 = double_conv(base, base * 2)
+        self.enc3 = double_conv(base * 2, base * 4)
+        self.enc4 = double_conv(base * 4, base * 8)
+        self.pool = nn.MaxPool2d(2)
+        self.context = DilatedContextBlock(base * 8, mid_ch=context_mid_ch,
+                                            dilations=tuple(context_dilations))
+        self.up3 = nn.ConvTranspose2d(base * 8, base * 4, 2, stride=2)
+        self.dec3 = double_conv(base * 8, base * 4)
+        self.up2 = nn.ConvTranspose2d(base * 4, base * 2, 2, stride=2)
+        self.dec2 = double_conv(base * 4, base * 2)
+        self.up1 = nn.ConvTranspose2d(base * 2, base, 2, stride=2)
+        self.dec1 = double_conv(base * 2, base)
+        self.out_conv = nn.Conv2d(base, num_bins, 1)
+
+    def forward(self, x):
+        h, w = x.shape[-2:]
+        x = F.pad(x, (0, (-w) % 8, 0, (-h) % 8), mode="replicate")
+        e1 = self.enc1(x)
+        e2 = self.enc2(self.pool(e1))
+        e3 = self.enc3(self.pool(e2))
+        e4 = self.context(self.enc4(self.pool(e3)))
+        d3 = self.dec3(torch.cat([self.up3(e4), e3], dim=1))
+        d2 = self.dec2(torch.cat([self.up2(d3), e2], dim=1))
+        d1 = self.dec1(torch.cat([self.up1(d2), e1], dim=1))
+        return self.out_conv(d1)[..., :h, :w]
+
+    def decode(self, logits, temperature: float = 0.38):
+        if not math.isfinite(temperature) or temperature <= 0:
+            raise ValueError("temperature must be finite and positive")
+        probs_t = F.softmax(logits.float() / temperature, dim=1)
+        return torch.einsum("bqhw,qc->bchw", probs_t, self.bin_centers)
+
+
+def load_model(source, revision=None, device="cpu"):
+    path = Path(source)
+    if not path.is_dir():
+        path = Path(snapshot_download(source, revision=revision,
+            allow_patterns=["config.json", "model.safetensors"]))
+    config = json.loads((path / "config.json").read_text())
+    state = load_file(str(path / "model.safetensors"))
+    centers = torch.tensor(config["bin_centers"], dtype=torch.float32)
+    if not torch.equal(centers, state["bin_centers"]):
+        raise ValueError("Checkpoint config and state color bins differ; refusing ambiguous decode")
+    model = SmallUNetColorizer(**config)
+    model.load_state_dict(state, strict=True)
+    model.to(device).eval()
+    return model
+
+def save_model(model, path):
+    path = Path(path); path.mkdir(parents=True, exist_ok=True)
+    model.save_pretrained(path)
+    # Mixin config can retain constructor bins; use the actual authoritative buffer.
+    cfg = json.loads((path / "config.json").read_text())
+    cfg["bin_centers"] = model.bin_centers.detach().cpu().tolist()
+    (path / "config.json").write_text(json.dumps(cfg, indent=2))

experiments/round5-20260927/source/persistence.py

@@ -0,0 +1,42 @@
+"""Commit run artifacts atomically and verify every changed file by SHA256."""
+import hashlib, json, os, time
+from pathlib import Path
+from huggingface_hub import HfApi, CommitOperationAdd, hf_hub_download
+
+REPO = 'User-2468/mini-unet-colorizer'
+PREFIX = 'experiments/round5-20260927'
+
+class DurableRun:
+    def __init__(self, root):
+        if not os.environ.get('HF_TOKEN'):
+            raise RuntimeError('A write token is required before starting')
+        self.api = HfApi(token=os.environ['HF_TOKEN'])
+        if self.api.whoami()['name'] != 'User-2468':
+            raise RuntimeError('Unexpected account')
+        self.root = Path(root)
+        self.saved = {}
+
+    def sync(self, reason):
+        files = [p for p in sorted(self.root.rglob('*')) if p.is_file()]
+        hashes = {p.relative_to(self.root).as_posix(): hashlib.sha256(p.read_bytes()).hexdigest() for p in files}
+        changed = [p for p in files if self.saved.get(p.relative_to(self.root).as_posix()) != hashes[p.relative_to(self.root).as_posix()]]
+        if not changed:
+            return
+        for attempt in range(3):
+            try:
+                head = self.api.model_info(REPO, revision='main').sha
+                operations = [CommitOperationAdd(path_in_repo=PREFIX+'/'+p.relative_to(self.root).as_posix(), path_or_fileobj=str(p)) for p in changed]
+                operations.append(CommitOperationAdd(path_in_repo=PREFIX+'/SHA256SUMS.json', path_or_fileobj=json.dumps(hashes,sort_keys=True,indent=2).encode()))
+                commit = self.api.create_commit(repo_id=REPO, revision='main', parent_commit=head, operations=operations, commit_message='Colorizer round5: '+reason)
+                for p in changed:
+                    name = p.relative_to(self.root).as_posix()
+                    downloaded = hf_hub_download(REPO, PREFIX+'/'+name, revision=commit.oid, force_download=True, token=os.environ['HF_TOKEN'])
+                    if hashlib.sha256(Path(downloaded).read_bytes()).hexdigest() != hashes[name]:
+                        raise RuntimeError('Remote checksum mismatch: '+name)
+                self.saved = hashes
+                print('PERSISTED',reason,commit.oid,'verified_files',len(changed),flush=True)
+                return
+            except Exception:
+                if attempt == 2:
+                    raise
+                time.sleep(2**attempt)

experiments/round5-20260927/source/spatial.py

@@ -0,0 +1,34 @@
+"""Controlled spatial decoding alternatives; no learned parameters."""
+import math
+import torch
+import torch.nn.functional as F
+
+def box_mean(x,radius):
+    # Border-normalized local windows, also work on images smaller than kernel.
+    return F.avg_pool2d(x,2*radius+1,stride=1,padding=radius,count_include_pad=False)
+
+def guided_chroma(L,ab,radius=4,epsilon=.001):
+    """Scalar luminance-guided local linear filter (He et al., ECCV 2010).
+
+    L is the network's [-1,1] luminance. Epsilon is in [0,1] luminance units.
+    Uses luminance only; reference colors never enter inference.
+    """
+    if not isinstance(radius,int) or radius<0 or not math.isfinite(epsilon) or epsilon<=0:
+        raise ValueError('Invalid guided-filter radius or epsilon')
+    if radius==0:return ab
+    I=(L.float()+1)/2;p=ab.float()
+    mi=box_mean(I,radius);mp=box_mean(p,radius)
+    var=(box_mean(I*I,radius)-mi*mi).clamp_min(0)
+    cov=box_mean(I*p,radius)-mi*mp
+    a=cov/(var+epsilon);b=mp-a*mi
+    return box_mean(a,radius)*I+box_mean(b,radius)
+
+def spatial_decode(model,logits,L,temperature=.38,pool=1,radius=0,epsilon=.001):
+    if pool<1 or not isinstance(pool,int):raise ValueError('pool must be a positive integer')
+    if pool>1:
+        # Average evidence before annealing, then upsample chroma, not RGB.
+        small=F.avg_pool2d(logits,pool,ceil_mode=True,count_include_pad=False)
+        ab=model.decode(small,temperature)
+        ab=F.interpolate(ab,size=L.shape[-2:],mode='bilinear',align_corners=False)
+    else:ab=model.decode(logits,temperature)
+    return guided_chroma(L,ab,radius,epsilon)

experiments/round5-20260927/source/train.py

@@ -0,0 +1,259 @@
+"""Round 4: matched multiscale structure and DDColor distillation experiments."""
+import os,sys,json,time,random,hashlib,traceback,shutil
+from pathlib import Path
+import numpy as np
+import cv2
+from PIL import Image,ImageDraw
+from skimage import data as sample_data
+from skimage.color import rgb2lab,lab2rgb
+import pyarrow as pa
+import pyarrow.parquet as pq
+import torch
+import torch.nn.functional as F
+from torch.utils.data import Dataset,DataLoader
+from huggingface_hub import HfApi,hf_hub_download,PyTorchModelHubMixin
+from model import load_model,save_model
+from data import decode_image,ColorBins
+from metrics import soft_ce,per_image_metrics
+from spatial import guided_chroma
+
+from persistence import DurableRun
+OUT=Path('round5');OUT.mkdir(exist_ok=True)
+DURABLE=None
+START=time.monotonic();DEADLINE=START+3.5*3600
+DEVICE='cuda';SEED=409;STEPS=3000
+BASE_REV='704fa80d792c3d759db91daa00b2dcfe6f0f6412'
+BASE_HASH='0e4c417375684a044860f8af3ac3a2fb44e1a5729254ca33abda758ea71aea6e'
+TEACHER_ID='piddnad/ddcolor_artistic'
+torch.set_num_threads(6)
+
+def deadline():
+    if time.monotonic()>DEADLINE:raise TimeoutError('Graceful export before remote hard timeout')
+
+def gray_arrays(im,style='gray'):
+    im=im.resize((256,256),Image.Resampling.BILINEAR)
+    rgb=np.asarray(im,np.float32)/255
+    lab=rgb2lab(rgb).astype(np.float32)
+    if style=='film':
+        g=(rgb*np.array([.42,.45,.13],np.float32)).sum(-1)
+        g=np.clip((g**1.15-.5)*.8+.5,0,1)
+    else:g=np.asarray(im.convert('L'),np.float32)/255
+    # Feed the same neutral sRGB input to teacher and student.
+    gray=np.repeat(g[...,None],3,-1).astype(np.float32)
+    L=rgb2lab(gray)[...,0].astype(np.float32)
+    return (L[None]/50-1).copy(),lab[...,1:].transpose(2,0,1).copy(),gray
+
+class Photos(Dataset):
+    def __init__(self,table,ids,bins=None,cache=None,augment=False,style='gray'):
+        self.table,self.ids,self.bins,self.cache,self.augment,self.style=table,ids,bins,cache,augment,style
+    def __len__(self):return len(self.ids)
+    def __getitem__(self,k):
+        L,ab,gray=gray_arrays(decode_image(self.table,self.ids[k]),self.style)
+        teach=np.array(self.cache[k],np.float32) if self.cache is not None else np.zeros((2,64,64),np.float32)
+        if self.augment:
+            if random.random()<.5:L=L[...,::-1].copy();ab=ab[...,::-1].copy();teach=teach[...,::-1].copy()
+            if random.random()<.3:L=np.clip(L*random.uniform(.85,1.15)+random.uniform(-.08,.08),-1,1)
+        if self.bins is not None:
+            idx,w=self.bins.encode(ab.transpose(1,2,0));return torch.from_numpy(L),torch.from_numpy(ab),torch.from_numpy(idx),torch.from_numpy(w),torch.from_numpy(teach)
+        return torch.from_numpy(L),torch.from_numpy(ab),torch.from_numpy(gray.transpose(2,0,1)),self.ids[k]
+
+def patch_excess(p,t):
+    """Excess color differences across 4–64px regions, in target-flat areas."""
+    values=[]
+    for scale in [4,16]:
+        a=F.avg_pool2d(p,scale);b=F.avg_pool2d(t,scale)
+        for offset in [1,4]:
+            for dim in [-1,-2]:
+                x=a.narrow(dim,offset,a.shape[dim]-offset)-a.narrow(dim,0,a.shape[dim]-offset)
+                y=b.narrow(dim,offset,b.shape[dim]-offset)-b.narrow(dim,0,b.shape[dim]-offset)
+                dx=x.norm(dim=1);dy=y.norm(dim=1);mask=(dy<3).float()
+                values.append(((dx-dy-1).relu()*mask).sum((1,2))/mask.sum((1,2)).clamp_min(1))
+    return sum(values)/len(values)
+
+def structural_loss(p,t):
+    terms=[]
+    for scale in [4,16]:
+        a=F.avg_pool2d(p,scale);b=F.avg_pool2d(t,scale)
+        for offset in [1,4]:
+            for dim in [-1,-2]:
+                x=a.narrow(dim,offset,a.shape[dim]-offset)-a.narrow(dim,0,a.shape[dim]-offset)
+                y=b.narrow(dim,offset,b.shape[dim]-offset)-b.narrow(dim,0,b.shape[dim]-offset)
+                terms.append(F.smooth_l1_loss(x/10,y/10,beta=.3))
+    return sum(terms)/len(terms)
+
+def additional_losses(p,t,teacher):
+    small=F.avg_pool2d(p,4);target=F.avg_pool2d(t,4)
+    # Teacher is fallible; reduce guidance when it conflicts strongly with ground truth.
+    confidence=torch.exp(-(teacher-target).norm(dim=1,keepdim=True)/30).detach()
+    kd=(F.smooth_l1_loss(small/20,teacher/20,beta=.5,reduction='none')*confidence).mean()
+    neutral=(t.norm(dim=1)<3).float()
+    neutral_loss=(p.norm(dim=1)*neutral).sum()/neutral.sum().clamp_min(1)/20
+    return structural_loss(p,t),kd,neutral_loss
+
+def measure(L,p,t,raw=None):
+    r=per_image_metrics(L,p,t);C=p.norm(dim=1);T=t.norm(dim=1)
+    for name,mask,event in [('missed_color',T>12,C<5),('neutral_spill',T<3,C>10)]:
+        r[name]=(mask&event).sum((1,2))/mask.sum((1,2)).clamp_min(1)
+    r['color_coverage']=(C>10).float().mean((1,2));r['patch_excess']=patch_excess(p,t)
+    r['raw_patch_excess']=patch_excess(p if raw is None else raw,t)
+    return r
+
+@torch.inference_mode()
+def teacher_predict(teacher,gray):
+    gray=F.interpolate(gray.to(DEVICE),size=(512,512),mode='bilinear',align_corners=False)
+    # Full precision is deliberate: spectral normalization / attention are not assumed BF16-safe.
+    out=teacher(gray).float()
+    assert out.shape[1]==2 and torch.isfinite(out).all()
+    return F.interpolate(out,size=(256,256),mode='bilinear',align_corners=False)
+
+@torch.inference_mode()
+def evaluate(model,table,ids,is_teacher=False):
+    result={};model.eval()
+    for style in ['gray','film']:
+        rows=[]
+        for L,t,gray,indices in DataLoader(Photos(table,ids,style=style),batch_size=2 if is_teacher else 8,num_workers=4):
+            deadline();L,t=L.to(DEVICE),t.to(DEVICE)
+            raw=teacher_predict(model,gray) if is_teacher else model.decode(model(L),.38)
+            pred=raw if is_teacher else guided_chroma(L,raw,8)
+            metrics=measure(L,pred,t,raw)
+            for j,index in enumerate(indices):rows.append({'index':int(index)}|{k:float(v[j]) for k,v in metrics.items()})
+        keep=[x for x in rows if x['target_chroma']>=5]
+        result[style]={'n_total':len(rows),'n_color':len(keep),'summary':{k:float(np.mean([x[k] for x in keep])) for k in keep[0] if k!='index'},'per_image':rows}
+    return result
+
+def selection(result,baseline):
+    scores=[];eligible=True
+    for style in ['gray','film']:
+        s=result[style]['summary'];b=baseline[style]['summary']
+        eligible &= (s['ab_error']<=b['ab_error']*1.05 and s['neutral_spill']<=b['neutral_spill']+.01
+                     and s['missed_color']<=b['missed_color']+.01 and s['color_coverage']>=.95*b['color_coverage']
+                     and s['patch_excess']<.85*b['patch_excess'] and s['raw_patch_excess']<.9*b['raw_patch_excess'])
+        scores.append(s['patch_excess']/max(b['patch_excess'],1e-6)+.3*s['neutral_spill']+.2*s['ab_error']/b['ab_error'])
+    return float(np.mean(scores)),bool(eligible)
+
+@torch.inference_mode()
+def probes(model,tag,teacher=False):
+    names=['astronaut','coffee','chelsea','rocket','camera','coins','moon'];images=[]
+    for name in names:
+        original=Image.fromarray(getattr(sample_data,name)()).convert('RGB')
+        L,_,gray=gray_arrays(original);x=torch.from_numpy(L)[None].to(DEVICE)
+        ab=teacher_predict(model,torch.from_numpy(gray.transpose(2,0,1))[None]) if teacher else guided_chroma(x,model.decode(model(x),.38),8)
+        lab=np.concatenate([(L[0]*50+50)[...,None],ab[0].cpu().numpy().transpose(1,2,0)],-1)
+        rgb=np.uint8(np.clip(lab2rgb(lab),0,1)*255)
+        images.append((name,Image.fromarray(np.uint8(gray*255)),Image.fromarray(rgb)))
+    canvas=Image.new('RGB',(512,len(names)*280),'white');d=ImageDraw.Draw(canvas)
+    for i,(name,gray,col) in enumerate(images):
+        canvas.paste(gray,(0,i*280+24));canvas.paste(col,(256,i*280+24));d.text((4,i*280+4),name+' input | '+tag,fill='black')
+    canvas.save(OUT/(tag+'.jpg'),quality=90)
+
+def write(name,obj):
+    (OUT/name).write_text(json.dumps(obj,indent=2));return obj
+
+def run():
+    global DURABLE
+    DURABLE=DurableRun(OUT)
+    source=OUT/'source';source.mkdir(exist_ok=True)
+    for p in Path('.').glob('*.py'):shutil.copy2(p,source/p.name)
+    shutil.copy2('previous_manifest.json',source/'previous_manifest.json')
+    shutil.copy2('PROTOCOL.md',source/'PROTOCOL.md')
+    shutil.copytree('vendor_ddcolor',source/'vendor_ddcolor',dirs_exist_ok=True,ignore=shutil.ignore_patterns('__pycache__'))
+    write('status.json',{'status':'initializing'})
+    torch.manual_seed(SEED);np.random.seed(SEED);random.seed(SEED);torch.backends.cudnn.benchmark=True
+    root=Path('init');root.mkdir(exist_ok=True)
+    for name in ['model.safetensors','config.json']:
+        root.joinpath(name).write_bytes(Path(hf_hub_download('User-2468/mini-unet-colorizer',name,revision=BASE_REV)).read_bytes())
+    assert hashlib.sha256((root/'model.safetensors').read_bytes()).hexdigest()==BASE_HASH
+    model=load_model(root,device=DEVICE);save_model(model,OUT/'best')
+    write('selection.json',{'arm':'v2_baseline','step':0,'accepted':False})
+    DURABLE.sync('baseline checkpoint and source before GPU work')
+    # Pin source by bundled git revision and resolve the teacher model revision exactly once.
+    from ddcolor import DDColor
+    class DDColorHF(DDColor,PyTorchModelHubMixin):
+        def __init__(self,config=None,**kw):super().__init__(**({**config,**kw} if isinstance(config,dict) else kw))
+    teacher_rev=HfApi().model_info(TEACHER_ID).sha
+    teacher=DDColorHF.from_pretrained(TEACHER_ID,revision=teacher_rev).to(DEVICE).eval()
+    for p in teacher.parameters():p.requires_grad_(False)
+    # Verify the actual GPU teacher batch and student backward path before data preparation.
+    assert torch.cuda.is_available()
+    print('PREFLIGHT teacher forward',flush=True)
+    smoke_teacher=teacher_predict(teacher,torch.full((4,3,256,256),.5))
+    assert smoke_teacher.shape==(4,2,256,256)
+    del smoke_teacher
+    model.eval();model.zero_grad(set_to_none=True)
+    with torch.autocast('cuda',dtype=torch.bfloat16):
+        smoke_logits=model(torch.zeros(2,1,256,256,device=DEVICE))
+    smoke_pred=model.decode(smoke_logits,.38)
+    smoke_losses=additional_losses(smoke_pred,torch.zeros_like(smoke_pred),torch.zeros(2,2,64,64,device=DEVICE))
+    sum(smoke_losses).backward()
+    assert all(torch.isfinite(p.grad).all() for p in model.parameters() if p.grad is not None)
+    model.zero_grad(set_to_none=True);del smoke_logits,smoke_pred,smoke_losses
+    print('PREFLIGHT PASSED: teacher batch 4, student BF16 backward, finite gradients, '+torch.cuda.get_device_name(),flush=True)
+    write('provenance.json',{'teacher_id':TEACHER_ID,'teacher_revision':teacher_rev,'teacher_parameters':sum(p.numel() for p in teacher.parameters()),'ddcolor_git':'2adb63f2656ac41cbdf7b894cddd94121a3faf13','base_revision':BASE_REV,'base_sha256':BASE_HASH,'steps_per_arm':STEPS,'seed':SEED,'teacher_input_size':512,'warning':'Existing development holdouts; teacher upstream training overlap unknown; no production certification.'})
+    probes(model,'v2');probes(teacher,'ddcolor_artistic',True)
+    DURABLE.sync('teacher preflight and visual baselines')
+    tables=[]
+    for repo,rev,files in [('johnowhitaker/imagenette2-320','771c1310a2487e8076ede6b7d6307244aa8400af',['default/train/0000.parquet']),('detection-datasets/coco','26ddc382fe75dfc2a0655b5977e296ea10efebce',['default/train/0000.parquet','default/train/0001.parquet'])]:
+        for file in files:tables.append(pq.read_table(hf_hub_download(repo,file,repo_type='dataset',revision=rev),columns=['image']))
+    table=pa.concat_tables(tables);manifest=json.loads(Path('previous_manifest.json').read_text())
+    ids=manifest['train'];val=manifest['validation'];test=manifest['test']
+    assert all(not set(a)&set(b) for a,b in [(ids,val),(ids,test),(val,test)])
+    write('manifest.json',manifest)
+    baseline=write('baseline_validation.json',evaluate(model,table,val))
+    write('teacher_validation.json',evaluate(teacher,table,val,True))
+    write('teacher_test.json',evaluate(teacher,table,test,True))
+    print('BASELINE',json.dumps({k:v['summary'] for k,v in baseline.items()}),flush=True)
+    DURABLE.sync('baseline and teacher evaluation')
+    cache=np.lib.format.open_memmap('teacher_cache.npy',mode='w+',dtype=np.float16,shape=(len(ids),2,64,64))
+    offset=0
+    for L,t,gray,indices in DataLoader(Photos(table,ids),batch_size=4,num_workers=4):
+        deadline();ab=F.avg_pool2d(teacher_predict(teacher,gray),4).cpu().numpy();cache[offset:offset+len(ab)]=ab;offset+=len(ab)
+        if offset%400==0:print('TEACHER_CACHE',offset,len(ids),'seconds',int(time.monotonic()-START),flush=True)
+    cache.flush();del teacher;torch.cuda.empty_cache()
+    bins=ColorBins(model.bin_centers.cpu().numpy());best_score=float('inf');history=[]
+    for arm,kd_weight in [('structure_control',0.),('structure_distilled',1.)]:
+        torch.manual_seed(SEED);np.random.seed(SEED);random.seed(SEED)
+        model=load_model(root,device=DEVICE)
+        optimizer=torch.optim.AdamW(model.parameters(),lr=3e-5,weight_decay=1e-4)
+        sched=torch.optim.lr_scheduler.CosineAnnealingLR(optimizer,STEPS,eta_min=3e-6)
+        loader=DataLoader(Photos(table,ids,bins,cache,True),batch_size=16,shuffle=True,num_workers=6,pin_memory=True,persistent_workers=True,generator=torch.Generator().manual_seed(SEED));it=iter(loader)
+        for step in range(1,STEPS+1):
+            deadline();model.train()
+            for m in model.modules():
+                if isinstance(m,torch.nn.BatchNorm2d):m.eval()
+            try:batch=next(it)
+            except StopIteration:it=iter(loader);batch=next(it)
+            L,t,idx,w,teach=[x.to(DEVICE,non_blocking=True) for x in batch]
+            optimizer.zero_grad(set_to_none=True)
+            with torch.autocast('cuda',dtype=torch.bfloat16):z=model(L)
+            p=model.decode(z,.38);structure,kd,neutral=additional_losses(p,t,teach)
+            loss=soft_ce(z,idx,w)+structure+kd_weight*kd+.3*neutral
+            if not torch.isfinite(loss):raise RuntimeError('Non-finite training loss')
+            loss.backward();torch.nn.utils.clip_grad_norm_(model.parameters(),1,error_if_nonfinite=True);optimizer.step();sched.step()
+            if step%100==0:print('STEP',arm,step,'loss',float(loss),'seconds',int(time.monotonic()-START),flush=True)
+            if step%250==0:
+                save_model(model,OUT/arm/'latest')
+                torch.save({'optimizer':optimizer.state_dict(),'scheduler':sched.state_dict(),'arm':arm,'step':step,'seed':SEED},OUT/arm/'latest'/'training_state.pt')
+                write('progress.json',{'arm':arm,'step':step,'elapsed_seconds':time.monotonic()-START})
+                DURABLE.sync(arm+' step '+str(step))
+            if step%500==0:
+                result=evaluate(model,table,val);score,ok=selection(result,baseline)
+                record={'arm':arm,'step':step,'eligible':ok,'score':score,'summary':{k:v['summary'] for k,v in result.items()}}
+                history.append(record);write('history.json',history);write(f'{arm}_{step}_validation.json',result);probes(model,f'{arm}_{step}')
+                if ok and score<best_score:
+                    best_score=score;save_model(model,OUT/'best');write('selection.json',{'arm':arm,'step':step,'accepted':True,'score':score})
+                print('VALIDATION',json.dumps(record),flush=True)
+                DURABLE.sync(arm+' evaluation '+str(step))
+        del it,loader,model,optimizer;torch.cuda.empty_cache()
+    for tag,path in [('v2',root),('selected',OUT/'best')]:
+        model=load_model(path,device=DEVICE);write(tag+'_test.json',evaluate(model,table,test));probes(model,tag+'_final')
+    write('status.json',{'status':'completed','elapsed_seconds':time.monotonic()-START})
+    chosen=json.loads((OUT/'selection.json').read_text())
+    (OUT/'best'/'README.md').write_text('# Mini U-Net round5 candidate\n\nExperimental checkpoint; visual review required before deployment.\n\nSelection: '+json.dumps(chosen)+'\n\nSee ../source/PROTOCOL.md, ../provenance.json, ../history.json and ../selected_test.json. Trained on Imagenette and COCO; DDColor teacher uses data with possible evaluation overlap. Predictions are plausible colors, not recovered historical colors. Architecture and decoder remain compatible with the existing Space.\n')
+    DURABLE.sync('completed checkpoint, model card and evaluation')
+
+if __name__=='__main__':
+    try:run()
+    except BaseException as e:
+        write('status.json',{'status':'interrupted_or_failed','error_type':type(e).__name__,'traceback':traceback.format_exc().replace(os.environ.get('HF_TOKEN','__NO_TOKEN__'),'[REDACTED]')})
+        if DURABLE is not None:DURABLE.sync('interrupted status and available checkpoints')
+        raise

experiments/round5-20260927/source/vendor_ddcolor/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

experiments/round5-20260927/source/vendor_ddcolor/basicsr/__init__.py

@@ -0,0 +1,16 @@
+"""BasicSR (vendored)
+
+This repo's inference scripts only need a small subset under `basicsr.archs...`.
+Upstream BasicSR's `basicsr/__init__.py` often does `import *` from archs/data/losses/metrics/models/train/utils,
+which pulls in many training-only dependencies during inference import.
+
+We keep this `__init__` lightweight to avoid import-time side effects.
+Training code should explicitly import the needed submodules.
+"""
+
+# flake8: noqa
+try:
+    from .version import __gitsha__, __version__  # type: ignore
+except Exception:
+    __gitsha__ = None
+    __version__ = None

experiments/round5-20260927/source/vendor_ddcolor/basicsr/archs/__init__.py

@@ -0,0 +1,41 @@
+import importlib
+import logging
+import os
+from copy import deepcopy
+from os import path as osp
+
+from basicsr.utils.registry import ARCH_REGISTRY
+
+__all__ = ['build_network']
+
+_ARCHS_IMPORTED = False
+
+
+def _ensure_arch_modules_imported():
+    """Lazy import arch modules for registry.
+
+    In upstream BasicSR, importing `basicsr.archs` scans and imports all `*_arch.py`
+    modules eagerly to populate the registry. That adds import overhead and may
+    pull in extra dependencies in inference-only scenarios.
+    Here we make it lazy: only scan/import when `build_network` is actually called.
+    """
+    global _ARCHS_IMPORTED
+    if _ARCHS_IMPORTED:
+        return
+    arch_folder = osp.dirname(osp.abspath(__file__))
+    arch_filenames = []
+    for name in os.listdir(arch_folder):
+        if name.endswith("_arch.py"):
+            arch_filenames.append(osp.splitext(name)[0])
+    for file_name in arch_filenames:
+        importlib.import_module(f'basicsr.archs.{file_name}')
+    _ARCHS_IMPORTED = True
+
+
+def build_network(opt):
+    _ensure_arch_modules_imported()
+    opt = deepcopy(opt)
+    network_type = opt.pop('type')
+    net = ARCH_REGISTRY.get(network_type)(**opt)
+    logging.getLogger('basicsr').info(f'Network [{net.__class__.__name__}] is created.')
+    return net

experiments/round5-20260927/source/vendor_ddcolor/basicsr/archs/ddcolor_arch_utils/convnext.py

@@ -0,0 +1,206 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+# ---- Optional dependency: timm ----
+# This file only needs two small helpers from timm: `trunc_normal_` and `DropPath`.
+# To reduce inference dependencies, we provide a pure-PyTorch fallback implementation.
+try:
+    from timm.layers import trunc_normal_, DropPath  # type: ignore
+except Exception:
+    import math
+
+    def trunc_normal_(tensor, mean=0.0, std=1.0, a=-2.0, b=2.0):
+        """Fills the input Tensor with values drawn from a truncated normal distribution.
+
+        Fallback implementation when timm is not available.
+        """
+        # Prefer PyTorch built-in if present
+        if hasattr(torch.nn.init, "trunc_normal_"):
+            return torch.nn.init.trunc_normal_(tensor, mean=mean, std=std, a=a, b=b)
+
+        # Based on PyTorch's internal implementation pattern
+        def norm_cdf(x):
+            return (1.0 + math.erf(x / math.sqrt(2.0))) / 2.0
+
+        with torch.no_grad():
+            l = norm_cdf((a - mean) / std)
+            u = norm_cdf((b - mean) / std)
+
+            tensor.uniform_(2 * l - 1, 2 * u - 1)
+            tensor.erfinv_()
+
+            tensor.mul_(std * math.sqrt(2.0))
+            tensor.add_(mean)
+            tensor.clamp_(min=a, max=b)
+            return tensor
+
+
+    class DropPath(nn.Module):
+        """Stochastic Depth per sample (when applied in main path of residual blocks)."""
+
+        def __init__(self, drop_prob: float = 0.0):
+            super().__init__()
+            self.drop_prob = float(drop_prob)
+
+        def forward(self, x):
+            if self.drop_prob == 0.0 or not self.training:
+                return x
+            keep_prob = 1.0 - self.drop_prob
+            shape = (x.shape[0],) + (1,) * (x.ndim - 1)
+            random_tensor = keep_prob + torch.rand(
+                shape, dtype=x.dtype, device=x.device
+            )
+            random_tensor.floor_()
+            return x.div(keep_prob) * random_tensor
+
+class Block(nn.Module):
+    r""" ConvNeXt Block. There are two equivalent implementations:
+    (1) DwConv -> LayerNorm (channels_first) -> 1x1 Conv -> GELU -> 1x1 Conv; all in (N, C, H, W)
+    (2) DwConv -> Permute to (N, H, W, C); LayerNorm (channels_last) -> Linear -> GELU -> Linear; Permute back
+    We use (2) as we find it slightly faster in PyTorch
+    
+    Args:
+        dim (int): Number of input channels.
+        drop_path (float): Stochastic depth rate. Default: 0.0
+        layer_scale_init_value (float): Init value for Layer Scale. Default: 1e-6.
+    """
+    def __init__(self, dim, drop_path=0., layer_scale_init_value=1e-6):
+        super().__init__()
+        self.dwconv = nn.Conv2d(dim, dim, kernel_size=7, padding=3, groups=dim) # depthwise conv
+        self.norm = LayerNorm(dim, eps=1e-6)
+        self.pwconv1 = nn.Linear(dim, 4 * dim) # pointwise/1x1 convs, implemented with linear layers
+        self.act = nn.GELU()
+        self.pwconv2 = nn.Linear(4 * dim, dim)
+        self.gamma = nn.Parameter(layer_scale_init_value * torch.ones((dim)), 
+                                    requires_grad=True) if layer_scale_init_value > 0 else None
+        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
+
+    def forward(self, x):
+        input = x
+        x = self.dwconv(x)
+        x = x.permute(0, 2, 3, 1) # (N, C, H, W) -> (N, H, W, C)
+        x = self.norm(x)
+        x = self.pwconv1(x)
+        x = self.act(x)
+        x = self.pwconv2(x)
+        if self.gamma is not None:
+            x = self.gamma * x
+        x = x.permute(0, 3, 1, 2) # (N, H, W, C) -> (N, C, H, W)
+
+        x = input + self.drop_path(x)
+        return x
+
+class ConvNeXt(nn.Module):
+    r""" ConvNeXt
+        A PyTorch impl of : `A ConvNet for the 2020s`  -
+          https://arxiv.org/pdf/2201.03545.pdf
+    Args:
+        in_chans (int): Number of input image channels. Default: 3
+        num_classes (int): Number of classes for classification head. Default: 1000
+        depths (tuple(int)): Number of blocks at each stage. Default: [3, 3, 9, 3]
+        dims (int): Feature dimension at each stage. Default: [96, 192, 384, 768]
+        drop_path_rate (float): Stochastic depth rate. Default: 0.
+        layer_scale_init_value (float): Init value for Layer Scale. Default: 1e-6.
+        head_init_scale (float): Init scaling value for classifier weights and biases. Default: 1.
+    """
+    def __init__(self, in_chans=3, num_classes=1000, 
+                 depths=[3, 3, 9, 3], dims=[96, 192, 384, 768], drop_path_rate=0., 
+                 layer_scale_init_value=1e-6, head_init_scale=1.,
+                 ):
+        super().__init__()
+
+        self.downsample_layers = nn.ModuleList() # stem and 3 intermediate downsampling conv layers
+        stem = nn.Sequential(
+            nn.Conv2d(in_chans, dims[0], kernel_size=4, stride=4),
+            LayerNorm(dims[0], eps=1e-6, data_format="channels_first")
+        )
+        self.downsample_layers.append(stem)
+        for i in range(3):
+            downsample_layer = nn.Sequential(
+                    LayerNorm(dims[i], eps=1e-6, data_format="channels_first"),
+                    nn.Conv2d(dims[i], dims[i+1], kernel_size=2, stride=2),
+            )
+            self.downsample_layers.append(downsample_layer)
+
+        self.stages = nn.ModuleList() # 4 feature resolution stages, each consisting of multiple residual blocks
+        dp_rates=[x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))] 
+        cur = 0
+        for i in range(4):
+            stage = nn.Sequential(
+                *[Block(dim=dims[i], drop_path=dp_rates[cur + j], 
+                layer_scale_init_value=layer_scale_init_value) for j in range(depths[i])]
+            )
+            self.stages.append(stage)
+            cur += depths[i]
+
+        # add norm layers for each output
+        out_indices = (0, 1, 2, 3)
+        for i in out_indices:
+            layer = LayerNorm(dims[i], eps=1e-6, data_format="channels_first")
+            # layer = nn.Identity()
+            layer_name = f'norm{i}'
+            self.add_module(layer_name, layer)
+
+        self.norm = nn.LayerNorm(dims[-1], eps=1e-6) # final norm layer
+        # self.head_cls = nn.Linear(dims[-1], 4)
+
+        self.apply(self._init_weights)
+        # self.head_cls.weight.data.mul_(head_init_scale)
+        # self.head_cls.bias.data.mul_(head_init_scale)
+
+    def _init_weights(self, m):
+        if isinstance(m, (nn.Conv2d, nn.Linear)):
+            trunc_normal_(m.weight, std=.02)
+            nn.init.constant_(m.bias, 0)
+
+    def forward_features(self, x):
+        for i in range(4):
+            x = self.downsample_layers[i](x)
+            x = self.stages[i](x)
+
+            # add extra norm
+            norm_layer = getattr(self, f'norm{i}')
+            # x = norm_layer(x)
+            norm_layer(x)
+
+        return self.norm(x.mean([-2, -1])) # global average pooling, (N, C, H, W) -> (N, C)
+
+    def forward(self, x):
+        x = self.forward_features(x)
+        # x = self.head_cls(x)
+        return x
+
+class LayerNorm(nn.Module):
+    r""" LayerNorm that supports two data formats: channels_last (default) or channels_first. 
+    The ordering of the dimensions in the inputs. channels_last corresponds to inputs with 
+    shape (batch_size, height, width, channels) while channels_first corresponds to inputs 
+    with shape (batch_size, channels, height, width).
+    """
+    def __init__(self, normalized_shape, eps=1e-6, data_format="channels_last"):
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(normalized_shape))
+        self.bias = nn.Parameter(torch.zeros(normalized_shape))
+        self.eps = eps
+        self.data_format = data_format
+        if self.data_format not in ["channels_last", "channels_first"]:
+            raise NotImplementedError 
+        self.normalized_shape = (normalized_shape, )
+    
+    def forward(self, x):
+        if self.data_format == "channels_last":  # B H W C
+            return F.layer_norm(x, self.normalized_shape, self.weight, self.bias, self.eps)
+        elif self.data_format == "channels_first":  # B C H W
+            u = x.mean(1, keepdim=True)
+            s = (x - u).pow(2).mean(1, keepdim=True)
+            x = (x - u) / torch.sqrt(s + self.eps)
+            x = self.weight[:, None, None] * x + self.bias[:, None, None]
+            return x

experiments/round5-20260927/source/vendor_ddcolor/basicsr/archs/ddcolor_arch_utils/position_encoding.py

@@ -0,0 +1,52 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+# Modified from: https://github.com/facebookresearch/detr/blob/master/models/position_encoding.py
+"""
+Various positional encodings for the transformer.
+"""
+import math
+
+import torch
+from torch import nn
+
+
+class PositionEmbeddingSine(nn.Module):
+    """
+    This is a more standard version of the position embedding, very similar to the one
+    used by the Attention is all you need paper, generalized to work on images.
+    """
+
+    def __init__(self, num_pos_feats=64, temperature=10000, normalize=False, scale=None):
+        super().__init__()
+        self.num_pos_feats = num_pos_feats
+        self.temperature = temperature
+        self.normalize = normalize
+        if scale is not None and normalize is False:
+            raise ValueError("normalize should be True if scale is passed")
+        if scale is None:
+            scale = 2 * math.pi
+        self.scale = scale
+
+    def forward(self, x, mask=None):
+        if mask is None:
+            mask = torch.zeros((x.size(0), x.size(2), x.size(3)), device=x.device, dtype=torch.bool)
+        not_mask = ~mask
+        y_embed = not_mask.cumsum(1, dtype=torch.float32)
+        x_embed = not_mask.cumsum(2, dtype=torch.float32)
+        if self.normalize:
+            eps = 1e-6
+            y_embed = y_embed / (y_embed[:, -1:, :] + eps) * self.scale
+            x_embed = x_embed / (x_embed[:, :, -1:] + eps) * self.scale
+
+        dim_t = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device)
+        dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_pos_feats)
+
+        pos_x = x_embed[:, :, :, None] / dim_t
+        pos_y = y_embed[:, :, :, None] / dim_t
+        pos_x = torch.stack(
+            (pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4
+        ).flatten(3)
+        pos_y = torch.stack(
+            (pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4
+        ).flatten(3)
+        pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2)
+        return pos

experiments/round5-20260927/source/vendor_ddcolor/basicsr/archs/ddcolor_arch_utils/transformer.py

@@ -0,0 +1,368 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+# Modified from: https://github.com/facebookresearch/detr/blob/master/models/transformer.py
+"""
+Transformer class.
+Copy-paste from torch.nn.Transformer with modifications:
+    * positional encodings are passed in MHattention
+    * extra LN at the end of encoder is removed
+    * decoder returns a stack of activations from all decoding layers
+"""
+import copy
+from typing import List, Optional
+
+import torch
+import torch.nn.functional as F
+from torch import Tensor, nn
+
+
+class Transformer(nn.Module):
+    def __init__(
+        self,
+        d_model=512,
+        nhead=8,
+        num_encoder_layers=6,
+        num_decoder_layers=6,
+        dim_feedforward=2048,
+        dropout=0.1,
+        activation="relu",
+        normalize_before=False,
+        return_intermediate_dec=False,
+    ):
+        super().__init__()
+
+        encoder_layer = TransformerEncoderLayer(
+            d_model, nhead, dim_feedforward, dropout, activation, normalize_before
+        )
+        encoder_norm = nn.LayerNorm(d_model) if normalize_before else None
+        self.encoder = TransformerEncoder(encoder_layer, num_encoder_layers, encoder_norm)
+
+        decoder_layer = TransformerDecoderLayer(
+            d_model, nhead, dim_feedforward, dropout, activation, normalize_before
+        )
+        decoder_norm = nn.LayerNorm(d_model)
+        self.decoder = TransformerDecoder(
+            decoder_layer,
+            num_decoder_layers,
+            decoder_norm,
+            return_intermediate=return_intermediate_dec,
+        )
+
+        self._reset_parameters()
+
+        self.d_model = d_model
+        self.nhead = nhead
+
+    def _reset_parameters(self):
+        for p in self.parameters():
+            if p.dim() > 1:
+                nn.init.xavier_uniform_(p)
+
+    def forward(self, src, mask, query_embed, pos_embed):
+        # flatten NxCxHxW to HWxNxC
+        bs, c, h, w = src.shape
+        src = src.flatten(2).permute(2, 0, 1)
+        pos_embed = pos_embed.flatten(2).permute(2, 0, 1)
+        query_embed = query_embed.unsqueeze(1).repeat(1, bs, 1)
+        if mask is not None:
+            mask = mask.flatten(1)
+
+        tgt = torch.zeros_like(query_embed)
+        memory = self.encoder(src, src_key_padding_mask=mask, pos=pos_embed)
+        hs = self.decoder(
+            tgt, memory, memory_key_padding_mask=mask, pos=pos_embed, query_pos=query_embed
+        )
+        return hs.transpose(1, 2), memory.permute(1, 2, 0).view(bs, c, h, w)
+
+
+class TransformerEncoder(nn.Module):
+    def __init__(self, encoder_layer, num_layers, norm=None):
+        super().__init__()
+        self.layers = _get_clones(encoder_layer, num_layers)
+        self.num_layers = num_layers
+        self.norm = norm
+
+    def forward(
+        self,
+        src,
+        mask: Optional[Tensor] = None,
+        src_key_padding_mask: Optional[Tensor] = None,
+        pos: Optional[Tensor] = None,
+    ):
+        output = src
+
+        for layer in self.layers:
+            output = layer(
+                output, src_mask=mask, src_key_padding_mask=src_key_padding_mask, pos=pos
+            )
+
+        if self.norm is not None:
+            output = self.norm(output)
+
+        return output
+
+
+class TransformerDecoder(nn.Module):
+    def __init__(self, decoder_layer, num_layers, norm=None, return_intermediate=False):
+        super().__init__()
+        self.layers = _get_clones(decoder_layer, num_layers)
+        self.num_layers = num_layers
+        self.norm = norm
+        self.return_intermediate = return_intermediate
+
+    def forward(
+        self,
+        tgt,
+        memory,
+        tgt_mask: Optional[Tensor] = None,
+        memory_mask: Optional[Tensor] = None,
+        tgt_key_padding_mask: Optional[Tensor] = None,
+        memory_key_padding_mask: Optional[Tensor] = None,
+        pos: Optional[Tensor] = None,
+        query_pos: Optional[Tensor] = None,
+    ):
+        output = tgt
+
+        intermediate = []
+
+        for layer in self.layers:
+            output = layer(
+                output,
+                memory,
+                tgt_mask=tgt_mask,
+                memory_mask=memory_mask,
+                tgt_key_padding_mask=tgt_key_padding_mask,
+                memory_key_padding_mask=memory_key_padding_mask,
+                pos=pos,
+                query_pos=query_pos,
+            )
+            if self.return_intermediate:
+                intermediate.append(self.norm(output))
+
+        if self.norm is not None:
+            output = self.norm(output)
+            if self.return_intermediate:
+                intermediate.pop()
+                intermediate.append(output)
+
+        if self.return_intermediate:
+            return torch.stack(intermediate)
+
+        return output.unsqueeze(0)
+
+
+class TransformerEncoderLayer(nn.Module):
+    def __init__(
+        self,
+        d_model,
+        nhead,
+        dim_feedforward=2048,
+        dropout=0.1,
+        activation="relu",
+        normalize_before=False,
+    ):
+        super().__init__()
+        self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
+        # Implementation of Feedforward model
+        self.linear1 = nn.Linear(d_model, dim_feedforward)
+        self.dropout = nn.Dropout(dropout)
+        self.linear2 = nn.Linear(dim_feedforward, d_model)
+
+        self.norm1 = nn.LayerNorm(d_model)
+        self.norm2 = nn.LayerNorm(d_model)
+        self.dropout1 = nn.Dropout(dropout)
+        self.dropout2 = nn.Dropout(dropout)
+
+        self.activation = _get_activation_fn(activation)
+        self.normalize_before = normalize_before
+
+    def with_pos_embed(self, tensor, pos: Optional[Tensor]):
+        return tensor if pos is None else tensor + pos
+
+    def forward_post(
+        self,
+        src,
+        src_mask: Optional[Tensor] = None,
+        src_key_padding_mask: Optional[Tensor] = None,
+        pos: Optional[Tensor] = None,
+    ):
+        q = k = self.with_pos_embed(src, pos)
+        src2 = self.self_attn(
+            q, k, value=src, attn_mask=src_mask, key_padding_mask=src_key_padding_mask
+        )[0]
+        src = src + self.dropout1(src2)
+        src = self.norm1(src)
+        src2 = self.linear2(self.dropout(self.activation(self.linear1(src))))
+        src = src + self.dropout2(src2)
+        src = self.norm2(src)
+        return src
+
+    def forward_pre(
+        self,
+        src,
+        src_mask: Optional[Tensor] = None,
+        src_key_padding_mask: Optional[Tensor] = None,
+        pos: Optional[Tensor] = None,
+    ):
+        src2 = self.norm1(src)
+        q = k = self.with_pos_embed(src2, pos)
+        src2 = self.self_attn(
+            q, k, value=src2, attn_mask=src_mask, key_padding_mask=src_key_padding_mask
+        )[0]
+        src = src + self.dropout1(src2)
+        src2 = self.norm2(src)
+        src2 = self.linear2(self.dropout(self.activation(self.linear1(src2))))
+        src = src + self.dropout2(src2)
+        return src
+
+    def forward(
+        self,
+        src,
+        src_mask: Optional[Tensor] = None,
+        src_key_padding_mask: Optional[Tensor] = None,
+        pos: Optional[Tensor] = None,
+    ):
+        if self.normalize_before:
+            return self.forward_pre(src, src_mask, src_key_padding_mask, pos)
+        return self.forward_post(src, src_mask, src_key_padding_mask, pos)
+
+
+class TransformerDecoderLayer(nn.Module):
+    def __init__(
+        self,
+        d_model,
+        nhead,
+        dim_feedforward=2048,
+        dropout=0.1,
+        activation="relu",
+        normalize_before=False,
+    ):
+        super().__init__()
+        self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
+        self.multihead_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
+        # Implementation of Feedforward model
+        self.linear1 = nn.Linear(d_model, dim_feedforward)
+        self.dropout = nn.Dropout(dropout)
+        self.linear2 = nn.Linear(dim_feedforward, d_model)
+
+        self.norm1 = nn.LayerNorm(d_model)
+        self.norm2 = nn.LayerNorm(d_model)
+        self.norm3 = nn.LayerNorm(d_model)
+        self.dropout1 = nn.Dropout(dropout)
+        self.dropout2 = nn.Dropout(dropout)
+        self.dropout3 = nn.Dropout(dropout)
+
+        self.activation = _get_activation_fn(activation)
+        self.normalize_before = normalize_before
+
+    def with_pos_embed(self, tensor, pos: Optional[Tensor]):
+        return tensor if pos is None else tensor + pos
+
+    def forward_post(
+        self,
+        tgt,
+        memory,
+        tgt_mask: Optional[Tensor] = None,
+        memory_mask: Optional[Tensor] = None,
+        tgt_key_padding_mask: Optional[Tensor] = None,
+        memory_key_padding_mask: Optional[Tensor] = None,
+        pos: Optional[Tensor] = None,
+        query_pos: Optional[Tensor] = None,
+    ):
+        q = k = self.with_pos_embed(tgt, query_pos)
+        tgt2 = self.self_attn(
+            q, k, value=tgt, attn_mask=tgt_mask, key_padding_mask=tgt_key_padding_mask
+        )[0]
+        tgt = tgt + self.dropout1(tgt2)
+        tgt = self.norm1(tgt)
+        tgt2 = self.multihead_attn(
+            query=self.with_pos_embed(tgt, query_pos),
+            key=self.with_pos_embed(memory, pos),
+            value=memory,
+            attn_mask=memory_mask,
+            key_padding_mask=memory_key_padding_mask,
+        )[0]
+        tgt = tgt + self.dropout2(tgt2)
+        tgt = self.norm2(tgt)
+        tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt))))
+        tgt = tgt + self.dropout3(tgt2)
+        tgt = self.norm3(tgt)
+        return tgt
+
+    def forward_pre(
+        self,
+        tgt,
+        memory,
+        tgt_mask: Optional[Tensor] = None,
+        memory_mask: Optional[Tensor] = None,
+        tgt_key_padding_mask: Optional[Tensor] = None,
+        memory_key_padding_mask: Optional[Tensor] = None,
+        pos: Optional[Tensor] = None,
+        query_pos: Optional[Tensor] = None,
+    ):
+        tgt2 = self.norm1(tgt)
+        q = k = self.with_pos_embed(tgt2, query_pos)
+        tgt2 = self.self_attn(
+            q, k, value=tgt2, attn_mask=tgt_mask, key_padding_mask=tgt_key_padding_mask
+        )[0]
+        tgt = tgt + self.dropout1(tgt2)
+        tgt2 = self.norm2(tgt)
+        tgt2 = self.multihead_attn(
+            query=self.with_pos_embed(tgt2, query_pos),
+            key=self.with_pos_embed(memory, pos),
+            value=memory,
+            attn_mask=memory_mask,
+            key_padding_mask=memory_key_padding_mask,
+        )[0]
+        tgt = tgt + self.dropout2(tgt2)
+        tgt2 = self.norm3(tgt)
+        tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt2))))
+        tgt = tgt + self.dropout3(tgt2)
+        return tgt
+
+    def forward(
+        self,
+        tgt,
+        memory,
+        tgt_mask: Optional[Tensor] = None,
+        memory_mask: Optional[Tensor] = None,
+        tgt_key_padding_mask: Optional[Tensor] = None,
+        memory_key_padding_mask: Optional[Tensor] = None,
+        pos: Optional[Tensor] = None,
+        query_pos: Optional[Tensor] = None,
+    ):
+        if self.normalize_before:
+            return self.forward_pre(
+                tgt,
+                memory,
+                tgt_mask,
+                memory_mask,
+                tgt_key_padding_mask,
+                memory_key_padding_mask,
+                pos,
+                query_pos,
+            )
+        return self.forward_post(
+            tgt,
+            memory,
+            tgt_mask,
+            memory_mask,
+            tgt_key_padding_mask,
+            memory_key_padding_mask,
+            pos,
+            query_pos,
+        )
+
+
+def _get_clones(module, N):
+    return nn.ModuleList([copy.deepcopy(module) for i in range(N)])
+
+
+def _get_activation_fn(activation):
+    """Return an activation function given a string"""
+    if activation == "relu":
+        return F.relu
+    if activation == "gelu":
+        return F.gelu
+    if activation == "glu":
+        return F.glu
+    raise RuntimeError(f"activation should be relu/gelu, not {activation}.")

experiments/round5-20260927/source/vendor_ddcolor/basicsr/archs/ddcolor_arch_utils/transformer_utils.py

@@ -0,0 +1,192 @@
+from typing import Optional
+from torch import nn, Tensor
+from torch.nn import functional as F
+
+class SelfAttentionLayer(nn.Module):
+
+    def __init__(self, d_model, nhead, dropout=0.0,
+                 activation="relu", normalize_before=False):
+        super().__init__()
+        self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
+
+        self.norm = nn.LayerNorm(d_model)
+        self.dropout = nn.Dropout(dropout)
+
+        self.activation = _get_activation_fn(activation)
+        self.normalize_before = normalize_before
+
+        self._reset_parameters()
+    
+    def _reset_parameters(self):
+        for p in self.parameters():
+            if p.dim() > 1:
+                nn.init.xavier_uniform_(p)
+
+    def with_pos_embed(self, tensor, pos: Optional[Tensor]):
+        return tensor if pos is None else tensor + pos
+
+    def forward_post(self, tgt,
+                     tgt_mask: Optional[Tensor] = None,
+                     tgt_key_padding_mask: Optional[Tensor] = None,
+                     query_pos: Optional[Tensor] = None):
+        q = k = self.with_pos_embed(tgt, query_pos)
+        tgt2 = self.self_attn(q, k, value=tgt, attn_mask=tgt_mask,
+                              key_padding_mask=tgt_key_padding_mask)[0]
+        tgt = tgt + self.dropout(tgt2)
+        tgt = self.norm(tgt)
+
+        return tgt
+
+    def forward_pre(self, tgt,
+                    tgt_mask: Optional[Tensor] = None,
+                    tgt_key_padding_mask: Optional[Tensor] = None,
+                    query_pos: Optional[Tensor] = None):
+        tgt2 = self.norm(tgt)
+        q = k = self.with_pos_embed(tgt2, query_pos)
+        tgt2 = self.self_attn(q, k, value=tgt2, attn_mask=tgt_mask,
+                              key_padding_mask=tgt_key_padding_mask)[0]
+        tgt = tgt + self.dropout(tgt2)
+        
+        return tgt
+
+    def forward(self, tgt,
+                tgt_mask: Optional[Tensor] = None,
+                tgt_key_padding_mask: Optional[Tensor] = None,
+                query_pos: Optional[Tensor] = None):
+        if self.normalize_before:
+            return self.forward_pre(tgt, tgt_mask,
+                                    tgt_key_padding_mask, query_pos)
+        return self.forward_post(tgt, tgt_mask,
+                                 tgt_key_padding_mask, query_pos)
+
+
+class CrossAttentionLayer(nn.Module):
+
+    def __init__(self, d_model, nhead, dropout=0.0,
+                 activation="relu", normalize_before=False):
+        super().__init__()
+        self.multihead_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
+
+        self.norm = nn.LayerNorm(d_model)
+        self.dropout = nn.Dropout(dropout)
+
+        self.activation = _get_activation_fn(activation)
+        self.normalize_before = normalize_before
+
+        self._reset_parameters()
+    
+    def _reset_parameters(self):
+        for p in self.parameters():
+            if p.dim() > 1:
+                nn.init.xavier_uniform_(p)
+
+    def with_pos_embed(self, tensor, pos: Optional[Tensor]):
+        return tensor if pos is None else tensor + pos
+
+    def forward_post(self, tgt, memory,
+                     memory_mask: Optional[Tensor] = None,
+                     memory_key_padding_mask: Optional[Tensor] = None,
+                     pos: Optional[Tensor] = None,
+                     query_pos: Optional[Tensor] = None):
+        tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt, query_pos),
+                                   key=self.with_pos_embed(memory, pos),
+                                   value=memory, attn_mask=memory_mask,
+                                   key_padding_mask=memory_key_padding_mask)[0]
+        tgt = tgt + self.dropout(tgt2)
+        tgt = self.norm(tgt)
+        
+        return tgt
+
+    def forward_pre(self, tgt, memory,
+                    memory_mask: Optional[Tensor] = None,
+                    memory_key_padding_mask: Optional[Tensor] = None,
+                    pos: Optional[Tensor] = None,
+                    query_pos: Optional[Tensor] = None):
+        tgt2 = self.norm(tgt)
+        tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt2, query_pos),
+                                   key=self.with_pos_embed(memory, pos),
+                                   value=memory, attn_mask=memory_mask,
+                                   key_padding_mask=memory_key_padding_mask)[0]
+        tgt = tgt + self.dropout(tgt2)
+
+        return tgt
+
+    def forward(self, tgt, memory,
+                memory_mask: Optional[Tensor] = None,
+                memory_key_padding_mask: Optional[Tensor] = None,
+                pos: Optional[Tensor] = None,
+                query_pos: Optional[Tensor] = None):
+        if self.normalize_before:
+            return self.forward_pre(tgt, memory, memory_mask,
+                                    memory_key_padding_mask, pos, query_pos)
+        return self.forward_post(tgt, memory, memory_mask,
+                                 memory_key_padding_mask, pos, query_pos)
+
+
+class FFNLayer(nn.Module):
+
+    def __init__(self, d_model, dim_feedforward=2048, dropout=0.0,
+                 activation="relu", normalize_before=False):
+        super().__init__()
+        # Implementation of Feedforward model
+        self.linear1 = nn.Linear(d_model, dim_feedforward)
+        self.dropout = nn.Dropout(dropout)
+        self.linear2 = nn.Linear(dim_feedforward, d_model)
+
+        self.norm = nn.LayerNorm(d_model)
+
+        self.activation = _get_activation_fn(activation)
+        self.normalize_before = normalize_before
+
+        self._reset_parameters()
+    
+    def _reset_parameters(self):
+        for p in self.parameters():
+            if p.dim() > 1:
+                nn.init.xavier_uniform_(p)
+
+    def with_pos_embed(self, tensor, pos: Optional[Tensor]):
+        return tensor if pos is None else tensor + pos
+
+    def forward_post(self, tgt):
+        tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt))))
+        tgt = tgt + self.dropout(tgt2)
+        tgt = self.norm(tgt)
+        return tgt
+
+    def forward_pre(self, tgt):
+        tgt2 = self.norm(tgt)
+        tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt2))))
+        tgt = tgt + self.dropout(tgt2)
+        return tgt
+
+    def forward(self, tgt):
+        if self.normalize_before:
+            return self.forward_pre(tgt)
+        return self.forward_post(tgt)
+
+
+def _get_activation_fn(activation):
+    """Return an activation function given a string"""
+    if activation == "relu":
+        return F.relu
+    if activation == "gelu":
+        return F.gelu
+    if activation == "glu":
+        return F.glu
+    raise RuntimeError(F"activation should be relu/gelu, not {activation}.")
+
+
+class MLP(nn.Module):
+    """ Very simple multi-layer perceptron (also called FFN)"""
+
+    def __init__(self, input_dim, hidden_dim, output_dim, num_layers):
+        super().__init__()
+        self.num_layers = num_layers
+        h = [hidden_dim] * (num_layers - 1)
+        self.layers = nn.ModuleList(nn.Linear(n, k) for n, k in zip([input_dim] + h, h + [output_dim]))
+
+    def forward(self, x):
+        for i, layer in enumerate(self.layers):
+            x = F.relu(layer(x)) if i < self.num_layers - 1 else layer(x)
+        return x

experiments/round5-20260927/source/vendor_ddcolor/basicsr/archs/ddcolor_arch_utils/unet.py

@@ -0,0 +1,208 @@
+from enum import Enum
+import torch
+import torch.nn as nn
+from torch.nn import functional as F
+import collections
+
+
+NormType = Enum('NormType', 'Batch BatchZero Weight Spectral')
+
+
+class Hook:
+    feature = None
+
+    def __init__(self, module):
+        self.hook = module.register_forward_hook(self.hook_fn)
+
+    def hook_fn(self, module, input, output):
+        if isinstance(output, torch.Tensor):
+            self.feature = output
+        elif isinstance(output, collections.OrderedDict):
+            self.feature = output['out']
+
+    def remove(self):
+        self.hook.remove()
+
+
+class SelfAttention(nn.Module):
+    "Self attention layer for nd."
+
+    def __init__(self, n_channels: int):
+        super().__init__()
+        self.query = conv1d(n_channels, n_channels // 8)
+        self.key = conv1d(n_channels, n_channels // 8)
+        self.value = conv1d(n_channels, n_channels)
+        self.gamma = nn.Parameter(torch.tensor([0.]))
+
+    def forward(self, x):
+        #Notation from https://arxiv.org/pdf/1805.08318.pdf
+        size = x.size()
+        x = x.view(*size[:2], -1)
+        f, g, h = self.query(x), self.key(x), self.value(x)
+        beta = F.softmax(torch.bmm(f.permute(0, 2, 1).contiguous(), g), dim=1)
+        o = self.gamma * torch.bmm(h, beta) + x
+        return o.view(*size).contiguous()
+
+
+def batchnorm_2d(nf: int, norm_type: NormType = NormType.Batch):
+    "A batchnorm2d layer with `nf` features initialized depending on `norm_type`."
+    bn = nn.BatchNorm2d(nf)
+    with torch.no_grad():
+        bn.bias.fill_(1e-3)
+        bn.weight.fill_(0. if norm_type == NormType.BatchZero else 1.)
+    return bn
+
+
+def init_default(m: nn.Module, func=nn.init.kaiming_normal_) -> None:
+    "Initialize `m` weights with `func` and set `bias` to 0."
+    if func:
+        if hasattr(m, 'weight'): func(m.weight)
+        if hasattr(m, 'bias') and hasattr(m.bias, 'data'): m.bias.data.fill_(0.)
+    return m
+
+
+def icnr(x, scale=2, init=nn.init.kaiming_normal_):
+    "ICNR init of `x`, with `scale` and `init` function."
+    ni, nf, h, w = x.shape
+    ni2 = int(ni / (scale**2))
+    k = init(torch.zeros([ni2, nf, h, w])).transpose(0, 1)
+    k = k.contiguous().view(ni2, nf, -1)
+    k = k.repeat(1, 1, scale**2)
+    k = k.contiguous().view([nf, ni, h, w]).transpose(0, 1)
+    x.data.copy_(k)
+
+
+def conv1d(ni: int, no: int, ks: int = 1, stride: int = 1, padding: int = 0, bias: bool = False):
+    "Create and initialize a `nn.Conv1d` layer with spectral normalization."
+    conv = nn.Conv1d(ni, no, ks, stride=stride, padding=padding, bias=bias)
+    nn.init.kaiming_normal_(conv.weight)
+    if bias: conv.bias.data.zero_()
+    return nn.utils.spectral_norm(conv)
+
+
+def custom_conv_layer(
+    ni: int,
+    nf: int,
+    ks: int = 3,
+    stride: int = 1,
+    padding: int = None,
+    bias: bool = None,
+    is_1d: bool = False,
+    norm_type=NormType.Batch,
+    use_activ: bool = True,
+    transpose: bool = False,
+    init=nn.init.kaiming_normal_,
+    self_attention: bool = False,
+    extra_bn: bool = False,
+):
+    "Create a sequence of convolutional (`ni` to `nf`), ReLU (if `use_activ`) and batchnorm (if `bn`) layers."
+    if padding is None:
+        padding = (ks - 1) // 2 if not transpose else 0
+    bn = norm_type in (NormType.Batch, NormType.BatchZero) or extra_bn == True
+    if bias is None:
+        bias = not bn
+    conv_func = nn.ConvTranspose2d if transpose else nn.Conv1d if is_1d else nn.Conv2d
+    conv = init_default(
+        conv_func(ni, nf, kernel_size=ks, bias=bias, stride=stride, padding=padding),
+        init,
+    )
+
+    if norm_type == NormType.Weight:
+        conv = nn.utils.weight_norm(conv)
+    elif norm_type == NormType.Spectral:
+        conv = nn.utils.spectral_norm(conv)
+    layers = [conv]
+    if use_activ:
+        layers.append(nn.ReLU(True))
+    if bn:
+        layers.append((nn.BatchNorm1d if is_1d else nn.BatchNorm2d)(nf))
+    if self_attention:
+        layers.append(SelfAttention(nf))
+    return nn.Sequential(*layers)
+
+
+def conv_layer(ni: int,
+               nf: int,
+               ks: int = 3,
+               stride: int = 1,
+               padding: int = None,
+               bias: bool = None,
+               is_1d: bool = False,
+               norm_type=NormType.Batch,
+               use_activ: bool = True,
+               transpose: bool = False,
+               init=nn.init.kaiming_normal_,
+               self_attention: bool = False):
+    "Create a sequence of convolutional (`ni` to `nf`), ReLU (if `use_activ`) and batchnorm (if `bn`) layers."
+    if padding is None: padding = (ks - 1) // 2 if not transpose else 0
+    bn = norm_type in (NormType.Batch, NormType.BatchZero)
+    if bias is None: bias = not bn
+    conv_func = nn.ConvTranspose2d if transpose else nn.Conv1d if is_1d else nn.Conv2d
+    conv = init_default(conv_func(ni, nf, kernel_size=ks, bias=bias, stride=stride, padding=padding), init)
+    if norm_type == NormType.Weight: conv = nn.utils.weight_norm(conv)
+    elif norm_type == NormType.Spectral: conv = nn.utils.spectral_norm(conv)
+    layers = [conv]
+    if use_activ: layers.append(nn.ReLU(True))
+    if bn: layers.append((nn.BatchNorm1d if is_1d else nn.BatchNorm2d)(nf))
+    if self_attention: layers.append(SelfAttention(nf))
+    return nn.Sequential(*layers)
+
+
+def _conv(ni: int, nf: int, ks: int = 3, stride: int = 1, **kwargs):
+    return conv_layer(ni, nf, ks=ks, stride=stride, norm_type=NormType.Spectral, **kwargs)
+
+
+class CustomPixelShuffle_ICNR(nn.Module):
+    "Upsample by `scale` from `ni` filters to `nf` (default `ni`), using `nn.PixelShuffle`, `icnr` init, and `weight_norm`."
+
+    def __init__(self,
+                 ni: int,
+                 nf: int = None,
+                 scale: int = 2,
+                 blur: bool = True,
+                 norm_type=NormType.Spectral,
+                 extra_bn=False):
+        super().__init__()
+        self.conv = custom_conv_layer(
+            ni, nf * (scale**2), ks=1, use_activ=False, norm_type=norm_type, extra_bn=extra_bn)
+        icnr(self.conv[0].weight)
+        self.shuf = nn.PixelShuffle(scale)
+        self.do_blur = blur
+        # Blurring over (h*w) kernel
+        # "Super-Resolution using Convolutional Neural Networks without Any Checkerboard Artifacts"
+        # - https://arxiv.org/abs/1806.02658
+        self.pad = nn.ReplicationPad2d((1, 0, 1, 0))
+        self.blur = nn.AvgPool2d(2, stride=1)
+        self.relu = nn.ReLU(True)
+
+    def forward(self, x):
+        x = self.shuf(self.relu(self.conv(x)))
+        return self.blur(self.pad(x)) if self.do_blur else x
+
+
+class UnetBlockWide(nn.Module):
+    "A quasi-UNet block, using `PixelShuffle_ICNR upsampling`."
+
+    def __init__(self,
+                 up_in_c: int,
+                 x_in_c: int,
+                 n_out: int,
+                 hook,
+                 blur: bool = False,
+                 self_attention: bool = False,
+                 norm_type=NormType.Spectral):
+        super().__init__()
+
+        self.hook = hook
+        up_out = n_out
+        self.shuf = CustomPixelShuffle_ICNR(up_in_c, up_out, blur=blur, norm_type=norm_type, extra_bn=True)
+        self.bn = batchnorm_2d(x_in_c)
+        ni = up_out + x_in_c
+        self.conv = custom_conv_layer(ni, n_out, norm_type=norm_type, self_attention=self_attention, extra_bn=True)
+        self.relu = nn.ReLU()
+
+    def forward(self, up_in):
+        s = self.hook.feature
+        up_out = self.shuf(up_in)
+        cat_x = self.relu(torch.cat([up_out, self.bn(s)], dim=1))
+        return self.conv(cat_x)

experiments/round5-20260927/source/vendor_ddcolor/basicsr/archs/ddcolor_arch_utils/util.py

@@ -0,0 +1,63 @@
+import numpy as np
+import torch
+from skimage import color
+
+
+def rgb2lab(img_rgb):
+    img_lab = color.rgb2lab(img_rgb)
+    return img_lab[:, :, :1], img_lab[:, :, 1:]
+
+
+def tensor_lab2rgb(labs, illuminant="D65", observer="2"):
+    """
+    Args:
+        lab    : (B, C, H, W)
+    Returns:
+        tuple   : (B, C, H, W)
+    """
+    illuminants = \
+        {"A": {'2': (1.098466069456375, 1, 0.3558228003436005),
+            '10': (1.111420406956693, 1, 0.3519978321919493)},
+        "D50": {'2': (0.9642119944211994, 1, 0.8251882845188288),
+                '10': (0.9672062750333777, 1, 0.8142801513128616)},
+        "D55": {'2': (0.956797052643698, 1, 0.9214805860173273),
+                '10': (0.9579665682254781, 1, 0.9092525159847462)},
+        "D65": {'2': (0.95047, 1., 1.08883),  # This was: `lab_ref_white`
+                '10': (0.94809667673716, 1, 1.0730513595166162)},
+        "D75": {'2': (0.9497220898840717, 1, 1.226393520724154),
+                '10': (0.9441713925645873, 1, 1.2064272211720228)},
+        "E": {'2': (1.0, 1.0, 1.0),
+            '10': (1.0, 1.0, 1.0)}}
+    xyz_from_rgb = np.array([[0.412453, 0.357580, 0.180423], [0.212671, 0.715160, 0.072169],
+                            [0.019334, 0.119193, 0.950227]])
+
+    rgb_from_xyz = np.array([[3.240481340, -0.96925495, 0.055646640], [-1.53715152, 1.875990000, -0.20404134],
+                            [-0.49853633, 0.041555930, 1.057311070]])
+    B, C, H, W = labs.shape
+    arrs = labs.permute((0, 2, 3, 1)).contiguous()  # (B, 3, H, W) -> (B, H, W, 3)
+    L, a, b = arrs[:, :, :, 0:1], arrs[:, :, :, 1:2], arrs[:, :, :, 2:]
+    y = (L + 16.) / 116.
+    x = (a / 500.) + y
+    z = y - (b / 200.)
+    invalid = z.data < 0
+    z[invalid] = 0
+    xyz = torch.cat([x, y, z], dim=3)
+    mask = xyz.data > 0.2068966
+    mask_xyz = xyz.clone()
+    mask_xyz[mask] = torch.pow(xyz[mask], 3.0)
+    mask_xyz[~mask] = (xyz[~mask] - 16.0 / 116.) / 7.787
+    xyz_ref_white = illuminants[illuminant][observer]
+    for i in range(C):
+        mask_xyz[:, :, :, i] = mask_xyz[:, :, :, i] * xyz_ref_white[i]
+
+    rgb_trans = torch.mm(mask_xyz.view(-1, 3), torch.from_numpy(rgb_from_xyz).type_as(xyz)).view(B, H, W, C)
+    rgb = rgb_trans.permute((0, 3, 1, 2)).contiguous()
+    mask = rgb.data > 0.0031308
+    mask_rgb = rgb.clone()
+    mask_rgb[mask] = 1.055 * torch.pow(rgb[mask], 1 / 2.4) - 0.055
+    mask_rgb[~mask] = rgb[~mask] * 12.92
+    neg_mask = mask_rgb.data < 0
+    large_mask = mask_rgb.data > 1
+    mask_rgb[neg_mask] = 0
+    mask_rgb[large_mask] = 1
+    return mask_rgb

experiments/round5-20260927/source/vendor_ddcolor/basicsr/utils/__init__.py

@@ -0,0 +1,37 @@
+from .diffjpeg import DiffJPEG
+from .file_client import FileClient
+from .img_process_util import USMSharp, usm_sharp
+from .img_util import crop_border, imfrombytes, img2tensor, imwrite, tensor2img
+from .logger import AvgTimer, MessageLogger, get_env_info, get_root_logger, init_tb_logger, init_wandb_logger
+from .misc import check_resume, get_time_str, make_exp_dirs, mkdir_and_rename, scandir, set_random_seed, sizeof_fmt
+
+__all__ = [
+    # file_client.py
+    'FileClient',
+    # img_util.py
+    'img2tensor',
+    'tensor2img',
+    'imfrombytes',
+    'imwrite',
+    'crop_border',
+    # logger.py
+    'MessageLogger',
+    'AvgTimer',
+    'init_tb_logger',
+    'init_wandb_logger',
+    'get_root_logger',
+    'get_env_info',
+    # misc.py
+    'set_random_seed',
+    'get_time_str',
+    'mkdir_and_rename',
+    'make_exp_dirs',
+    'scandir',
+    'check_resume',
+    'sizeof_fmt',
+    # diffjpeg
+    'DiffJPEG',
+    # img_process_util
+    'USMSharp',
+    'usm_sharp'
+]

experiments/round5-20260927/source/vendor_ddcolor/basicsr/utils/diffjpeg.py

@@ -0,0 +1,515 @@
+"""
+Modified from https://github.com/mlomnitz/DiffJPEG
+
+For images not divisible by 8
+https://dsp.stackexchange.com/questions/35339/jpeg-dct-padding/35343#35343
+"""
+import itertools
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.nn import functional as F
+
+# ------------------------ utils ------------------------#
+y_table = np.array(
+    [[16, 11, 10, 16, 24, 40, 51, 61], [12, 12, 14, 19, 26, 58, 60, 55], [14, 13, 16, 24, 40, 57, 69, 56],
+     [14, 17, 22, 29, 51, 87, 80, 62], [18, 22, 37, 56, 68, 109, 103, 77], [24, 35, 55, 64, 81, 104, 113, 92],
+     [49, 64, 78, 87, 103, 121, 120, 101], [72, 92, 95, 98, 112, 100, 103, 99]],
+    dtype=np.float32).T
+y_table = nn.Parameter(torch.from_numpy(y_table))
+c_table = np.empty((8, 8), dtype=np.float32)
+c_table.fill(99)
+c_table[:4, :4] = np.array([[17, 18, 24, 47], [18, 21, 26, 66], [24, 26, 56, 99], [47, 66, 99, 99]]).T
+c_table = nn.Parameter(torch.from_numpy(c_table))
+
+
+def diff_round(x):
+    """ Differentiable rounding function
+    """
+    return torch.round(x) + (x - torch.round(x))**3
+
+
+def quality_to_factor(quality):
+    """ Calculate factor corresponding to quality
+
+    Args:
+        quality(float): Quality for jpeg compression.
+
+    Returns:
+        float: Compression factor.
+    """
+    if quality < 50:
+        quality = 5000. / quality
+    else:
+        quality = 200. - quality * 2
+    return quality / 100.
+
+
+# ------------------------ compression ------------------------#
+class RGB2YCbCrJpeg(nn.Module):
+    """ Converts RGB image to YCbCr
+    """
+
+    def __init__(self):
+        super(RGB2YCbCrJpeg, self).__init__()
+        matrix = np.array([[0.299, 0.587, 0.114], [-0.168736, -0.331264, 0.5], [0.5, -0.418688, -0.081312]],
+                          dtype=np.float32).T
+        self.shift = nn.Parameter(torch.tensor([0., 128., 128.]))
+        self.matrix = nn.Parameter(torch.from_numpy(matrix))
+
+    def forward(self, image):
+        """
+        Args:
+            image(Tensor): batch x 3 x height x width
+
+        Returns:
+            Tensor: batch x height x width x 3
+        """
+        image = image.permute(0, 2, 3, 1)
+        result = torch.tensordot(image, self.matrix, dims=1) + self.shift
+        return result.view(image.shape)
+
+
+class ChromaSubsampling(nn.Module):
+    """ Chroma subsampling on CbCr channels
+    """
+
+    def __init__(self):
+        super(ChromaSubsampling, self).__init__()
+
+    def forward(self, image):
+        """
+        Args:
+            image(tensor): batch x height x width x 3
+
+        Returns:
+            y(tensor): batch x height x width
+            cb(tensor): batch x height/2 x width/2
+            cr(tensor): batch x height/2 x width/2
+        """
+        image_2 = image.permute(0, 3, 1, 2).clone()
+        cb = F.avg_pool2d(image_2[:, 1, :, :].unsqueeze(1), kernel_size=2, stride=(2, 2), count_include_pad=False)
+        cr = F.avg_pool2d(image_2[:, 2, :, :].unsqueeze(1), kernel_size=2, stride=(2, 2), count_include_pad=False)
+        cb = cb.permute(0, 2, 3, 1)
+        cr = cr.permute(0, 2, 3, 1)
+        return image[:, :, :, 0], cb.squeeze(3), cr.squeeze(3)
+
+
+class BlockSplitting(nn.Module):
+    """ Splitting image into patches
+    """
+
+    def __init__(self):
+        super(BlockSplitting, self).__init__()
+        self.k = 8
+
+    def forward(self, image):
+        """
+        Args:
+            image(tensor): batch x height x width
+
+        Returns:
+            Tensor:  batch x h*w/64 x h x w
+        """
+        height, _ = image.shape[1:3]
+        batch_size = image.shape[0]
+        image_reshaped = image.view(batch_size, height // self.k, self.k, -1, self.k)
+        image_transposed = image_reshaped.permute(0, 1, 3, 2, 4)
+        return image_transposed.contiguous().view(batch_size, -1, self.k, self.k)
+
+
+class DCT8x8(nn.Module):
+    """ Discrete Cosine Transformation
+    """
+
+    def __init__(self):
+        super(DCT8x8, self).__init__()
+        tensor = np.zeros((8, 8, 8, 8), dtype=np.float32)
+        for x, y, u, v in itertools.product(range(8), repeat=4):
+            tensor[x, y, u, v] = np.cos((2 * x + 1) * u * np.pi / 16) * np.cos((2 * y + 1) * v * np.pi / 16)
+        alpha = np.array([1. / np.sqrt(2)] + [1] * 7)
+        self.tensor = nn.Parameter(torch.from_numpy(tensor).float())
+        self.scale = nn.Parameter(torch.from_numpy(np.outer(alpha, alpha) * 0.25).float())
+
+    def forward(self, image):
+        """
+        Args:
+            image(tensor): batch x height x width
+
+        Returns:
+            Tensor: batch x height x width
+        """
+        image = image - 128
+        result = self.scale * torch.tensordot(image, self.tensor, dims=2)
+        result.view(image.shape)
+        return result
+
+
+class YQuantize(nn.Module):
+    """ JPEG Quantization for Y channel
+
+    Args:
+        rounding(function): rounding function to use
+    """
+
+    def __init__(self, rounding):
+        super(YQuantize, self).__init__()
+        self.rounding = rounding
+        self.y_table = y_table
+
+    def forward(self, image, factor=1):
+        """
+        Args:
+            image(tensor): batch x height x width
+
+        Returns:
+            Tensor: batch x height x width
+        """
+        if isinstance(factor, (int, float)):
+            image = image.float() / (self.y_table * factor)
+        else:
+            b = factor.size(0)
+            table = self.y_table.expand(b, 1, 8, 8) * factor.view(b, 1, 1, 1)
+            image = image.float() / table
+        image = self.rounding(image)
+        return image
+
+
+class CQuantize(nn.Module):
+    """ JPEG Quantization for CbCr channels
+
+    Args:
+        rounding(function): rounding function to use
+    """
+
+    def __init__(self, rounding):
+        super(CQuantize, self).__init__()
+        self.rounding = rounding
+        self.c_table = c_table
+
+    def forward(self, image, factor=1):
+        """
+        Args:
+            image(tensor): batch x height x width
+
+        Returns:
+            Tensor: batch x height x width
+        """
+        if isinstance(factor, (int, float)):
+            image = image.float() / (self.c_table * factor)
+        else:
+            b = factor.size(0)
+            table = self.c_table.expand(b, 1, 8, 8) * factor.view(b, 1, 1, 1)
+            image = image.float() / table
+        image = self.rounding(image)
+        return image
+
+
+class CompressJpeg(nn.Module):
+    """Full JPEG compression algorithm
+
+    Args:
+        rounding(function): rounding function to use
+    """
+
+    def __init__(self, rounding=torch.round):
+        super(CompressJpeg, self).__init__()
+        self.l1 = nn.Sequential(RGB2YCbCrJpeg(), ChromaSubsampling())
+        self.l2 = nn.Sequential(BlockSplitting(), DCT8x8())
+        self.c_quantize = CQuantize(rounding=rounding)
+        self.y_quantize = YQuantize(rounding=rounding)
+
+    def forward(self, image, factor=1):
+        """
+        Args:
+            image(tensor): batch x 3 x height x width
+
+        Returns:
+            dict(tensor): Compressed tensor with batch x h*w/64 x 8 x 8.
+        """
+        y, cb, cr = self.l1(image * 255)
+        components = {'y': y, 'cb': cb, 'cr': cr}
+        for k in components.keys():
+            comp = self.l2(components[k])
+            if k in ('cb', 'cr'):
+                comp = self.c_quantize(comp, factor=factor)
+            else:
+                comp = self.y_quantize(comp, factor=factor)
+
+            components[k] = comp
+
+        return components['y'], components['cb'], components['cr']
+
+
+# ------------------------ decompression ------------------------#
+
+
+class YDequantize(nn.Module):
+    """Dequantize Y channel
+    """
+
+    def __init__(self):
+        super(YDequantize, self).__init__()
+        self.y_table = y_table
+
+    def forward(self, image, factor=1):
+        """
+        Args:
+            image(tensor): batch x height x width
+
+        Returns:
+            Tensor: batch x height x width
+        """
+        if isinstance(factor, (int, float)):
+            out = image * (self.y_table * factor)
+        else:
+            b = factor.size(0)
+            table = self.y_table.expand(b, 1, 8, 8) * factor.view(b, 1, 1, 1)
+            out = image * table
+        return out
+
+
+class CDequantize(nn.Module):
+    """Dequantize CbCr channel
+    """
+
+    def __init__(self):
+        super(CDequantize, self).__init__()
+        self.c_table = c_table
+
+    def forward(self, image, factor=1):
+        """
+        Args:
+            image(tensor): batch x height x width
+
+        Returns:
+            Tensor: batch x height x width
+        """
+        if isinstance(factor, (int, float)):
+            out = image * (self.c_table * factor)
+        else:
+            b = factor.size(0)
+            table = self.c_table.expand(b, 1, 8, 8) * factor.view(b, 1, 1, 1)
+            out = image * table
+        return out
+
+
+class iDCT8x8(nn.Module):
+    """Inverse discrete Cosine Transformation
+    """
+
+    def __init__(self):
+        super(iDCT8x8, self).__init__()
+        alpha = np.array([1. / np.sqrt(2)] + [1] * 7)
+        self.alpha = nn.Parameter(torch.from_numpy(np.outer(alpha, alpha)).float())
+        tensor = np.zeros((8, 8, 8, 8), dtype=np.float32)
+        for x, y, u, v in itertools.product(range(8), repeat=4):
+            tensor[x, y, u, v] = np.cos((2 * u + 1) * x * np.pi / 16) * np.cos((2 * v + 1) * y * np.pi / 16)
+        self.tensor = nn.Parameter(torch.from_numpy(tensor).float())
+
+    def forward(self, image):
+        """
+        Args:
+            image(tensor): batch x height x width
+
+        Returns:
+            Tensor: batch x height x width
+        """
+        image = image * self.alpha
+        result = 0.25 * torch.tensordot(image, self.tensor, dims=2) + 128
+        result.view(image.shape)
+        return result
+
+
+class BlockMerging(nn.Module):
+    """Merge patches into image
+    """
+
+    def __init__(self):
+        super(BlockMerging, self).__init__()
+
+    def forward(self, patches, height, width):
+        """
+        Args:
+            patches(tensor) batch x height*width/64, height x width
+            height(int)
+            width(int)
+
+        Returns:
+            Tensor: batch x height x width
+        """
+        k = 8
+        batch_size = patches.shape[0]
+        image_reshaped = patches.view(batch_size, height // k, width // k, k, k)
+        image_transposed = image_reshaped.permute(0, 1, 3, 2, 4)
+        return image_transposed.contiguous().view(batch_size, height, width)
+
+
+class ChromaUpsampling(nn.Module):
+    """Upsample chroma layers
+    """
+
+    def __init__(self):
+        super(ChromaUpsampling, self).__init__()
+
+    def forward(self, y, cb, cr):
+        """
+        Args:
+            y(tensor): y channel image
+            cb(tensor): cb channel
+            cr(tensor): cr channel
+
+        Returns:
+            Tensor: batch x height x width x 3
+        """
+
+        def repeat(x, k=2):
+            height, width = x.shape[1:3]
+            x = x.unsqueeze(-1)
+            x = x.repeat(1, 1, k, k)
+            x = x.view(-1, height * k, width * k)
+            return x
+
+        cb = repeat(cb)
+        cr = repeat(cr)
+        return torch.cat([y.unsqueeze(3), cb.unsqueeze(3), cr.unsqueeze(3)], dim=3)
+
+
+class YCbCr2RGBJpeg(nn.Module):
+    """Converts YCbCr image to RGB JPEG
+    """
+
+    def __init__(self):
+        super(YCbCr2RGBJpeg, self).__init__()
+
+        matrix = np.array([[1., 0., 1.402], [1, -0.344136, -0.714136], [1, 1.772, 0]], dtype=np.float32).T
+        self.shift = nn.Parameter(torch.tensor([0, -128., -128.]))
+        self.matrix = nn.Parameter(torch.from_numpy(matrix))
+
+    def forward(self, image):
+        """
+        Args:
+            image(tensor): batch x height x width x 3
+
+        Returns:
+            Tensor: batch x 3 x height x width
+        """
+        result = torch.tensordot(image + self.shift, self.matrix, dims=1)
+        return result.view(image.shape).permute(0, 3, 1, 2)
+
+
+class DeCompressJpeg(nn.Module):
+    """Full JPEG decompression algorithm
+
+    Args:
+        rounding(function): rounding function to use
+    """
+
+    def __init__(self, rounding=torch.round):
+        super(DeCompressJpeg, self).__init__()
+        self.c_dequantize = CDequantize()
+        self.y_dequantize = YDequantize()
+        self.idct = iDCT8x8()
+        self.merging = BlockMerging()
+        self.chroma = ChromaUpsampling()
+        self.colors = YCbCr2RGBJpeg()
+
+    def forward(self, y, cb, cr, imgh, imgw, factor=1):
+        """
+        Args:
+            compressed(dict(tensor)): batch x h*w/64 x 8 x 8
+            imgh(int)
+            imgw(int)
+            factor(float)
+
+        Returns:
+            Tensor: batch x 3 x height x width
+        """
+        components = {'y': y, 'cb': cb, 'cr': cr}
+        for k in components.keys():
+            if k in ('cb', 'cr'):
+                comp = self.c_dequantize(components[k], factor=factor)
+                height, width = int(imgh / 2), int(imgw / 2)
+            else:
+                comp = self.y_dequantize(components[k], factor=factor)
+                height, width = imgh, imgw
+            comp = self.idct(comp)
+            components[k] = self.merging(comp, height, width)
+            #
+        image = self.chroma(components['y'], components['cb'], components['cr'])
+        image = self.colors(image)
+
+        image = torch.min(255 * torch.ones_like(image), torch.max(torch.zeros_like(image), image))
+        return image / 255
+
+
+# ------------------------ main DiffJPEG ------------------------ #
+
+
+class DiffJPEG(nn.Module):
+    """This JPEG algorithm result is slightly different from cv2.
+    DiffJPEG supports batch processing.
+
+    Args:
+        differentiable(bool): If True, uses custom differentiable rounding function, if False, uses standard torch.round
+    """
+
+    def __init__(self, differentiable=True):
+        super(DiffJPEG, self).__init__()
+        if differentiable:
+            rounding = diff_round
+        else:
+            rounding = torch.round
+
+        self.compress = CompressJpeg(rounding=rounding)
+        self.decompress = DeCompressJpeg(rounding=rounding)
+
+    def forward(self, x, quality):
+        """
+        Args:
+            x (Tensor): Input image, bchw, rgb, [0, 1]
+            quality(float): Quality factor for jpeg compression scheme.
+        """
+        factor = quality
+        if isinstance(factor, (int, float)):
+            factor = quality_to_factor(factor)
+        else:
+            for i in range(factor.size(0)):
+                factor[i] = quality_to_factor(factor[i])
+        h, w = x.size()[-2:]
+        h_pad, w_pad = 0, 0
+        # why should use 16
+        if h % 16 != 0:
+            h_pad = 16 - h % 16
+        if w % 16 != 0:
+            w_pad = 16 - w % 16
+        x = F.pad(x, (0, w_pad, 0, h_pad), mode='constant', value=0)
+
+        y, cb, cr = self.compress(x, factor=factor)
+        recovered = self.decompress(y, cb, cr, (h + h_pad), (w + w_pad), factor=factor)
+        recovered = recovered[:, :, 0:h, 0:w]
+        return recovered
+
+
+if __name__ == '__main__':
+    import cv2
+
+    from basicsr.utils import img2tensor, tensor2img
+
+    img_gt = cv2.imread('test.png') / 255.
+
+    # -------------- cv2 -------------- #
+    encode_param = [int(cv2.IMWRITE_JPEG_QUALITY), 20]
+    _, encimg = cv2.imencode('.jpg', img_gt * 255., encode_param)
+    img_lq = np.float32(cv2.imdecode(encimg, 1))
+    cv2.imwrite('cv2_JPEG_20.png', img_lq)
+
+    # -------------- DiffJPEG -------------- #
+    jpeger = DiffJPEG(differentiable=False).cuda()
+    img_gt = img2tensor(img_gt)
+    img_gt = torch.stack([img_gt, img_gt]).cuda()
+    quality = img_gt.new_tensor([20, 40])
+    out = jpeger(img_gt, quality=quality)
+
+    cv2.imwrite('pt_JPEG_20.png', tensor2img(out[0]))
+    cv2.imwrite('pt_JPEG_40.png', tensor2img(out[1]))

experiments/round5-20260927/source/vendor_ddcolor/basicsr/utils/dist_util.py

@@ -0,0 +1,82 @@
+# Modified from https://github.com/open-mmlab/mmcv/blob/master/mmcv/runner/dist_utils.py  # noqa: E501
+import functools
+import os
+import subprocess
+import torch
+import torch.distributed as dist
+import torch.multiprocessing as mp
+
+
+def init_dist(launcher, backend='nccl', **kwargs):
+    if mp.get_start_method(allow_none=True) is None:
+        mp.set_start_method('spawn')
+    if launcher == 'pytorch':
+        _init_dist_pytorch(backend, **kwargs)
+    elif launcher == 'slurm':
+        _init_dist_slurm(backend, **kwargs)
+    else:
+        raise ValueError(f'Invalid launcher type: {launcher}')
+
+
+def _init_dist_pytorch(backend, **kwargs):
+    rank = int(os.environ['RANK'])
+    num_gpus = torch.cuda.device_count()
+    torch.cuda.set_device(rank % num_gpus)
+    dist.init_process_group(backend=backend, **kwargs)
+
+
+def _init_dist_slurm(backend, port=None):
+    """Initialize slurm distributed training environment.
+
+    If argument ``port`` is not specified, then the master port will be system
+    environment variable ``MASTER_PORT``. If ``MASTER_PORT`` is not in system
+    environment variable, then a default port ``29500`` will be used.
+
+    Args:
+        backend (str): Backend of torch.distributed.
+        port (int, optional): Master port. Defaults to None.
+    """
+    proc_id = int(os.environ['SLURM_PROCID'])
+    ntasks = int(os.environ['SLURM_NTASKS'])
+    node_list = os.environ['SLURM_NODELIST']
+    num_gpus = torch.cuda.device_count()
+    torch.cuda.set_device(proc_id % num_gpus)
+    addr = subprocess.getoutput(f'scontrol show hostname {node_list} | head -n1')
+    # specify master port
+    if port is not None:
+        os.environ['MASTER_PORT'] = str(port)
+    elif 'MASTER_PORT' in os.environ:
+        pass  # use MASTER_PORT in the environment variable
+    else:
+        # 29500 is torch.distributed default port
+        os.environ['MASTER_PORT'] = '29500'
+    os.environ['MASTER_ADDR'] = addr
+    os.environ['WORLD_SIZE'] = str(ntasks)
+    os.environ['LOCAL_RANK'] = str(proc_id % num_gpus)
+    os.environ['RANK'] = str(proc_id)
+    dist.init_process_group(backend=backend)
+
+
+def get_dist_info():
+    if dist.is_available():
+        initialized = dist.is_initialized()
+    else:
+        initialized = False
+    if initialized:
+        rank = dist.get_rank()
+        world_size = dist.get_world_size()
+    else:
+        rank = 0
+        world_size = 1
+    return rank, world_size
+
+
+def master_only(func):
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        rank, _ = get_dist_info()
+        if rank == 0:
+            return func(*args, **kwargs)
+
+    return wrapper

experiments/round5-20260927/source/vendor_ddcolor/basicsr/utils/file_client.py

@@ -0,0 +1,167 @@
+# Modified from https://github.com/open-mmlab/mmcv/blob/master/mmcv/fileio/file_client.py  # noqa: E501
+from abc import ABCMeta, abstractmethod
+
+
+class BaseStorageBackend(metaclass=ABCMeta):
+    """Abstract class of storage backends.
+
+    All backends need to implement two apis: ``get()`` and ``get_text()``.
+    ``get()`` reads the file as a byte stream and ``get_text()`` reads the file
+    as texts.
+    """
+
+    @abstractmethod
+    def get(self, filepath):
+        pass
+
+    @abstractmethod
+    def get_text(self, filepath):
+        pass
+
+
+class MemcachedBackend(BaseStorageBackend):
+    """Memcached storage backend.
+
+    Attributes:
+        server_list_cfg (str): Config file for memcached server list.
+        client_cfg (str): Config file for memcached client.
+        sys_path (str | None): Additional path to be appended to `sys.path`.
+            Default: None.
+    """
+
+    def __init__(self, server_list_cfg, client_cfg, sys_path=None):
+        if sys_path is not None:
+            import sys
+            sys.path.append(sys_path)
+        try:
+            import mc
+        except ImportError:
+            raise ImportError('Please install memcached to enable MemcachedBackend.')
+
+        self.server_list_cfg = server_list_cfg
+        self.client_cfg = client_cfg
+        self._client = mc.MemcachedClient.GetInstance(self.server_list_cfg, self.client_cfg)
+        # mc.pyvector servers as a point which points to a memory cache
+        self._mc_buffer = mc.pyvector()
+
+    def get(self, filepath):
+        filepath = str(filepath)
+        import mc
+        self._client.Get(filepath, self._mc_buffer)
+        value_buf = mc.ConvertBuffer(self._mc_buffer)
+        return value_buf
+
+    def get_text(self, filepath):
+        raise NotImplementedError
+
+
+class HardDiskBackend(BaseStorageBackend):
+    """Raw hard disks storage backend."""
+
+    def get(self, filepath):
+        filepath = str(filepath)
+        with open(filepath, 'rb') as f:
+            value_buf = f.read()
+        return value_buf
+
+    def get_text(self, filepath):
+        filepath = str(filepath)
+        with open(filepath, 'r') as f:
+            value_buf = f.read()
+        return value_buf
+
+
+class LmdbBackend(BaseStorageBackend):
+    """Lmdb storage backend.
+
+    Args:
+        db_paths (str | list[str]): Lmdb database paths.
+        client_keys (str | list[str]): Lmdb client keys. Default: 'default'.
+        readonly (bool, optional): Lmdb environment parameter. If True,
+            disallow any write operations. Default: True.
+        lock (bool, optional): Lmdb environment parameter. If False, when
+            concurrent access occurs, do not lock the database. Default: False.
+        readahead (bool, optional): Lmdb environment parameter. If False,
+            disable the OS filesystem readahead mechanism, which may improve
+            random read performance when a database is larger than RAM.
+            Default: False.
+
+    Attributes:
+        db_paths (list): Lmdb database path.
+        _client (list): A list of several lmdb envs.
+    """
+
+    def __init__(self, db_paths, client_keys='default', readonly=True, lock=False, readahead=False, **kwargs):
+        try:
+            import lmdb
+        except ImportError:
+            raise ImportError('Please install lmdb to enable LmdbBackend.')
+
+        if isinstance(client_keys, str):
+            client_keys = [client_keys]
+
+        if isinstance(db_paths, list):
+            self.db_paths = [str(v) for v in db_paths]
+        elif isinstance(db_paths, str):
+            self.db_paths = [str(db_paths)]
+        assert len(client_keys) == len(self.db_paths), ('client_keys and db_paths should have the same length, '
+                                                        f'but received {len(client_keys)} and {len(self.db_paths)}.')
+
+        self._client = {}
+        for client, path in zip(client_keys, self.db_paths):
+            self._client[client] = lmdb.open(path, readonly=readonly, lock=lock, readahead=readahead, **kwargs)
+
+    def get(self, filepath, client_key):
+        """Get values according to the filepath from one lmdb named client_key.
+
+        Args:
+            filepath (str | obj:`Path`): Here, filepath is the lmdb key.
+            client_key (str): Used for distinguishing different lmdb envs.
+        """
+        filepath = str(filepath)
+        assert client_key in self._client, (f'client_key {client_key} is not ' 'in lmdb clients.')
+        client = self._client[client_key]
+        with client.begin(write=False) as txn:
+            value_buf = txn.get(filepath.encode('ascii'))
+        return value_buf
+
+    def get_text(self, filepath):
+        raise NotImplementedError
+
+
+class FileClient(object):
+    """A general file client to access files in different backend.
+
+    The client loads a file or text in a specified backend from its path
+    and return it as a binary file. it can also register other backend
+    accessor with a given name and backend class.
+
+    Attributes:
+        backend (str): The storage backend type. Options are "disk",
+            "memcached" and "lmdb".
+        client (:obj:`BaseStorageBackend`): The backend object.
+    """
+
+    _backends = {
+        'disk': HardDiskBackend,
+        'memcached': MemcachedBackend,
+        'lmdb': LmdbBackend,
+    }
+
+    def __init__(self, backend='disk', **kwargs):
+        if backend not in self._backends:
+            raise ValueError(f'Backend {backend} is not supported. Currently supported ones'
+                             f' are {list(self._backends.keys())}')
+        self.backend = backend
+        self.client = self._backends[backend](**kwargs)
+
+    def get(self, filepath, client_key='default'):
+        # client_key is used only for lmdb, where different fileclients have
+        # different lmdb environments.
+        if self.backend == 'lmdb':
+            return self.client.get(filepath, client_key)
+        else:
+            return self.client.get(filepath)
+
+    def get_text(self, filepath):
+        return self.client.get_text(filepath)

experiments/round5-20260927/source/vendor_ddcolor/basicsr/utils/img_process_util.py

@@ -0,0 +1,83 @@
+import cv2
+import numpy as np
+import torch
+from torch.nn import functional as F
+
+
+def filter2D(img, kernel):
+    """PyTorch version of cv2.filter2D
+
+    Args:
+        img (Tensor): (b, c, h, w)
+        kernel (Tensor): (b, k, k)
+    """
+    k = kernel.size(-1)
+    b, c, h, w = img.size()
+    if k % 2 == 1:
+        img = F.pad(img, (k // 2, k // 2, k // 2, k // 2), mode='reflect')
+    else:
+        raise ValueError('Wrong kernel size')
+
+    ph, pw = img.size()[-2:]
+
+    if kernel.size(0) == 1:
+        # apply the same kernel to all batch images
+        img = img.view(b * c, 1, ph, pw)
+        kernel = kernel.view(1, 1, k, k)
+        return F.conv2d(img, kernel, padding=0).view(b, c, h, w)
+    else:
+        img = img.view(1, b * c, ph, pw)
+        kernel = kernel.view(b, 1, k, k).repeat(1, c, 1, 1).view(b * c, 1, k, k)
+        return F.conv2d(img, kernel, groups=b * c).view(b, c, h, w)
+
+
+def usm_sharp(img, weight=0.5, radius=50, threshold=10):
+    """USM sharpening.
+
+    Input image: I; Blurry image: B.
+    1. sharp = I + weight * (I - B)
+    2. Mask = 1 if abs(I - B) > threshold, else: 0
+    3. Blur mask:
+    4. Out = Mask * sharp + (1 - Mask) * I
+
+
+    Args:
+        img (Numpy array): Input image, HWC, BGR; float32, [0, 1].
+        weight (float): Sharp weight. Default: 1.
+        radius (float): Kernel size of Gaussian blur. Default: 50.
+        threshold (int):
+    """
+    if radius % 2 == 0:
+        radius += 1
+    blur = cv2.GaussianBlur(img, (radius, radius), 0)
+    residual = img - blur
+    mask = np.abs(residual) * 255 > threshold
+    mask = mask.astype('float32')
+    soft_mask = cv2.GaussianBlur(mask, (radius, radius), 0)
+
+    sharp = img + weight * residual
+    sharp = np.clip(sharp, 0, 1)
+    return soft_mask * sharp + (1 - soft_mask) * img
+
+
+class USMSharp(torch.nn.Module):
+
+    def __init__(self, radius=50, sigma=0):
+        super(USMSharp, self).__init__()
+        if radius % 2 == 0:
+            radius += 1
+        self.radius = radius
+        kernel = cv2.getGaussianKernel(radius, sigma)
+        kernel = torch.FloatTensor(np.dot(kernel, kernel.transpose())).unsqueeze_(0)
+        self.register_buffer('kernel', kernel)
+
+    def forward(self, img, weight=0.5, threshold=10):
+        blur = filter2D(img, self.kernel)
+        residual = img - blur
+
+        mask = torch.abs(residual) * 255 > threshold
+        mask = mask.float()
+        soft_mask = filter2D(mask, self.kernel)
+        sharp = img + weight * residual
+        sharp = torch.clip(sharp, 0, 1)
+        return soft_mask * sharp + (1 - soft_mask) * img

experiments/round5-20260927/source/vendor_ddcolor/basicsr/utils/img_util.py

@@ -0,0 +1,227 @@
+import cv2
+import math
+import numpy as np
+import os
+import torch
+from torchvision.utils import make_grid
+
+
+def img2tensor(imgs, bgr2rgb=True, float32=True):
+    """Numpy array to tensor.
+
+    Args:
+        imgs (list[ndarray] | ndarray): Input images.
+        bgr2rgb (bool): Whether to change bgr to rgb.
+        float32 (bool): Whether to change to float32.
+
+    Returns:
+        list[tensor] | tensor: Tensor images. If returned results only have
+            one element, just return tensor.
+    """
+
+    def _totensor(img, bgr2rgb, float32):
+        if img.shape[2] == 3 and bgr2rgb:
+            if img.dtype == 'float64':
+                img = img.astype('float32')
+            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        img = torch.from_numpy(img.transpose(2, 0, 1))
+        if float32:
+            img = img.float()
+        return img
+
+    if isinstance(imgs, list):
+        return [_totensor(img, bgr2rgb, float32) for img in imgs]
+    else:
+        return _totensor(imgs, bgr2rgb, float32)
+
+
+def tensor2img(tensor, rgb2bgr=True, out_type=np.uint8, min_max=(0, 1)):
+    """Convert torch Tensors into image numpy arrays.
+
+    After clamping to [min, max], values will be normalized to [0, 1].
+
+    Args:
+        tensor (Tensor or list[Tensor]): Accept shapes:
+            1) 4D mini-batch Tensor of shape (B x 3/1 x H x W);
+            2) 3D Tensor of shape (3/1 x H x W);
+            3) 2D Tensor of shape (H x W).
+            Tensor channel should be in RGB order.
+        rgb2bgr (bool): Whether to change rgb to bgr.
+        out_type (numpy type): output types. If ``np.uint8``, transform outputs
+            to uint8 type with range [0, 255]; otherwise, float type with
+            range [0, 1]. Default: ``np.uint8``.
+        min_max (tuple[int]): min and max values for clamp.
+
+    Returns:
+        (Tensor or list): 3D ndarray of shape (H x W x C) OR 2D ndarray of
+        shape (H x W). The channel order is BGR.
+    """
+    if not (torch.is_tensor(tensor) or (isinstance(tensor, list) and all(torch.is_tensor(t) for t in tensor))):
+        raise TypeError(f'tensor or list of tensors expected, got {type(tensor)}')
+
+    if torch.is_tensor(tensor):
+        tensor = [tensor]
+    result = []
+    for _tensor in tensor:
+        _tensor = _tensor.squeeze(0).float().detach().cpu().clamp_(*min_max)
+        _tensor = (_tensor - min_max[0]) / (min_max[1] - min_max[0])
+
+        n_dim = _tensor.dim()
+        if n_dim == 4:
+            img_np = make_grid(_tensor, nrow=int(math.sqrt(_tensor.size(0))), normalize=False).numpy()
+            img_np = img_np.transpose(1, 2, 0)
+            if rgb2bgr:
+                img_np = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
+        elif n_dim == 3:
+            img_np = _tensor.numpy()
+            img_np = img_np.transpose(1, 2, 0)
+            if img_np.shape[2] == 1:  # gray image
+                img_np = np.squeeze(img_np, axis=2)
+            else:
+                if rgb2bgr:
+                    img_np = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
+        elif n_dim == 2:
+            img_np = _tensor.numpy()
+        else:
+            raise TypeError(f'Only support 4D, 3D or 2D tensor. But received with dimension: {n_dim}')
+        if out_type == np.uint8:
+            # Unlike MATLAB, numpy.unit8() WILL NOT round by default.
+            img_np = (img_np * 255.0).round()
+        img_np = img_np.astype(out_type)
+        result.append(img_np)
+    if len(result) == 1:
+        result = result[0]
+    return result
+
+
+def tensor2img_fast(tensor, rgb2bgr=True, min_max=(0, 1)):
+    """This implementation is slightly faster than tensor2img.
+    It now only supports torch tensor with shape (1, c, h, w).
+
+    Args:
+        tensor (Tensor): Now only support torch tensor with (1, c, h, w).
+        rgb2bgr (bool): Whether to change rgb to bgr. Default: True.
+        min_max (tuple[int]): min and max values for clamp.
+    """
+    output = tensor.squeeze(0).detach().clamp_(*min_max).permute(1, 2, 0)
+    output = (output - min_max[0]) / (min_max[1] - min_max[0]) * 255
+    output = output.type(torch.uint8).cpu().numpy()
+    if rgb2bgr:
+        output = cv2.cvtColor(output, cv2.COLOR_RGB2BGR)
+    return output
+
+
+def imfrombytes(content, flag='color', float32=False):
+    """Read an image from bytes.
+
+    Args:
+        content (bytes): Image bytes got from files or other streams.
+        flag (str): Flags specifying the color type of a loaded image,
+            candidates are `color`, `grayscale` and `unchanged`.
+        float32 (bool): Whether to change to float32., If True, will also norm
+            to [0, 1]. Default: False.
+
+    Returns:
+        ndarray: Loaded image array.
+    """
+    img_np = np.frombuffer(content, np.uint8)
+    imread_flags = {'color': cv2.IMREAD_COLOR, 'grayscale': cv2.IMREAD_GRAYSCALE, 'unchanged': cv2.IMREAD_UNCHANGED}
+    img = cv2.imdecode(img_np, imread_flags[flag])
+    if float32:
+        img = img.astype(np.float32) / 255.
+    return img
+
+
+def imwrite(img, file_path, params=None, auto_mkdir=True):
+    """Write image to file.
+
+    Args:
+        img (ndarray): Image array to be written.
+        file_path (str): Image file path.
+        params (None or list): Same as opencv's :func:`imwrite` interface.
+        auto_mkdir (bool): If the parent folder of `file_path` does not exist,
+            whether to create it automatically.
+
+    Returns:
+        bool: Successful or not.
+    """
+    if auto_mkdir:
+        dir_name = os.path.abspath(os.path.dirname(file_path))
+        os.makedirs(dir_name, exist_ok=True)
+    ok = cv2.imwrite(file_path, img, params)
+    if not ok:
+        raise IOError('Failed in writing images.')
+
+
+def crop_border(imgs, crop_border):
+    """Crop borders of images.
+
+    Args:
+        imgs (list[ndarray] | ndarray): Images with shape (h, w, c).
+        crop_border (int): Crop border for each end of height and weight.
+
+    Returns:
+        list[ndarray]: Cropped images.
+    """
+    if crop_border == 0:
+        return imgs
+    else:
+        if isinstance(imgs, list):
+            return [v[crop_border:-crop_border, crop_border:-crop_border, ...] for v in imgs]
+        else:
+            return imgs[crop_border:-crop_border, crop_border:-crop_border, ...]
+
+
+def tensor_lab2rgb(labs, illuminant="D65", observer="2"):
+    """
+    Args:
+        lab    : (B, C, H, W)
+    Returns:
+        tuple   : (C, H, W)
+    """
+    illuminants = \
+        {"A": {'2': (1.098466069456375, 1, 0.3558228003436005),
+               '10': (1.111420406956693, 1, 0.3519978321919493)},
+         "D50": {'2': (0.9642119944211994, 1, 0.8251882845188288),
+                 '10': (0.9672062750333777, 1, 0.8142801513128616)},
+         "D55": {'2': (0.956797052643698, 1, 0.9214805860173273),
+                 '10': (0.9579665682254781, 1, 0.9092525159847462)},
+         "D65": {'2': (0.95047, 1., 1.08883),  # This was: `lab_ref_white`
+                 '10': (0.94809667673716, 1, 1.0730513595166162)},
+         "D75": {'2': (0.9497220898840717, 1, 1.226393520724154),
+                 '10': (0.9441713925645873, 1, 1.2064272211720228)},
+         "E": {'2': (1.0, 1.0, 1.0),
+               '10': (1.0, 1.0, 1.0)}}
+    xyz_from_rgb = np.array([[0.412453, 0.357580, 0.180423], [0.212671, 0.715160, 0.072169],
+                             [0.019334, 0.119193, 0.950227]])
+
+    rgb_from_xyz = np.array([[3.240481340, -0.96925495, 0.055646640], [-1.53715152, 1.875990000, -0.20404134],
+                             [-0.49853633, 0.041555930, 1.057311070]])
+    B, C, H, W = labs.shape
+    arrs = labs.permute((0, 2, 3, 1)).contiguous()  # (B, 3, H, W) -> (B, H, W, 3)
+    L, a, b = arrs[:, :, :, 0:1], arrs[:, :, :, 1:2], arrs[:, :, :, 2:]
+    y = (L + 16.) / 116.
+    x = (a / 500.) + y
+    z = y - (b / 200.)
+    invalid = z.data < 0
+    z[invalid] = 0
+    xyz = torch.cat([x, y, z], dim=3)
+    mask = xyz.data > 0.2068966
+    mask_xyz = xyz.clone()
+    mask_xyz[mask] = torch.pow(xyz[mask], 3.0)
+    mask_xyz[~mask] = (xyz[~mask] - 16.0 / 116.) / 7.787
+    xyz_ref_white = illuminants[illuminant][observer]
+    for i in range(C):
+        mask_xyz[:, :, :, i] = mask_xyz[:, :, :, i] * xyz_ref_white[i]
+
+    rgb_trans = torch.mm(mask_xyz.view(-1, 3), torch.from_numpy(rgb_from_xyz).type_as(xyz)).view(B, H, W, C)
+    rgb = rgb_trans.permute((0, 3, 1, 2)).contiguous()
+    mask = rgb.data > 0.0031308
+    mask_rgb = rgb.clone()
+    mask_rgb[mask] = 1.055 * torch.pow(rgb[mask], 1 / 2.4) - 0.055
+    mask_rgb[~mask] = rgb[~mask] * 12.92
+    neg_mask = mask_rgb.data < 0
+    large_mask = mask_rgb.data > 1
+    mask_rgb[neg_mask] = 0
+    mask_rgb[large_mask] = 1
+    return mask_rgb

experiments/round5-20260927/source/vendor_ddcolor/basicsr/utils/logger.py

@@ -0,0 +1,209 @@
+import datetime
+import logging
+import time
+
+from .dist_util import get_dist_info, master_only
+
+initialized_logger = {}
+
+
+class AvgTimer():
+
+    def __init__(self, window=200):
+        self.window = window  # average window
+        self.current_time = 0
+        self.total_time = 0
+        self.count = 0
+        self.avg_time = 0
+        self.start()
+
+    def start(self):
+        self.start_time = time.time()
+
+    def record(self):
+        self.count += 1
+        self.current_time = time.time() - self.start_time
+        self.total_time += self.current_time
+        # calculate average time
+        self.avg_time = self.total_time / self.count
+        # reset
+        if self.count > self.window:
+            self.count = 0
+            self.total_time = 0
+
+    def get_current_time(self):
+        return self.current_time
+
+    def get_avg_time(self):
+        return self.avg_time
+
+
+class MessageLogger():
+    """Message logger for printing.
+
+    Args:
+        opt (dict): Config. It contains the following keys:
+            name (str): Exp name.
+            logger (dict): Contains 'print_freq' (str) for logger interval.
+            train (dict): Contains 'total_iter' (int) for total iters.
+            use_tb_logger (bool): Use tensorboard logger.
+        start_iter (int): Start iter. Default: 1.
+        tb_logger (obj:`tb_logger`): Tensorboard logger. Default： None.
+    """
+
+    def __init__(self, opt, start_iter=1, tb_logger=None):
+        self.exp_name = opt['name']
+        self.interval = opt['logger']['print_freq']
+        self.start_iter = start_iter
+        self.max_iters = opt['train']['total_iter']
+        self.use_tb_logger = opt['logger']['use_tb_logger']
+        self.tb_logger = tb_logger
+        self.start_time = time.time()
+        self.logger = get_root_logger()
+
+    def reset_start_time(self):
+        self.start_time = time.time()
+
+    @master_only
+    def __call__(self, log_vars):
+        """Format logging message.
+
+        Args:
+            log_vars (dict): It contains the following keys:
+                epoch (int): Epoch number.
+                iter (int): Current iter.
+                lrs (list): List for learning rates.
+
+                time (float): Iter time.
+                data_time (float): Data time for each iter.
+        """
+        # epoch, iter, learning rates
+        epoch = log_vars.pop('epoch')
+        current_iter = log_vars.pop('iter')
+        lrs = log_vars.pop('lrs')
+
+        message = (f'[{self.exp_name[:5]}..][epoch:{epoch:3d}, iter:{current_iter:8,d}, lr:(')
+        for v in lrs:
+            message += f'{v:.3e},'
+        message += ')] '
+
+        # time and estimated time
+        if 'time' in log_vars.keys():
+            iter_time = log_vars.pop('time')
+            data_time = log_vars.pop('data_time')
+
+            total_time = time.time() - self.start_time
+            time_sec_avg = total_time / (current_iter - self.start_iter + 1)
+            eta_sec = time_sec_avg * (self.max_iters - current_iter - 1)
+            eta_str = str(datetime.timedelta(seconds=int(eta_sec)))
+            message += f'[eta: {eta_str}, '
+            message += f'time (data): {iter_time:.3f} ({data_time:.3f})] '
+
+        # other items, especially losses
+        for k, v in log_vars.items():
+            message += f'{k}: {v:.4e} '
+            # tensorboard logger
+            if self.use_tb_logger and 'debug' not in self.exp_name:
+                if k.startswith('l_'):
+                    self.tb_logger.add_scalar(f'losses/{k}', v, current_iter)
+                else:
+                    self.tb_logger.add_scalar(k, v, current_iter)
+        self.logger.info(message)
+
+
+@master_only
+def init_tb_logger(log_dir):
+    from torch.utils.tensorboard import SummaryWriter
+    tb_logger = SummaryWriter(log_dir=log_dir)
+    return tb_logger
+
+
+@master_only
+def init_wandb_logger(opt):
+    """We now only use wandb to sync tensorboard log."""
+    import wandb
+    logger = get_root_logger()
+
+    project = opt['logger']['wandb']['project']
+    resume_id = opt['logger']['wandb'].get('resume_id')
+    if resume_id:
+        wandb_id = resume_id
+        resume = 'allow'
+        logger.warning(f'Resume wandb logger with id={wandb_id}.')
+    else:
+        wandb_id = wandb.util.generate_id()
+        resume = 'never'
+
+    wandb.init(id=wandb_id, resume=resume, name=opt['name'], config=opt, project=project, sync_tensorboard=True)
+
+    logger.info(f'Use wandb logger with id={wandb_id}; project={project}.')
+
+
+def get_root_logger(logger_name='basicsr', log_level=logging.INFO, log_file=None):
+    """Get the root logger.
+
+    The logger will be initialized if it has not been initialized. By default a
+    StreamHandler will be added. If `log_file` is specified, a FileHandler will
+    also be added.
+
+    Args:
+        logger_name (str): root logger name. Default: 'basicsr'.
+        log_file (str | None): The log filename. If specified, a FileHandler
+            will be added to the root logger.
+        log_level (int): The root logger level. Note that only the process of
+            rank 0 is affected, while other processes will set the level to
+            "Error" and be silent most of the time.
+
+    Returns:
+        logging.Logger: The root logger.
+    """
+    logger = logging.getLogger(logger_name)
+    # if the logger has been initialized, just return it
+    if logger_name in initialized_logger:
+        return logger
+
+    format_str = '%(asctime)s %(levelname)s: %(message)s'
+    stream_handler = logging.StreamHandler()
+    stream_handler.setFormatter(logging.Formatter(format_str))
+    logger.addHandler(stream_handler)
+    logger.propagate = False
+    rank, _ = get_dist_info()
+    if rank != 0:
+        logger.setLevel('ERROR')
+    elif log_file is not None:
+        logger.setLevel(log_level)
+        # add file handler
+        file_handler = logging.FileHandler(log_file, 'w')
+        file_handler.setFormatter(logging.Formatter(format_str))
+        file_handler.setLevel(log_level)
+        logger.addHandler(file_handler)
+    initialized_logger[logger_name] = True
+    return logger
+
+
+def get_env_info():
+    """Get environment information.
+
+    Currently, only log the software version.
+    """
+    import torch
+    import torchvision
+
+    from basicsr.version import __version__
+    msg = r"""
+                ____                _       _____  ____
+               / __ ) ____ _ _____ (_)_____/ ___/ / __ \
+              / __  |/ __ `// ___// // ___/\__ \ / /_/ /
+             / /_/ // /_/ /(__  )/ // /__ ___/ // _, _/
+            /_____/ \__,_//____//_/ \___//____//_/ |_|
+     ______                   __   __                 __      __
+    / ____/____   ____   ____/ /  / /   __  __ _____ / /__   / /
+   / / __ / __ \ / __ \ / __  /  / /   / / / // ___// //_/  / /
+  / /_/ // /_/ // /_/ // /_/ /  / /___/ /_/ // /__ / /<    /_/
+  \____/ \____/ \____/ \____/  /_____/\____/ \___//_/|_|  (_)
+    """
+    msg += ('\nVersion Information: '
+            f'\n\tBasicSR: {__version__}'
+            f'\n\tPyTorch: {torch.__version__}'
+            f'\n\tTorchVision: {torchvision.__version__}')
+    return msg

experiments/round5-20260927/source/vendor_ddcolor/basicsr/utils/misc.py

@@ -0,0 +1,141 @@
+import numpy as np
+import os
+import random
+import time
+import torch
+from os import path as osp
+
+from .dist_util import master_only
+
+
+def set_random_seed(seed):
+    """Set random seeds."""
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+
+def get_time_str():
+    return time.strftime('%Y%m%d_%H%M%S', time.localtime())
+
+
+def mkdir_and_rename(path):
+    """mkdirs. If path exists, rename it with timestamp and create a new one.
+
+    Args:
+        path (str): Folder path.
+    """
+    if osp.exists(path):
+        new_name = path + '_archived_' + get_time_str()
+        print(f'Path already exists. Rename it to {new_name}', flush=True)
+        os.rename(path, new_name)
+    os.makedirs(path, exist_ok=True)
+
+
+@master_only
+def make_exp_dirs(opt):
+    """Make dirs for experiments."""
+    path_opt = opt['path'].copy()
+    if opt['is_train']:
+        mkdir_and_rename(path_opt.pop('experiments_root'))
+    else:
+        mkdir_and_rename(path_opt.pop('results_root'))
+    for key, path in path_opt.items():
+        if ('strict_load' in key) or ('pretrain_network' in key) or ('resume' in key) or ('param_key' in key):
+            continue
+        else:
+            os.makedirs(path, exist_ok=True)
+
+
+def scandir(dir_path, suffix=None, recursive=False, full_path=False):
+    """Scan a directory to find the interested files.
+
+    Args:
+        dir_path (str): Path of the directory.
+        suffix (str | tuple(str), optional): File suffix that we are
+            interested in. Default: None.
+        recursive (bool, optional): If set to True, recursively scan the
+            directory. Default: False.
+        full_path (bool, optional): If set to True, include the dir_path.
+            Default: False.
+
+    Returns:
+        A generator for all the interested files with relative paths.
+    """
+
+    if (suffix is not None) and not isinstance(suffix, (str, tuple)):
+        raise TypeError('"suffix" must be a string or tuple of strings')
+
+    root = dir_path
+
+    def _scandir(dir_path, suffix, recursive):
+        for entry in os.scandir(dir_path):
+            if not entry.name.startswith('.') and entry.is_file():
+                if full_path:
+                    return_path = entry.path
+                else:
+                    return_path = osp.relpath(entry.path, root)
+
+                if suffix is None:
+                    yield return_path
+                elif return_path.endswith(suffix):
+                    yield return_path
+            else:
+                if recursive:
+                    yield from _scandir(entry.path, suffix=suffix, recursive=recursive)
+                else:
+                    continue
+
+    return _scandir(dir_path, suffix=suffix, recursive=recursive)
+
+
+def check_resume(opt, resume_iter):
+    """Check resume states and pretrain_network paths.
+
+    Args:
+        opt (dict): Options.
+        resume_iter (int): Resume iteration.
+    """
+    if opt['path']['resume_state']:
+        # get all the networks
+        networks = [key for key in opt.keys() if key.startswith('network_')]
+        flag_pretrain = False
+        for network in networks:
+            if opt['path'].get(f'pretrain_{network}') is not None:
+                flag_pretrain = True
+        if flag_pretrain:
+            print('pretrain_network path will be ignored during resuming.')
+        # set pretrained model paths
+        for network in networks:
+            name = f'pretrain_{network}'
+            basename = network.replace('network_', '')
+            if opt['path'].get('ignore_resume_networks') is None or (network
+                                                                     not in opt['path']['ignore_resume_networks']):
+                opt['path'][name] = osp.join(opt['path']['models'], f'net_{basename}_{resume_iter}.pth')
+                print(f"Set {name} to {opt['path'][name]}")
+
+        # change param_key to params in resume
+        param_keys = [key for key in opt['path'].keys() if key.startswith('param_key')]
+        for param_key in param_keys:
+            if opt['path'][param_key] == 'params_ema':
+                opt['path'][param_key] = 'params'
+                print(f'Set {param_key} to params')
+
+
+def sizeof_fmt(size, suffix='B'):
+    """Get human readable file size.
+
+    Args:
+        size (int): File size.
+        suffix (str): Suffix. Default: 'B'.
+
+    Return:
+        str: Formatted file siz.
+    """
+    for unit in ['', 'K', 'M', 'G', 'T', 'P', 'E', 'Z']:
+        if abs(size) < 1024.0:
+            return f'{size:3.1f} {unit}{suffix}'
+        size /= 1024.0
+    return f'{size:3.1f} Y{suffix}'

experiments/round5-20260927/source/vendor_ddcolor/basicsr/utils/registry.py

@@ -0,0 +1,82 @@
+# Modified from: https://github.com/facebookresearch/fvcore/blob/master/fvcore/common/registry.py  # noqa: E501
+
+
+class Registry():
+    """
+    The registry that provides name -> object mapping, to support third-party
+    users' custom modules.
+
+    To create a registry (e.g. a backbone registry):
+
+    .. code-block:: python
+
+        BACKBONE_REGISTRY = Registry('BACKBONE')
+
+    To register an object:
+
+    .. code-block:: python
+
+        @BACKBONE_REGISTRY.register()
+        class MyBackbone():
+            ...
+
+    Or:
+
+    .. code-block:: python
+
+        BACKBONE_REGISTRY.register(MyBackbone)
+    """
+
+    def __init__(self, name):
+        """
+        Args:
+            name (str): the name of this registry
+        """
+        self._name = name
+        self._obj_map = {}
+
+    def _do_register(self, name, obj):
+        assert (name not in self._obj_map), (f"An object named '{name}' was already registered "
+                                             f"in '{self._name}' registry!")
+        self._obj_map[name] = obj
+
+    def register(self, obj=None):
+        """
+        Register the given object under the the name `obj.__name__`.
+        Can be used as either a decorator or not.
+        See docstring of this class for usage.
+        """
+        if obj is None:
+            # used as a decorator
+            def deco(func_or_class):
+                name = func_or_class.__name__
+                self._do_register(name, func_or_class)
+                return func_or_class
+
+            return deco
+
+        # used as a function call
+        name = obj.__name__
+        self._do_register(name, obj)
+
+    def get(self, name):
+        ret = self._obj_map.get(name)
+        if ret is None:
+            raise KeyError(f"No object named '{name}' found in '{self._name}' registry!")
+        return ret
+
+    def __contains__(self, name):
+        return name in self._obj_map
+
+    def __iter__(self):
+        return iter(self._obj_map.items())
+
+    def keys(self):
+        return self._obj_map.keys()
+
+
+DATASET_REGISTRY = Registry('dataset')
+ARCH_REGISTRY = Registry('arch')
+MODEL_REGISTRY = Registry('model')
+LOSS_REGISTRY = Registry('loss')
+METRIC_REGISTRY = Registry('metric')

experiments/round5-20260927/source/vendor_ddcolor/ddcolor/__init__.py

@@ -0,0 +1,9 @@
+from .model import DDColor
+from .pipeline import ColorizationPipeline, build_ddcolor_model, load_checkpoint_state_dict
+
+__all__ = [
+    "DDColor",
+    "ColorizationPipeline",
+    "build_ddcolor_model",
+    "load_checkpoint_state_dict",
+]

experiments/round5-20260927/source/vendor_ddcolor/ddcolor/model.py

@@ -0,0 +1,278 @@
+import torch
+import torch.nn as nn
+
+from basicsr.archs.ddcolor_arch_utils.unet import Hook, CustomPixelShuffle_ICNR,  UnetBlockWide, NormType, custom_conv_layer
+from basicsr.archs.ddcolor_arch_utils.convnext import ConvNeXt
+from basicsr.archs.ddcolor_arch_utils.transformer_utils import SelfAttentionLayer, CrossAttentionLayer, FFNLayer, MLP
+from basicsr.archs.ddcolor_arch_utils.position_encoding import PositionEmbeddingSine
+
+
+class DDColor(nn.Module):
+    def __init__(
+        self,
+        encoder_name='convnext-l',
+        decoder_name='MultiScaleColorDecoder',
+        num_input_channels=3,
+        input_size=(256, 256),
+        nf=512,
+        num_output_channels=3,
+        last_norm='Weight',
+        do_normalize=False,
+        num_queries=256,
+        num_scales=3,
+        dec_layers=9,
+    ):
+        super().__init__()
+
+        self.encoder = ImageEncoder(encoder_name, ['norm0', 'norm1', 'norm2', 'norm3'])
+        self.encoder.eval()
+        test_input = torch.randn(1, num_input_channels, *input_size)
+
+        with torch.no_grad():
+            self.encoder(test_input)
+
+        self.decoder = DuelDecoder(
+            self.encoder.hooks,
+            nf=nf,
+            last_norm=last_norm,
+            num_queries=num_queries,
+            num_scales=num_scales,
+            dec_layers=dec_layers,
+            decoder_name=decoder_name
+        )
+
+        self.refine_net = nn.Sequential(
+            custom_conv_layer(num_queries + 3, num_output_channels, ks=1, use_activ=False, norm_type=NormType.Spectral)
+        )
+    
+        self.do_normalize = do_normalize
+        self.register_buffer('mean', torch.Tensor([0.485, 0.456, 0.406]).view(1, 3, 1, 1))
+        self.register_buffer('std', torch.Tensor([0.229, 0.224, 0.225]).view(1, 3, 1, 1))
+
+    def normalize(self, img):
+        return (img - self.mean) / self.std
+
+    def denormalize(self, img):
+        return img * self.std + self.mean
+
+    def forward(self, x):
+        if x.shape[1] == 3:
+            x = self.normalize(x)
+        
+        self.encoder(x)
+        out_feat = self.decoder()
+        coarse_input = torch.cat([out_feat, x], dim=1)
+        out = self.refine_net(coarse_input)
+
+        if self.do_normalize:
+            out = self.denormalize(out)
+        return out
+
+
+class ImageEncoder(nn.Module):
+    def __init__(self, encoder_name, hook_names):
+        super().__init__()
+
+        assert encoder_name == 'convnext-t' or encoder_name == 'convnext-l'
+        if encoder_name == 'convnext-t':
+            self.arch = ConvNeXt(depths=[3, 3, 9, 3], dims=[96, 192, 384, 768])
+        elif encoder_name == 'convnext-l':
+            self.arch = ConvNeXt(depths=[3, 3, 27, 3], dims=[192, 384, 768, 1536])
+        else:
+            raise NotImplementedError
+
+        self.encoder_name = encoder_name
+        self.hook_names = hook_names
+        self.hooks = self.setup_hooks()
+
+    def setup_hooks(self):
+        hooks = [Hook(self.arch._modules[name]) for name in self.hook_names]
+        return hooks
+
+    def forward(self, x):
+        return self.arch(x)
+
+
+class DuelDecoder(nn.Module):
+    def __init__(
+        self,
+        hooks,
+        nf=512,
+        blur=True,
+        last_norm='Weight',
+        num_queries=256,
+        num_scales=3,
+        dec_layers=9,
+        decoder_name='MultiScaleColorDecoder',
+    ):
+        super().__init__()
+        self.hooks = hooks
+        self.nf = nf
+        self.blur = blur
+        self.last_norm = getattr(NormType, last_norm)
+        self.decoder_name = decoder_name
+
+        self.layers = self.make_layers()
+        embed_dim = nf // 2
+        self.last_shuf = CustomPixelShuffle_ICNR(embed_dim, embed_dim, blur=self.blur, norm_type=self.last_norm, scale=4)
+        
+        assert decoder_name == 'MultiScaleColorDecoder'
+        self.color_decoder = MultiScaleColorDecoder(
+            in_channels=[512, 512, 256],
+            num_queries=num_queries,
+            num_scales=num_scales,
+            dec_layers=dec_layers,
+        )
+
+    def make_layers(self):
+        decoder_layers = []
+        in_c = self.hooks[-1].feature.shape[1]
+        out_c = self.nf
+
+        setup_hooks = self.hooks[-2::-1]
+        for layer_index, hook in enumerate(setup_hooks):
+            feature_c = hook.feature.shape[1]
+            if layer_index == len(setup_hooks) - 1:
+                out_c = out_c // 2
+            decoder_layers.append(
+                UnetBlockWide(
+                    in_c, feature_c, out_c, hook, blur=self.blur, self_attention=False, norm_type=NormType.Spectral))
+            in_c = out_c
+
+        return nn.Sequential(*decoder_layers)
+
+    def forward(self):
+        encode_feat = self.hooks[-1].feature
+        out0 = self.layers[0](encode_feat)
+        out1 = self.layers[1](out0) 
+        out2 = self.layers[2](out1) 
+        out3 = self.last_shuf(out2) 
+
+        return self.color_decoder([out0, out1, out2], out3)
+
+
+class MultiScaleColorDecoder(nn.Module):
+    def __init__(
+        self,
+        in_channels,
+        hidden_dim=256,
+        num_queries=100,
+        nheads=8,
+        dim_feedforward=2048,
+        dec_layers=9,
+        pre_norm=False,
+        color_embed_dim=256,
+        enforce_input_project=True,
+        num_scales=3,
+    ):
+        super().__init__()
+
+        self.hidden_dim = hidden_dim
+        self.num_queries = num_queries
+        self.num_layers = dec_layers
+        self.num_feature_levels = num_scales  
+
+        # Positional encoding layer
+        self.pe_layer = PositionEmbeddingSine(hidden_dim // 2, normalize=True)
+        
+        # Learnable query features and embeddings
+        self.query_feat = nn.Embedding(num_queries, hidden_dim)
+        self.query_embed = nn.Embedding(num_queries, hidden_dim)
+
+        # Learnable level embeddings
+        self.level_embed = nn.Embedding(num_scales, hidden_dim)
+
+        # Input projection layers
+        self.input_proj = nn.ModuleList(
+            [self._make_input_proj(in_ch, hidden_dim, enforce_input_project) for in_ch in in_channels]
+        )
+
+        # Transformer layers
+        self.transformer_self_attention_layers = nn.ModuleList()
+        self.transformer_cross_attention_layers = nn.ModuleList()
+        self.transformer_ffn_layers = nn.ModuleList()
+
+        for _ in range(dec_layers):
+            self.transformer_self_attention_layers.append(
+                SelfAttentionLayer(
+                    d_model=hidden_dim,
+                    nhead=nheads,
+                    dropout=0.0,
+                    normalize_before=pre_norm,
+                )
+            )
+            self.transformer_cross_attention_layers.append(
+                CrossAttentionLayer(
+                    d_model=hidden_dim,
+                    nhead=nheads,
+                    dropout=0.0,
+                    normalize_before=pre_norm,
+                )
+            )
+            self.transformer_ffn_layers.append(
+                FFNLayer(
+                    d_model=hidden_dim,
+                    dim_feedforward=dim_feedforward,
+                    dropout=0.0,
+                    normalize_before=pre_norm,
+                )
+            )
+
+        # Layer normalization for the decoder output
+        self.decoder_norm = nn.LayerNorm(hidden_dim)
+        
+        # Output embedding layer
+        self.color_embed = MLP(hidden_dim, hidden_dim, color_embed_dim, 3)
+
+    def forward(self, x, img_features):
+        assert len(x) == self.num_feature_levels
+
+        src, pos = self._get_src_and_pos(x)
+
+        bs = src[0].shape[1]
+
+        # Prepare query embeddings (QxNxC)
+        query_embed = self.query_embed.weight.unsqueeze(1).repeat(1, bs, 1)
+        output = self.query_feat.weight.unsqueeze(1).repeat(1, bs, 1)
+    
+        for i in range(self.num_layers):
+            level_index = i % self.num_feature_levels
+            # attention: cross-attention first
+            output = self.transformer_cross_attention_layers[i](
+                output, src[level_index],
+                memory_mask=None,
+                memory_key_padding_mask=None,
+                pos=pos[level_index], query_pos=query_embed
+            )
+            output = self.transformer_self_attention_layers[i](
+                output, tgt_mask=None,
+                tgt_key_padding_mask=None,
+                query_pos=query_embed
+            )
+            # FFN
+            output = self.transformer_ffn_layers[i](
+                output
+            )
+
+        decoder_output = self.decoder_norm(output).transpose(0, 1)
+        color_embed = self.color_embed(decoder_output)
+    
+        out = torch.einsum("bqc,bchw->bqhw", color_embed, img_features)
+
+        return out
+
+    def _make_input_proj(self, in_ch, hidden_dim, enforce):
+        if in_ch != hidden_dim or enforce:
+            proj = nn.Conv2d(in_ch, hidden_dim, kernel_size=1)
+            nn.init.kaiming_uniform_(proj.weight, a=1)
+            if proj.bias is not None:
+                nn.init.constant_(proj.bias, 0)
+            return proj
+        return nn.Sequential()
+
+    def _get_src_and_pos(self, x):
+        src, pos = [], []
+        for i, feature in enumerate(x):
+            pos.append(self.pe_layer(feature).flatten(2).permute(2, 0, 1))  # flatten NxCxHxW to HWxNxC
+            src.append((self.input_proj[i](feature).flatten(2) + self.level_embed.weight[i][None, :, None]).permute(2, 0, 1))
+        return src, pos

experiments/round5-20260927/source/vendor_ddcolor/ddcolor/pipeline.py

@@ -0,0 +1,127 @@
+import cv2
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+
+def load_checkpoint_state_dict(model_path: str, map_location="cpu"):
+    """Load a checkpoint and return a state_dict.
+
+    Supports both:
+    - {'params': state_dict, ...} (common in this repo)
+    - raw state_dict
+    """
+    ckpt = torch.load(model_path, map_location=map_location)
+    if isinstance(ckpt, dict) and "params" in ckpt:
+        return ckpt["params"]
+    return ckpt
+
+
+def build_ddcolor_model(
+    model_cls,
+    *,
+    model_path: str,
+    input_size: int = 512,
+    model_size: str = "large",
+    decoder_type: str = "MultiScaleColorDecoder",
+    device=None,
+    **kwargs,
+):
+    """Build a DDColor model and load weights.
+
+    This helper is intentionally backend-agnostic: `model_cls` can be
+    `ddcolor.DDColor` or `basicsr.archs.ddcolor_arch.DDColor` as long as
+    it supports the common constructor args used below.
+    """
+    if device is None:
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    if model_size not in ("tiny", "large"):
+        raise ValueError(f"model_size must be 'tiny' or 'large', got: {model_size}")
+    encoder_name = "convnext-t" if model_size == "tiny" else "convnext-l"
+
+    if decoder_type == "MultiScaleColorDecoder":
+        # keep default consistent with existing scripts
+        kwargs.setdefault("num_queries", 100)
+        kwargs.setdefault("num_scales", 3)
+        kwargs.setdefault("dec_layers", 9)
+    elif decoder_type == "SingleColorDecoder":
+        kwargs.setdefault("num_queries", 256)
+    else:
+        raise NotImplementedError(f"decoder_type not implemented: {decoder_type}")
+
+    model = model_cls(
+        encoder_name=encoder_name,
+        decoder_name=decoder_type,
+        input_size=[input_size, input_size],
+        num_output_channels=2,
+        last_norm="Spectral",
+        do_normalize=False,
+        **kwargs,
+    )
+
+    state_dict = load_checkpoint_state_dict(model_path, map_location="cpu")
+    model.load_state_dict(state_dict, strict=False)
+    model = model.to(device)
+    model.eval()
+    return model
+
+
+class ColorizationPipeline:
+    """Shared image colorization pipeline used by CLI/Gradio/Cog.
+
+    - input: BGR uint8 image (OpenCV)
+    - output: BGR uint8 image (OpenCV)
+    """
+
+    def __init__(self, model, *, input_size: int = 512, device=None):
+        self.input_size = int(input_size)
+        if device is None:
+            try:
+                device = next(model.parameters()).device
+            except StopIteration:
+                device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.device = device
+        self.model = model.to(self.device)
+        self.model.eval()
+
+    def process(self, img_bgr: np.ndarray) -> np.ndarray:
+        ctx = torch.inference_mode if hasattr(torch, "inference_mode") else torch.no_grad
+        with ctx():
+            if img_bgr is None:
+                raise ValueError("img is None (cv2.imread failed?)")
+
+            height, width = img_bgr.shape[:2]
+
+            img = (img_bgr / 255.0).astype(np.float32)
+            orig_l = cv2.cvtColor(img, cv2.COLOR_BGR2Lab)[:, :, :1]  # (h, w, 1)
+
+            # resize rgb image -> lab -> get grey -> rgb
+            img_resized = cv2.resize(img, (self.input_size, self.input_size))
+            img_l = cv2.cvtColor(img_resized, cv2.COLOR_BGR2Lab)[:, :, :1]
+            img_gray_lab = np.concatenate(
+                (img_l, np.zeros_like(img_l), np.zeros_like(img_l)), axis=-1
+            )
+            img_gray_rgb = cv2.cvtColor(img_gray_lab, cv2.COLOR_LAB2RGB)
+
+            tensor_gray_rgb = (
+                torch.from_numpy(img_gray_rgb.transpose((2, 0, 1)))
+                .float()
+                .unsqueeze(0)
+                .to(self.device)
+            )
+
+            output_ab = self.model(tensor_gray_rgb).cpu()  # (1, 2, input_size, input_size)
+
+            # resize ab -> concat original l -> bgr
+            output_ab_resized = (
+                F.interpolate(output_ab, size=(height, width))[0]
+                .float()
+                .numpy()
+                .transpose(1, 2, 0)
+            )
+            output_lab = np.concatenate((orig_l, output_ab_resized), axis=-1)
+            output_bgr = cv2.cvtColor(output_lab, cv2.COLOR_LAB2BGR)
+
+            output_img = (output_bgr * 255.0).round().astype(np.uint8)
+            return output_img

experiments/round5-20260927/status.json

@@ -0,0 +1,3 @@
+{
+  "status": "initializing"
+}