colorization-deploy-v2

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

submissions/colorization/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2016, Richard Zhang, Phillip Isola, Alexei A. Efros
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

submissions/colorization/README.md

@@ -0,0 +1,37 @@
+# Colorization 
+
+Automatic colorization of grayscale images using a CNN trained on ImageNet.
+Based on the paper: [Colorful Image Colorization](http://richzhang.github.io/colorization/)
+by Richard Zhang, Phillip Isola, Alexei A. Efros (ECCV 2016).
+
+The network takes the L channel of a LAB image as input and predicts the
+ab channels, which are then merged back with L to produce a full-color output.
+
+## Model Details
+- **Architecture**: Custom CNN (VGG-style encoder + dilated convolutions)
+- **Input**: Grayscale image (L channel of LAB), 224×224
+- **Output**: ab channels, upsampled to original size
+- **Framework**: ONNX (converted from original Caffe model)
+- **Original weights**: http://eecs.berkeley.edu/~rich.zhang/projects/2016_colorization/
+
+## Usage
+
+### Python
+```bash
+python demo.py --model colorization_deploy_v2_2026april.onnx --image example_outputs/input_image.jpg --output example_outputs/output_image.png
+```
+
+Or import directly:
+```python
+import cv2
+
+net = cv2.dnn.readNet("colorization_deploy_v2_2026apr.onnx")
+# see demo.py for full inference pipeline
+```
+
+## License
+See [LICENSE](./LICENSE) — original model is released under BSD license by Richard Zhang.
+
+## References
+- Paper: https://arxiv.org/abs/1603.08511
+- Original repo: https://github.com/richzhang/colorization

submissions/colorization/colorization_deploy_v2_2026april.onnx

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

submissions/colorization/demo.py

@@ -0,0 +1,42 @@
+"""
+Grayscale image colorization using colorization_deploy_v2 ONNX model.
+Usage:
+    python demo.py --model colorization_deploy_v2_2026april.onnx --image example_outputs/input_image.jpg
+"""
+import argparse
+import numpy as np
+import cv2 as cv
+
+def colorize(model_path: str, image_path: str, output_path: str = "example_outputs/output_image.png"):
+    net = cv.dnn.readNet(model_path)
+
+    img = cv.imread(image_path)
+    if img is None:
+        print(f"Error: Could not read image at {image_path}")
+        return
+
+    img_rgb = (img[:, :, ::-1] * 1.0 / 255).astype(np.float32)
+    img_lab = cv.cvtColor(img_rgb, cv.COLOR_RGB2Lab)
+
+    img_l = img_lab[:, :, 0]                        # L channel
+    img_l_rs = cv.resize(img_l, (224, 224))
+    img_l_rs -= 50.0                                # mean-center subtraction
+
+    net.setInput(cv.dnn.blobFromImage(img_l_rs))
+    ab_dec = net.forward()[0, :, :, :].transpose((1, 2, 0))
+
+    (h, w) = img_rgb.shape[:2]
+    ab_dec_us = cv.resize(ab_dec, (w, h))
+    img_lab_out = np.concatenate((img_l[:, :, np.newaxis], ab_dec_us), axis=2)
+
+    img_bgr_out = np.clip(cv.cvtColor(img_lab_out, cv.COLOR_Lab2BGR), 0, 1)
+    cv.imwrite(output_path, (img_bgr_out * 255).astype(np.uint8))
+    print(f"Saved colorized image to {output_path}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Colorize a grayscale image")
+    parser.add_argument("--model", required=True, help="Path to .onnx model")
+    parser.add_argument("--image", required=True, help="Path to input image")
+    parser.add_argument("--output", default="example_outputs/output_image.png", help="Output image path")
+    args = parser.parse_args()
+    colorize(args.model, args.image, args.output)

submissions/colorization/model_conversion.py

@@ -0,0 +1,48 @@
+import torch
+import torch.nn as nn
+import numpy as np
+from colorization.colorizers import eccv16
+
+class ExactCaffeMatch(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.core = eccv16(pretrained=True).eval()
+
+        # Load the color palette kernel
+        pts_in_hull = np.load('opencv_extra/testdata/dnn/colorization_pts_in_hull.npy')
+
+        weight_tensor = torch.tensor(pts_in_hull.flatten()).float().view(2, 313, 1, 1)
+        self.register_buffer('decode_weight', weight_tensor)
+
+    def forward(self, x):
+        x = x / 100.0
+        x = self.core.model1(x)
+        x = self.core.model2(x)
+        x = self.core.model3(x)
+        x = self.core.model4(x)
+        x = self.core.model5(x)
+        x = self.core.model6(x)
+        x = self.core.model7(x)
+        x = self.core.model8(x)
+
+        # 1. Apply Caffe temperature scaling
+        x = x * 2.606# 2. Softmax
+        x = torch.softmax(x, dim=1)
+
+        x = torch.nn.functional.conv2d(x, self.decode_weight)
+
+        return x
+
+model = ExactCaffeMatch()
+dummy_input = torch.randn(1, 1, 224, 224)
+
+torch.onnx.export(
+    model, dummy_input,
+    "colorization/colorization_deploy_v2_2026april.onnx",
+    export_params=True,
+    opset_version=11,
+    do_constant_folding=True,
+    input_names=['data_l'],
+    output_names=['class8_ab'],
+    operator_export_type=torch.onnx.OperatorExportTypes.ONNX_FALLTHROUGH
+)