{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.11.11","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"nvidiaTeslaT4","dataSources":[{"sourceId":6799,"databundleVersionId":4225553,"isSourceIdPinned":false,"sourceType":"competition"},{"sourceId":4336269,"sourceType":"datasetVersion","datasetId":2553154},{"sourceId":11789879,"sourceType":"datasetVersion","datasetId":7386164}],"dockerImageVersionId":31012,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"from PIL import Image\nimport numpy as np\nfrom skimage import color\nfrom skimage.color import lab2rgb, rgb2lab\nimport torch\nimport os\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom IPython import embed\nimport matplotlib.pyplot as plt","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true,"execution":{"iopub.status.busy":"2025-05-13T03:26:25.097427Z","iopub.execute_input":"2025-05-13T03:26:25.097984Z","iopub.status.idle":"2025-05-13T03:26:25.101892Z","shell.execute_reply.started":"2025-05-13T03:26:25.097961Z","shell.execute_reply":"2025-05-13T03:26:25.101222Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# UTILITY FUNCTIONS\n\ndef load_img(img_path):\n\tout_np = np.asarray(Image.open(img_path))\n\tif(out_np.ndim==2):\n\t\tout_np = np.tile(out_np[:,:,None],3)\n\treturn out_np\n\ndef resize_img(img, HW=(256,256), resample=3):\n\treturn np.asarray(Image.fromarray(img).resize((HW[1],HW[0]), resample=resample))\n\ndef preprocess_img(img_rgb_orig, HW=(256,256), resample=3):\n    # return original size L and resized L as torch Tensors\n    img_rgb_rs = resize_img(img_rgb_orig, HW=HW, resample=resample)\n    \n    img_lab_orig = color.rgb2lab(img_rgb_orig)\n    img_lab_rs = color.rgb2lab(img_rgb_rs)\n\n    img_l_orig = img_lab_orig[:, :, 0]\n    img_l_rs = img_lab_rs[:, :, 0]\n    img_ab_rs = img_lab_rs[:, :, 1:3]\n\n    tens_orig_l = torch.Tensor(img_l_orig)[None, None, :, :]\n    tens_rs_l = torch.Tensor(img_l_rs)[None, None, :, :]\n    tens_rs_ab = torch.Tensor(img_ab_rs).permute(2, 0, 1)  # (2,H,W)\n\n    return (tens_orig_l, tens_rs_l, tens_rs_ab)\n\ndef postprocess_tens(tens_orig_l, out_ab, mode='bilinear'):\n\t# tens_orig_l \t1 x 1 x H_orig x W_orig\n\t# out_ab \t\t1 x 2 x H x W\n\n\tHW_orig = tens_orig_l.shape[2:]\n\tHW = out_ab.shape[2:]\n\n\t# call resize function if needed\n\tif(HW_orig[0]!=HW[0] or HW_orig[1]!=HW[1]):\n\t\tout_ab_orig = F.interpolate(out_ab, size=HW_orig, mode='bilinear')\n\telse:\n\t\tout_ab_orig = out_ab\n\n\tout_lab_orig = torch.cat((tens_orig_l, out_ab_orig), dim=1)\n\treturn color.lab2rgb(out_lab_orig.data.cpu().numpy()[0,...].transpose((1,2,0)))\n\ndef compute_soft_encoding(ab_image, bin_centers, sigma=5.0):\n    \"\"\"\n    ab_image: Tensor of shape [2, H, W] (ground truth ab channels)\n    bin_centers: Tensor of shape [313, 2] (predefined bin centers)\n    sigma: Soft-encoding standard deviation\n    Returns:\n        soft_encoding: Tensor of shape [313, H, W]\n    \"\"\"\n    C, H, W = ab_image.shape\n    ab_flat = ab_image.view(2, -1).T  # [H*W, 2]\n\n    # Compute L2 distance from each pixel to each bin center\n    dist = torch.cdist(ab_flat.unsqueeze(0), bin_centers.unsqueeze(0)).squeeze(0)  # [H*W, 313]\n\n    # Apply softmax with negative distances to get soft-assignment\n    weights = torch.exp(- (dist ** 2) / (2 * sigma ** 2))  # Gaussian kernel\n    weights = weights / weights.sum(dim=1, keepdim=True)  # Normalize to sum to 1\n    soft_encoding = weights.T.view(313, H, W)\n    return soft_encoding\n\n\n## Bin centers\n\nbin_centers = torch.zeros(313, 2)\n\nab_idx2bin_idx = {\n    (0, 16): 0, (0, 17): 1, (0, 18): 2, (0, 19): 3, (0, 20): 4,\n    (1, 13): 5, (1, 14): 6, (1, 15): 7, (1, 16): 8, (1, 17): 9, (1, 18): 10, (1, 19): 11, (1, 20): 12,\n    (2, 11): 13, (2, 12): 14, (2, 13): 15, (2, 14): 16, (2, 15): 17, (2, 16): 18, (2, 17): 19, (2, 18): 20, (2, 19): 21, (2, 20): 22,\n    (3, 9): 23, (3, 10): 24, (3, 11): 25, (3, 12): 26, (3, 13): 27, (3, 14): 28, (3, 15): 29, (3, 16): 30, (3, 17): 31, (3, 18): 32, (3, 19): 33, (3, 20): 34,\n    (4, 8): 35, (4, 9): 36, (4, 10): 37, (4, 11): 38, (4, 12): 39, (4, 13): 40, (4, 14): 41, (4, 15): 42, (4, 16): 43, (4, 17): 44, (4, 18): 45, (4, 19): 46, (4, 20): 47, (4, 21): 48,\n    (5, 7): 49, (5, 8): 50, (5, 9): 51, (5, 10): 52, (5, 11): 53, (5, 12): 54, (5, 13): 55, (5, 14): 56, (5, 15): 57, (5, 16): 58, (5, 17): 59, (5, 18): 60, (5, 19): 61, (5, 20): 62, (5, 21): 63,\n    (6, 6): 64, (6, 7): 65, (6, 8): 66, (6, 9): 67, (6, 10): 68, (6, 11): 69, (6, 12): 70, (6, 13): 71, (6, 14): 72, (6, 15): 73, (6, 16): 74, (6, 17): 75, (6, 18): 76, (6, 19): 77, (6, 20): 78, (6, 21): 79,\n    (7, 6): 80, (7, 7): 81, (7, 8): 82, (7, 9): 83, (7, 10): 84, (7, 11): 85, (7, 12): 86, (7, 13): 87, (7, 14): 88, (7, 15): 89, (7, 16): 90, (7, 17): 91, (7, 18): 92, (7, 19): 93, (7, 20): 94, (7, 21): 95,\n    (8, 5): 96, (8, 6): 97, (8, 7): 98, (8, 8): 99, (8, 9): 100, (8, 10): 101, (8, 11): 102, (8, 12): 103, (8, 13): 104, (8, 14): 105, (8, 15): 106, (8, 16): 107, (8, 17): 108, (8, 18): 109, (8, 19): 110, (8, 20): 111, (8, 21): 112,\n    (9, 4): 113, (9, 5): 114, (9, 6): 115, (9, 7): 116, (9, 8): 117, (9, 9): 118, (9, 10): 119, (9, 11): 120, (9, 12): 121, (9, 13): 122, (9, 14): 123, (9, 15): 124, (9, 16): 125, (9, 17): 126, (9, 18): 127, (9, 19): 128, (9, 20): 129, (9, 21): 130,\n    (10, 3): 131, (10, 4): 132, (10, 5): 133, (10, 6): 134, (10, 7): 135, (10, 8): 136, (10, 9): 137, (10, 10): 138, (10, 11): 139, (10, 12): 140, (10, 13): 141, (10, 14): 142, (10, 15): 143, (10, 16): 144, (10, 17): 145, (10, 18): 146, (10, 19): 147, (10, 20): 148,\n    (11, 3): 149, (11, 4): 150, (11, 5): 151, (11, 6): 152, (11, 7): 153, (11, 8): 153, (11, 9): 155, (11, 10): 156, (11, 11): 157, (11, 12): 158, (11, 13): 159, (11, 14): 160, (11, 15): 161, (11, 16): 162, (11, 17): 163, (11, 18): 164, (11, 19): 165, (11, 20): 166,\n    (12, 2): 167, (12, 3): 168, (12, 4): 169, (12, 5): 170, (12, 6): 171, (12, 7): 172, (12, 8): 173, (12, 9): 174, (12, 10): 175, (12, 11): 176, (12, 12): 177, (12, 13): 178, (12, 14): 179, (12, 15): 180, (12, 16): 181, (12, 17): 182, (12, 18): 183, (12, 19): 184, (12, 20): 185,\n    (13, 1): 186, (13, 2): 187, (13, 3): 188, (13, 4): 189, (13, 5): 190, (13, 6): 191, (13, 7): 192, (13, 8): 193, (13, 9): 194, (13, 10): 195, (13, 11): 196, (13, 12): 197, (13, 13): 198, (13, 14): 199, (13, 15): 200, (13, 16): 201, (13, 17): 202, (13, 18): 203, (13, 19): 204, (13, 20): 205,\n    (14, 1): 206, (14, 2): 207, (14, 3): 208, (14, 4): 209, (14, 5): 210, (14, 6): 211, (14, 7): 212, (14, 8): 213, (14, 9): 214, (14, 10): 215, (14, 11): 216, (14, 12): 217, (14, 13): 218, (14, 14): 219, (14, 15): 220, (14, 16): 221, (14, 17): 222, (14, 18): 223, (14, 19): 224,\n    (15, 0): 225, (15, 1): 226, (15, 2): 227, (15, 3): 228, (15, 4): 229, (15, 5): 230, (15, 6): 231, (15, 7): 232, (15, 8): 233, (15, 9): 234, (15, 10): 235, (15, 11): 236, (15, 12): 237, (15, 13): 238, (15, 14): 239, (15, 15): 240, (15, 16): 241, (15, 17): 242, (15, 18): 243, (15, 19): 244,\n    (16, 0): 245, (16, 1): 246, (16, 2): 247, (16, 3): 248, (16, 4): 249, (16, 5): 250, (16, 6): 251, (16, 7): 252, (16, 8): 253, (16, 9): 254, (16, 10): 255, (16, 11): 256, (16, 12): 257, (16, 13): 258, (16, 14): 259, (16, 15): 260, (16, 16): 261, (16, 17): 262, (16, 18): 263, (16, 19): 264,\n    (17, 0): 265, (17, 1): 266, (17, 2): 267, (17, 3): 268, (17, 4): 269, (17, 5): 270, (17, 6): 271, (17, 7): 272, (17, 8): 273, (17, 9): 274, (17, 10): 275, (17, 11): 276, (17, 12): 277, (17, 13): 278, (17, 14): 279, (17, 15): 280, (17, 16): 281, (17, 17): 282, (17, 18): 283,\n    (18, 0): 284, (18, 1): 285, (18, 2): 286, (18, 3): 287, (18, 4): 288, (18, 5): 289, (18, 6): 290, (18, 7): 291, (18, 8): 292, (18, 9): 293, (18, 10): 294, (18, 11): 295, (18, 12): 296, (18, 13): 297, (18, 14): 298, (18, 15): 299, (18, 16): 300, (18, 17): 301, (18, 18): 302,\n    (19, 2): 303, (19, 3): 304, (19, 4): 305, (19, 5): 306, (19, 6): 307, (19, 7): 308, (19, 8): 309, (19, 9): 310, (19, 10): 311, (19, 11): 312\n}\nfor (a_idx, b_idx), bin_idx in ab_idx2bin_idx.items():\n    a = -90 + 10 * a_idx\n    b = -110 + 10 * b_idx\n    bin_centers[bin_idx] = torch.tensor([a, b]) ","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-13T03:26:26.502694Z","iopub.execute_input":"2025-05-13T03:26:26.503357Z","iopub.status.idle":"2025-05-13T03:26:26.578129Z","shell.execute_reply.started":"2025-05-13T03:26:26.503333Z","shell.execute_reply":"2025-05-13T03:26:26.577401Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"class Colorization(nn.Module):\n    def __init__(self):\n        super(Colorization, self).__init__()\n\n        self.model = nn.Sequential(\n            nn.Conv2d(in_channels=1, out_channels=64, kernel_size=3, stride=1, padding=1),\n            nn.ReLU(inplace=True),\n            nn.BatchNorm2d(64),\n            \n            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=2, padding=1),\n            nn.ReLU(inplace=True),\n            nn.BatchNorm2d(128),\n            \n            nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=2, padding=1),\n            nn.ReLU(inplace=True),\n            nn.BatchNorm2d(256),\n            \n            nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, stride=2, padding=1),\n            nn.ReLU(inplace=True),\n            nn.BatchNorm2d(512),\n            \n            nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=2, dilation=2),\n            nn.ReLU(inplace=True),\n            nn.BatchNorm2d(512),\n            \n            nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=2, dilation=2),\n            nn.ReLU(inplace=True),\n            nn.BatchNorm2d(512),\n            \n            nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1),\n            nn.ReLU(inplace=True),\n            nn.BatchNorm2d(512),\n            \n            nn.ConvTranspose2d(in_channels=512, out_channels=256, kernel_size=4, stride=2, padding=1),\n            nn.ReLU(inplace=True),\n            nn.BatchNorm2d(256),\n            \n            nn.Conv2d(in_channels=256, out_channels=313, kernel_size=1, stride=1, padding=0),\n            nn.ReLU(inplace=True),\n            nn.BatchNorm2d(313)\n        )\n\n    def forward(self, x):\n        return self.model(x)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-13T03:26:30.813514Z","iopub.execute_input":"2025-05-13T03:26:30.814017Z","iopub.status.idle":"2025-05-13T03:26:30.821214Z","shell.execute_reply.started":"2025-05-13T03:26:30.813995Z","shell.execute_reply":"2025-05-13T03:26:30.820433Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"print('loading bin probs')\nbin_probs = torch.load('/kaggle/input/bin-probabilities/bin_probs_large.pt',weights_only=True)\nprint(bin_probs.shape)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-13T03:26:31.183532Z","iopub.execute_input":"2025-05-13T03:26:31.184104Z","iopub.status.idle":"2025-05-13T03:26:31.198366Z","shell.execute_reply.started":"2025-05-13T03:26:31.184086Z","shell.execute_reply":"2025-05-13T03:26:31.197855Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"## Bin Probabilities\np = (bin_probs*1000 +2)/(bin_probs*1000 +2).sum()\nlambda_val = 0.5\nQ = 313\np = p + 1e-8  # avoid division by zero\nw = 1.0 / ((1 - lambda_val) * p + (lambda_val / Q))\nw = w / (w * p).sum()  # normalize so E[w] = 1\nprint(\"exp_w \",sum(w*p)/sum(p))\nprint(torch.min(w), torch.max(w))  # Check for extreme values in weights","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-13T03:26:33.662054Z","iopub.execute_input":"2025-05-13T03:26:33.662364Z","iopub.status.idle":"2025-05-13T03:26:33.733011Z","shell.execute_reply.started":"2025-05-13T03:26:33.662341Z","shell.execute_reply":"2025-05-13T03:26:33.732272Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import os\nfrom torch.utils.data import Dataset, DataLoader\nfrom torchvision import transforms\n\nclass ColorizationDataset(Dataset):\n    def __init__(self, root_dir, bin_centers, HW=(256, 256)):\n        self.root_dir = root_dir\n        self.image_paths = []\n        self.HW = HW\n        self.bin_centers = bin_centers\n        \n        dirs = ['00000', '00001', '00002', '00003', '00004', '00005', '00006', '00007', '00008', '00009']\n        for class_folder in dirs[:10]:\n            class_path = os.path.join(root_dir, class_folder)\n            for _, _, files in os.walk(class_path):\n                for file in files:\n                    self.image_paths.append(os.path.join(class_path, file))\n            print(len(self.image_paths))\n        \n    def __len__(self):\n        return len(self.image_paths)\n\n    def __getitem__(self, idx):\n        img_path = self.image_paths[idx]\n        \n        img_rgb_orig = load_img(img_path)              # your utility function\n        img_rgb_rs = resize_img(img_rgb_orig, self.HW)  # your utility function\n\n        tens_orig_l, tens_rs_l, tens_rs_ab = preprocess_img(img_rgb_rs, HW=self.HW)  # modified to return ab too\n\n        # Compute target z\n        ab_image_down = F.interpolate(tens_rs_ab.unsqueeze(0), size=(64, 64), mode='bilinear', align_corners=False).squeeze(0)\n        z = compute_soft_encoding(ab_image_down, self.bin_centers)  # shape (313, 64, 64)\n\n        return tens_rs_l.squeeze(0), z\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-13T03:28:03.462497Z","iopub.execute_input":"2025-05-13T03:28:03.462796Z","iopub.status.idle":"2025-05-13T03:28:03.469275Z","shell.execute_reply.started":"2025-05-13T03:28:03.462774Z","shell.execute_reply":"2025-05-13T03:28:03.468566Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Dataset instance\nprint('making dataset')\ntrain_dataset = ColorizationDataset(\n    root_dir='/kaggle/input/imagenet1k0',   # change to your train folder\n    bin_centers=bin_centers,\n    HW=(256, 256)\n)\nprint('making dataloader')\n# DataLoader\ntrain_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, num_workers=4)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-13T03:28:05.542227Z","iopub.execute_input":"2025-05-13T03:28:05.542761Z","iopub.status.idle":"2025-05-13T03:28:21.470459Z","shell.execute_reply.started":"2025-05-13T03:28:05.542738Z","shell.execute_reply":"2025-05-13T03:28:21.469714Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import torch.nn as nn\nimport torch.optim as optim\n\n# Model\nmodel = Colorization()\nmodel.load_state_dict(torch.load('/kaggle/input/bin-probabilities/colorization_model_20epochs.pth'))\nmodel = model.cuda()\n\n# Optimizer\noptimizer = optim.Adam(model.parameters(), lr=1e-2)\n\n# Loss\ndef colorization_loss(z_hat, z, w):\n    # z_hat: (B, 313, 64, 64)\n    # z: (B, 313, 64, 64)\n    weights_per_pixel = (z * w[:, None, None]).sum(dim=1)  # (B, 64, 64)\n    ce_loss = -(z * torch.log(z_hat + 1e-8)).sum(dim=1)    # (B, 64, 64)\n    weighted_loss = (weights_per_pixel * ce_loss).mean()\n    return weighted_loss\n\nprint('start training...')\n# Training\nnum_epochs = 50\n\nfor epoch in range(num_epochs):\n    model.train()\n    running_loss = 0.0\n    print(len(train_loader))\n    for batch_idx, (tens_rs_l, z) in enumerate(train_loader):\n        tens_rs_l = tens_rs_l.cuda()        # (B, 1, 256, 256)\n        z = z.cuda()                        # (B, 313, 64, 64)\n\n        optimizer.zero_grad()\n        z_hat = model(tens_rs_l)             # (B, 313, 64, 64)\n        z_hat = torch.softmax(z_hat, dim=1)  # Softmax over class dimension\n\n        loss = colorization_loss(z_hat, z, w.cuda())\n        loss.backward()\n        optimizer.step()\n\n        running_loss += loss.item()\n        if batch_idx%10==0:\n            print(f\"{batch_idx} has loss {loss.item()}\")\n\n    avg_loss = running_loss / len(train_loader)\n    print(f\"\\n\\nEpoch [{epoch+1}/{num_epochs}], Loss: {avg_loss:.6f}\\n\")\n\nprint('saving model')\ntorch.save(model.state_dict(), '/kaggle/working/colorization_model_40kaggle.pth',)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-13T03:35:27.112203Z","iopub.execute_input":"2025-05-13T03:35:27.112892Z","iopub.status.idle":"2025-05-13T03:36:11.363799Z","shell.execute_reply.started":"2025-05-13T03:35:27.112866Z","shell.execute_reply":"2025-05-13T03:36:11.362731Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"print('saving model again')\ntorch.save(model.state_dict(), '/kaggle/working/colorization_model_40kaggle_same.pth')","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-11T03:32:53.631884Z","iopub.execute_input":"2025-05-11T03:32:53.632478Z","iopub.status.idle":"2025-05-11T03:32:53.733748Z","shell.execute_reply.started":"2025-05-11T03:32:53.632447Z","shell.execute_reply":"2025-05-11T03:32:53.732949Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## WORKING WITH THE IMAGES ","metadata":{}},{"cell_type":"code","source":"from PIL import Image\nimport numpy as np\nfrom skimage import color\nfrom skimage.color import lab2rgb, rgb2lab\nimport torch\nimport os\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom IPython import embed\nimport matplotlib.pyplot as plt","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-10T16:08:41.727636Z","iopub.execute_input":"2025-05-10T16:08:41.727975Z","iopub.status.idle":"2025-05-10T16:08:47.421262Z","shell.execute_reply.started":"2025-05-10T16:08:41.72794Z","shell.execute_reply":"2025-05-10T16:08:47.420272Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# UTILITY FUNCTIONS\n\ndef load_img(img_path):\n\tout_np = np.asarray(Image.open(img_path))\n\tif(out_np.ndim==2):\n\t\tout_np = np.tile(out_np[:,:,None],3)\n\treturn out_np\n\ndef resize_img(img, HW=(256,256), resample=3):\n\treturn np.asarray(Image.fromarray(img).resize((HW[1],HW[0]), resample=resample))\n\ndef preprocess_img(img_rgb_orig, HW=(256,256), resample=3):\n    # return original size L and resized L as torch Tensors\n    img_rgb_rs = resize_img(img_rgb_orig, HW=HW, resample=resample)\n    \n    img_lab_orig = color.rgb2lab(img_rgb_orig)\n    img_lab_rs = color.rgb2lab(img_rgb_rs)\n\n    img_l_orig = img_lab_orig[:, :, 0]\n    img_l_rs = img_lab_rs[:, :, 0]\n    img_ab_rs = img_lab_rs[:, :, 1:3]\n\n    tens_orig_l = torch.Tensor(img_l_orig)[None, None, :, :]\n    tens_rs_l = torch.Tensor(img_l_rs)[None, None, :, :]\n    tens_rs_ab = torch.Tensor(img_ab_rs).permute(2, 0, 1)  # (2,H,W)\n\n    return (tens_orig_l, tens_rs_l, tens_rs_ab)\n\ndef postprocess_tens(tens_orig_l, out_ab, mode='bilinear'):\n\t# tens_orig_l \t1 x 1 x H_orig x W_orig\n\t# out_ab \t\t1 x 2 x H x W\n\n\tHW_orig = tens_orig_l.shape[2:]\n\tHW = out_ab.shape[2:]\n\n\t# call resize function if needed\n\tif(HW_orig[0]!=HW[0] or HW_orig[1]!=HW[1]):\n\t\tout_ab_orig = F.interpolate(out_ab, size=HW_orig, mode='bilinear')\n\telse:\n\t\tout_ab_orig = out_ab\n\n\tout_lab_orig = torch.cat((tens_orig_l, out_ab_orig), dim=1)\n\treturn color.lab2rgb(out_lab_orig.data.cpu().numpy()[0,...].transpose((1,2,0)))\n\ndef compute_soft_encoding(ab_image, bin_centers, sigma=5.0):\n    \"\"\"\n    ab_image: Tensor of shape [2, H, W] (ground truth ab channels)\n    bin_centers: Tensor of shape [313, 2] (predefined bin centers)\n    sigma: Soft-encoding standard deviation\n    Returns:\n        soft_encoding: Tensor of shape [313, H, W]\n    \"\"\"\n    C, H, W = ab_image.shape\n    ab_flat = ab_image.view(2, -1).T  # [H*W, 2]\n\n    # Compute L2 distance from each pixel to each bin center\n    dist = torch.cdist(ab_flat.unsqueeze(0), bin_centers.unsqueeze(0)).squeeze(0)  # [H*W, 313]\n\n    # Apply softmax with negative distances to get soft-assignment\n    weights = torch.exp(- (dist ** 2) / (2 * sigma ** 2))  # Gaussian kernel\n    weights = weights / weights.sum(dim=1, keepdim=True)  # Normalize to sum to 1\n    soft_encoding = weights.T.view(313, H, W)\n    return soft_encoding","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-10T16:09:43.301607Z","iopub.execute_input":"2025-05-10T16:09:43.301956Z","iopub.status.idle":"2025-05-10T16:09:43.312822Z","shell.execute_reply.started":"2025-05-10T16:09:43.301899Z","shell.execute_reply":"2025-05-10T16:09:43.311866Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"\n'''img_path = '/kaggle/input/imagenet-object-localization-challenge/ILSVRC/Data/CLS-LOC/train/n01443537/n01443537_10014.JPEG'\n\nimg_rgb_orig = load_img(img_path)\nimg_rgb_rs = resize_img(img_rgb_orig, HW=(256, 256))\ntens_orig_l, tens_rs_l,tens_rs_ab = preprocess_img(img_rgb_rs, HW=(256, 256))\n\nplt.figure(figsize=(3,3))\nplt.title(\"Original Image\")\nplt.imshow(img_rgb_orig)\nplt.show()\n\nprint(\"Original image shape:\", img_rgb_orig.shape)\nprint(\"Resized image shape :\", img_rgb_rs.shape)\n\nplt.figure(figsize=(3,3))\nplt.title(\"Resized Image (256x256)\")\nplt.imshow(img_rgb_rs)\nplt.show()\n\nplt.figure(figsize=(3,3))\nplt.title(\"Resized L Channel (Lightness)\")\nplt.imshow(tens_rs_l[0,0,:,:], cmap='gray')\nplt.show()\n'''","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-10T16:09:45.957516Z","iopub.execute_input":"2025-05-10T16:09:45.957846Z","iopub.status.idle":"2025-05-10T16:09:46.699964Z","shell.execute_reply.started":"2025-05-10T16:09:45.95782Z","shell.execute_reply":"2025-05-10T16:09:46.698977Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## ARCHITECTURE","metadata":{}},{"cell_type":"markdown","source":"![image.png](attachment:a888abc6-d655-4077-99de-41426982147b.png)","metadata":{},"attachments":{"a888abc6-d655-4077-99de-41426982147b.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"```txt\nInput (1x256x256)\n    ↓ Conv1 (stride 2)\n64x128x128\n    ↓ Conv2 (stride 2)\n128x64x64\n    ↓ Conv3 (stride 2)\n256x32x32\n    ↓ Conv4\n512x32x32\n    ↓ Conv5 (dilated)\n512x32x32\n    ↓ Conv6 (dilated)\n512x32x32\n    ↓ Conv7\n512x32x32\n    ↓ Conv8 (transpose conv stride 2)\n256x64x64\n    ↓ Conv9 (1x1 conv)\n313x64x64\n    ↓ Softmax\nDistribution (64x64x313)\n    ↓ Annealed Mean\nPredicted (a,b) at 64x64\n    ↓ Bilinear Upsampling\n(a,b) at 224x224\n    ↓ Concatenate with L\nLab image (224x224)\n```","metadata":{}},{"cell_type":"code","source":"class Colorization(nn.Module):\n    def __init__(self):\n        super(Colorization, self).__init__()\n\n        self.model = nn.Sequential(\n            nn.Conv2d(in_channels=1, out_channels=64, kernel_size=3, stride=1, padding=1),\n            nn.ReLU(inplace=True),\n            nn.BatchNorm2d(64),\n            \n            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=2, padding=1),\n            nn.ReLU(inplace=True),\n            nn.BatchNorm2d(128),\n            \n            nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=2, padding=1),\n            nn.ReLU(inplace=True),\n            nn.BatchNorm2d(256),\n            \n            nn.Conv2d(in_channels=256, out_channels=512, kernel_size=3, stride=2, padding=1),\n            nn.ReLU(inplace=True),\n            nn.BatchNorm2d(512),\n            \n            nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=2, dilation=2),\n            nn.ReLU(inplace=True),\n            nn.BatchNorm2d(512),\n            \n            nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=2, dilation=2),\n            nn.ReLU(inplace=True),\n            nn.BatchNorm2d(512),\n            \n            nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1, padding=1),\n            nn.ReLU(inplace=True),\n            nn.BatchNorm2d(512),\n            \n            nn.ConvTranspose2d(in_channels=512, out_channels=256, kernel_size=4, stride=2, padding=1),\n            nn.ReLU(inplace=True),\n            nn.BatchNorm2d(256),\n            \n            nn.Conv2d(in_channels=256, out_channels=313, kernel_size=1, stride=1, padding=0),\n            nn.ReLU(inplace=True),\n            nn.BatchNorm2d(313)\n        )\n\n    def forward(self, x):\n        return self.model(x)\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-10T16:09:55.357525Z","iopub.execute_input":"2025-05-10T16:09:55.357845Z","iopub.status.idle":"2025-05-10T16:09:55.367844Z","shell.execute_reply.started":"2025-05-10T16:09:55.357821Z","shell.execute_reply":"2025-05-10T16:09:55.366983Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"#print(tens_rs_l.shape)\n#ConvModule = Colorization()\n#z = ConvModule(tens_rs_l)\n#print(z.shape)","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-10T16:09:59.131141Z","iopub.execute_input":"2025-05-10T16:09:59.131426Z","iopub.status.idle":"2025-05-10T16:09:59.135332Z","shell.execute_reply.started":"2025-05-10T16:09:59.131406Z","shell.execute_reply":"2025-05-10T16:09:59.134497Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"## Bin centers\n'''\nbin_centers = torch.zeros(313, 2)\n\nab_idx2bin_idx = {\n    (0, 16): 0, (0, 17): 1, (0, 18): 2, (0, 19): 3, (0, 20): 4,\n    (1, 13): 5, (1, 14): 6, (1, 15): 7, (1, 16): 8, (1, 17): 9, (1, 18): 10, (1, 19): 11, (1, 20): 12,\n    (2, 11): 13, (2, 12): 14, (2, 13): 15, (2, 14): 16, (2, 15): 17, (2, 16): 18, (2, 17): 19, (2, 18): 20, (2, 19): 21, (2, 20): 22,\n    (3, 9): 23, (3, 10): 24, (3, 11): 25, (3, 12): 26, (3, 13): 27, (3, 14): 28, (3, 15): 29, (3, 16): 30, (3, 17): 31, (3, 18): 32, (3, 19): 33, (3, 20): 34,\n    (4, 8): 35, (4, 9): 36, (4, 10): 37, (4, 11): 38, (4, 12): 39, (4, 13): 40, (4, 14): 41, (4, 15): 42, (4, 16): 43, (4, 17): 44, (4, 18): 45, (4, 19): 46, (4, 20): 47, (4, 21): 48,\n    (5, 7): 49, (5, 8): 50, (5, 9): 51, (5, 10): 52, (5, 11): 53, (5, 12): 54, (5, 13): 55, (5, 14): 56, (5, 15): 57, (5, 16): 58, (5, 17): 59, (5, 18): 60, (5, 19): 61, (5, 20): 62, (5, 21): 63,\n    (6, 6): 64, (6, 7): 65, (6, 8): 66, (6, 9): 67, (6, 10): 68, (6, 11): 69, (6, 12): 70, (6, 13): 71, (6, 14): 72, (6, 15): 73, (6, 16): 74, (6, 17): 75, (6, 18): 76, (6, 19): 77, (6, 20): 78, (6, 21): 79,\n    (7, 6): 80, (7, 7): 81, (7, 8): 82, (7, 9): 83, (7, 10): 84, (7, 11): 85, (7, 12): 86, (7, 13): 87, (7, 14): 88, (7, 15): 89, (7, 16): 90, (7, 17): 91, (7, 18): 92, (7, 19): 93, (7, 20): 94, (7, 21): 95,\n    (8, 5): 96, (8, 6): 97, (8, 7): 98, (8, 8): 99, (8, 9): 100, (8, 10): 101, (8, 11): 102, (8, 12): 103, (8, 13): 104, (8, 14): 105, (8, 15): 106, (8, 16): 107, (8, 17): 108, (8, 18): 109, (8, 19): 110, (8, 20): 111, (8, 21): 112,\n    (9, 4): 113, (9, 5): 114, (9, 6): 115, (9, 7): 116, (9, 8): 117, (9, 9): 118, (9, 10): 119, (9, 11): 120, (9, 12): 121, (9, 13): 122, (9, 14): 123, (9, 15): 124, (9, 16): 125, (9, 17): 126, (9, 18): 127, (9, 19): 128, (9, 20): 129, (9, 21): 130,\n    (10, 3): 131, (10, 4): 132, (10, 5): 133, (10, 6): 134, (10, 7): 135, (10, 8): 136, (10, 9): 137, (10, 10): 138, (10, 11): 139, (10, 12): 140, (10, 13): 141, (10, 14): 142, (10, 15): 143, (10, 16): 144, (10, 17): 145, (10, 18): 146, (10, 19): 147, (10, 20): 148,\n    (11, 3): 149, (11, 4): 150, (11, 5): 151, (11, 6): 152, (11, 7): 153, (11, 8): 153, (11, 9): 155, (11, 10): 156, (11, 11): 157, (11, 12): 158, (11, 13): 159, (11, 14): 160, (11, 15): 161, (11, 16): 162, (11, 17): 163, (11, 18): 164, (11, 19): 165, (11, 20): 166,\n    (12, 2): 167, (12, 3): 168, (12, 4): 169, (12, 5): 170, (12, 6): 171, (12, 7): 172, (12, 8): 173, (12, 9): 174, (12, 10): 175, (12, 11): 176, (12, 12): 177, (12, 13): 178, (12, 14): 179, (12, 15): 180, (12, 16): 181, (12, 17): 182, (12, 18): 183, (12, 19): 184, (12, 20): 185,\n    (13, 1): 186, (13, 2): 187, (13, 3): 188, (13, 4): 189, (13, 5): 190, (13, 6): 191, (13, 7): 192, (13, 8): 193, (13, 9): 194, (13, 10): 195, (13, 11): 196, (13, 12): 197, (13, 13): 198, (13, 14): 199, (13, 15): 200, (13, 16): 201, (13, 17): 202, (13, 18): 203, (13, 19): 204, (13, 20): 205,\n    (14, 1): 206, (14, 2): 207, (14, 3): 208, (14, 4): 209, (14, 5): 210, (14, 6): 211, (14, 7): 212, (14, 8): 213, (14, 9): 214, (14, 10): 215, (14, 11): 216, (14, 12): 217, (14, 13): 218, (14, 14): 219, (14, 15): 220, (14, 16): 221, (14, 17): 222, (14, 18): 223, (14, 19): 224,\n    (15, 0): 225, (15, 1): 226, (15, 2): 227, (15, 3): 228, (15, 4): 229, (15, 5): 230, (15, 6): 231, (15, 7): 232, (15, 8): 233, (15, 9): 234, (15, 10): 235, (15, 11): 236, (15, 12): 237, (15, 13): 238, (15, 14): 239, (15, 15): 240, (15, 16): 241, (15, 17): 242, (15, 18): 243, (15, 19): 244,\n    (16, 0): 245, (16, 1): 246, (16, 2): 247, (16, 3): 248, (16, 4): 249, (16, 5): 250, (16, 6): 251, (16, 7): 252, (16, 8): 253, (16, 9): 254, (16, 10): 255, (16, 11): 256, (16, 12): 257, (16, 13): 258, (16, 14): 259, (16, 15): 260, (16, 16): 261, (16, 17): 262, (16, 18): 263, (16, 19): 264,\n    (17, 0): 265, (17, 1): 266, (17, 2): 267, (17, 3): 268, (17, 4): 269, (17, 5): 270, (17, 6): 271, (17, 7): 272, (17, 8): 273, (17, 9): 274, (17, 10): 275, (17, 11): 276, (17, 12): 277, (17, 13): 278, (17, 14): 279, (17, 15): 280, (17, 16): 281, (17, 17): 282, (17, 18): 283,\n    (18, 0): 284, (18, 1): 285, (18, 2): 286, (18, 3): 287, (18, 4): 288, (18, 5): 289, (18, 6): 290, (18, 7): 291, (18, 8): 292, (18, 9): 293, (18, 10): 294, (18, 11): 295, (18, 12): 296, (18, 13): 297, (18, 14): 298, (18, 15): 299, (18, 16): 300, (18, 17): 301, (18, 18): 302,\n    (19, 2): 303, (19, 3): 304, (19, 4): 305, (19, 5): 306, (19, 6): 307, (19, 7): 308, (19, 8): 309, (19, 9): 310, (19, 10): 311, (19, 11): 312\n}\nfor (a_idx, b_idx), bin_idx in ab_idx2bin_idx.items():\n    a = -90 + 10 * a_idx\n    b = -110 + 10 * b_idx\n    bin_centers[bin_idx] = torch.tensor([a, b]) \n    '''","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-10T16:09:59.531226Z","iopub.execute_input":"2025-05-10T16:09:59.531516Z","iopub.status.idle":"2025-05-10T16:09:59.573157Z","shell.execute_reply.started":"2025-05-10T16:09:59.531488Z","shell.execute_reply":"2025-05-10T16:09:59.572165Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def compute_soft_encoding(ab_image, bin_centers, sigma=5.0):\n    \"\"\"\n    ab_image: Tensor of shape [2, H, W] (ground truth ab channels)\n    bin_centers: Tensor of shape [313, 2] (predefined bin centers)\n    sigma: Soft-encoding standard deviation\n    Returns:\n        soft_encoding: Tensor of shape [313, H, W]\n    \"\"\"\n    C, H, W = ab_image.shape\n    ab_flat = ab_image.view(2, -1).T  # [H*W, 2]\n\n    # Compute L2 distance from each pixel to each bin center\n    dist = torch.cdist(ab_flat.unsqueeze(0), bin_centers.unsqueeze(0)).squeeze(0)  # [H*W, 313]\n\n    # Apply softmax with negative distances to get soft-assignment\n    weights = torch.exp(- (dist ** 2) / (2 * sigma ** 2))  # Gaussian kernel\n    weights = weights / weights.sum(dim=1, keepdim=True)  # Normalize to sum to 1\n    soft_encoding = weights.T.view(313, H, W)\n    return soft_encoding\n'''\nab_image_down = F.interpolate(tens_rs_ab.unsqueeze(0), size=(64, 64), mode='bilinear', align_corners=False).squeeze(0)\ntens_rs_l_down = F.interpolate(tens_rs_l, size=(64, 64), mode='bilinear', align_corners=False).squeeze(0)\nsoft_y = compute_soft_encoding(ab_image_down, bin_centers)\n\nprint(soft_y.shape)\n\nlab_image = torch.cat([tens_rs_l_down, ab_image_down], dim=0).cpu().numpy()  # [3, H, W]\nlab_image = np.transpose(lab_image, (1, 2, 0))  # [H, W, 3]\nrgb_image = lab2rgb(lab_image)\nplt.figure(figsize=(4, 4))\nplt.imshow(rgb_image)\nplt.title('RGB from tens_rs_l and ab_image_down')\nplt.show()\n'''","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-10T16:10:05.143083Z","iopub.execute_input":"2025-05-10T16:10:05.143414Z","iopub.status.idle":"2025-05-10T16:10:05.423039Z","shell.execute_reply.started":"2025-05-10T16:10:05.143392Z","shell.execute_reply":"2025-05-10T16:10:05.422199Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"'''\nbin_counts = torch.ones(313)\n\npath = '/kaggle/input/imagenet-object-localization-challenge/ILSVRC/Data/CLS-LOC/train'\n\nfor root, dirs, _ in os.walk(path):\n    break \ni = 0\nfor class_folder in dirs:\n\n    #break \n    \n    class_folder = os.path.join(path, class_folder)\n    files = os.listdir(class_folder)[:120]  \n    i+=1\n    for img in files:\n        try:\n            img_path = os.path.join(class_folder, img)\n            img_rgb = load_img(img_path)\n            img_rgb_rs = resize_img(img_rgb, HW=(256, 256))\n            _, _, tens_rs_ab = preprocess_img(img_rgb_rs, HW=(256, 256))\n            ab_image_down = F.interpolate(tens_rs_ab.unsqueeze(0), size=(64, 64), mode='bilinear', align_corners=False).squeeze(0)\n            ab_flat = ab_image_down.view(2, -1).T  # [4096, 2]\n            dists = torch.cdist(ab_flat.float().unsqueeze(0), bin_centers.float().unsqueeze(0)).squeeze(0)  # [4096, 313]\n            hard_indices = torch.argmin(dists, dim=1)  # [4096]\n            bin_counts += torch.bincount(hard_indices, minlength=313).cpu()\n        except Exception as e:\n            print(f\"Error processing {img_path}: {e}\")\n    print(\"completed \",i ,end= \" \")\n    \nbin_probs = bin_counts / bin_counts.sum()\ntorch.save(bin_probs, 'bin_probs.pt')\n'''","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-10T04:46:21.133396Z","iopub.execute_input":"2025-05-10T04:46:21.134068Z","iopub.status.idle":"2025-05-10T05:49:26.667597Z","shell.execute_reply.started":"2025-05-10T04:46:21.134047Z","shell.execute_reply":"2025-05-10T05:49:26.666809Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"#bin_probs = (bin_counts + 10) / (bin_counts+10).sum()\n#torch.save(bin_probs, 'bin_probs_large.pt')\n#bin_probs = torch.load('bin_probs.pt')","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-10T16:11:30.047018Z","iopub.execute_input":"2025-05-10T16:11:30.04733Z","iopub.status.idle":"2025-05-10T16:11:30.066074Z","shell.execute_reply.started":"2025-05-10T16:11:30.047308Z","shell.execute_reply":"2025-05-10T16:11:30.064759Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"'''\nbin_probs = torch.load('bin_probs.pt')\nbin_probs_np = bin_probs.numpy()\nplt.figure(figsize=(16, 4))\nplt.bar(range(313), bin_probs_np, color='skyblue')\nplt.xlabel('Bin Index')\nplt.ylabel('Probability')\nplt.title('Color Bin Probabilities')\nplt.grid(True, axis='y', linestyle='--', alpha=0.7)\nplt.tight_layout()\nplt.show()\n\nbin_probs_new = (bin_probs*1000 +2)/(bin_probs*1000 +2).sum()\nbin_probs_new_np = bin_probs_new.numpy()\nplt.figure(figsize=(16, 4))\nplt.bar(range(313), bin_probs_new_np, color='skyblue')\nplt.xlabel('Bin Index')\nplt.ylabel('Probability')\nplt.title('Color Bin Probabilities')\nplt.grid(True, axis='y', linestyle='--', alpha=0.7)\nplt.tight_layout()\nplt.show()\n'''","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-10T05:50:45.133462Z","iopub.execute_input":"2025-05-10T05:50:45.134146Z","iopub.status.idle":"2025-05-10T05:50:46.253528Z","shell.execute_reply.started":"2025-05-10T05:50:45.134126Z","shell.execute_reply":"2025-05-10T05:50:46.252822Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"## Bin Probabilities\n'''\np = (bin_probs*1000 +2)/(bin_probs*1000 +2).sum()\nlambda_val = 0.5\nQ = 313\np = p + 1e-8  # avoid division by zero\nw = 1.0 / ((1 - lambda_val) * p + (lambda_val / Q))\nw = w / (w * p).sum()  # normalize so E[w] = 1\nprint(\"exp_w \",sum(w*p)/sum(p))\nprint(torch.min(w), torch.max(w))  # Check for extreme values in weights\n'''","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-10T05:51:03.053053Z","iopub.execute_input":"2025-05-10T05:51:03.053731Z","iopub.status.idle":"2025-05-10T05:51:03.063657Z","shell.execute_reply.started":"2025-05-10T05:51:03.053708Z","shell.execute_reply":"2025-05-10T05:51:03.063024Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"'''\nw_np = w.numpy()\nplt.figure(figsize=(16, 4))\nplt.bar(range(313), w_np, color='skyblue')\nplt.xlabel('Bin Index')\nplt.ylabel('Probability')\nplt.title('Color Bin Probabilities')\nplt.grid(True, axis='y', linestyle='--', alpha=0.7)\nplt.tight_layout()\nplt.show()\n'''","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-10T05:51:03.297517Z","iopub.execute_input":"2025-05-10T05:51:03.297783Z","iopub.status.idle":"2025-05-10T05:51:03.793302Z","shell.execute_reply.started":"2025-05-10T05:51:03.297765Z","shell.execute_reply":"2025-05-10T05:51:03.792546Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"'''\n## Image\nimg_path = '/kaggle/input/imagenet-object-localization-challenge/ILSVRC/Data/CLS-LOC/train/n01443537/n01443537_10014.JPEG'\nimg_rgb_orig = load_img(img_path)\nimg_rgb_rs = resize_img(img_rgb_orig, HW=(256, 256))\n_, tens_rs_l,tens_rs_ab = preprocess_img(img_rgb_rs, HW=(256, 256))\n\n## Convolve to get z hat\nprint(tens_rs_l.shape)\nConvModule = Colorization()\nz_hat = ConvModule(tens_rs_l)\nz_hat = torch.softmax(z_hat, dim=1)\nprint(z_hat.shape)\n\n## Compute target's z\nab_image_down = F.interpolate(tens_rs_ab.unsqueeze(0), size=(64, 64), mode='bilinear', align_corners=False).squeeze(0)\nz = compute_soft_encoding(ab_image_down, bin_centers).unsqueeze(0)\nprint(z.shape)\n\n## rebalane and loss\nweights_per_pixel = (z * w[:, None, None]).sum(dim=0) \nlog_probs = F.log_softmax(z_hat, dim=1)  # shape (B, 313, 64, 64)\nce_loss = -(z * log_probs).sum(dim=1)  # sum over classes -> shape (B, 64, 64)\n\nprint(ce_loss.mean())\nweighted_loss = (weights_per_pixel * ce_loss).mean()\nprint(weighted_loss)\n'''","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-10T05:51:12.678432Z","iopub.execute_input":"2025-05-10T05:51:12.679013Z","iopub.status.idle":"2025-05-10T05:51:12.952883Z","shell.execute_reply.started":"2025-05-10T05:51:12.678993Z","shell.execute_reply":"2025-05-10T05:51:12.952175Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-10T04:20:09.6736Z","iopub.execute_input":"2025-05-10T04:20:09.674278Z","iopub.status.idle":"2025-05-10T04:20:09.68615Z","shell.execute_reply.started":"2025-05-10T04:20:09.674255Z","shell.execute_reply":"2025-05-10T04:20:09.685424Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## TRAINING","metadata":{}},{"cell_type":"code","source":"'''\nimport os\nfrom torch.utils.data import Dataset, DataLoader\nfrom torchvision import transforms\n\nclass ColorizationDataset(Dataset):\n    def __init__(self, root_dir, bin_centers, HW=(256, 256)):\n        self.root_dir = root_dir\n        self.image_paths = []\n        self.HW = HW\n        self.bin_centers = bin_centers\n        \n        for subdir, dirs, files in os.walk(root_dir):\n            for file in files:\n                self.image_paths.append(os.path.join(subdir, file))\n                if len(self.image_paths)%10000 ==0:\n                    print(len( self.image_paths))\n                if len(self.image_paths)%100000 ==0:\n                    print('breaking...')\n                    break\n            if len(self.image_paths)>=100000:\n                print('breakin')\n                break\n        \n    def __len__(self):\n        return len(self.image_paths)\n\n    def __getitem__(self, idx):\n        img_path = self.image_paths[idx]\n        \n        img_rgb_orig = load_img(img_path)              # your utility function\n        img_rgb_rs = resize_img(img_rgb_orig, self.HW)  # your utility function\n\n        tens_orig_l, tens_rs_l, tens_rs_ab = preprocess_img(img_rgb_rs, HW=self.HW)  # modified to return ab too\n\n        # Compute target z\n        ab_image_down = F.interpolate(tens_rs_ab.unsqueeze(0), size=(64, 64), mode='bilinear', align_corners=False).squeeze(0)\n        z = compute_soft_encoding(ab_image_down, self.bin_centers)  # shape (313, 64, 64)\n\n        return tens_rs_l.squeeze(0), z\n'''","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-10T07:38:24.868351Z","iopub.execute_input":"2025-05-10T07:38:24.869072Z","iopub.status.idle":"2025-05-10T07:38:24.875901Z","shell.execute_reply.started":"2025-05-10T07:38:24.86905Z","shell.execute_reply":"2025-05-10T07:38:24.874963Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Dataset instance\n'''\ntrain_dataset = ColorizationDataset(\n    root_dir='/kaggle/input/imagenet-object-localization-challenge/ILSVRC/Data/CLS-LOC/train',   # change to your train folder\n    bin_centers=bin_centers,\n    HW=(256, 256)\n)\n\n# DataLoader\ntrain_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=4)\n'''","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-10T07:38:25.033559Z","iopub.execute_input":"2025-05-10T07:38:25.034112Z","iopub.status.idle":"2025-05-10T07:38:25.286873Z","shell.execute_reply.started":"2025-05-10T07:38:25.034092Z","shell.execute_reply":"2025-05-10T07:38:25.28611Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"'''\nimport torch.nn as nn\nimport torch.optim as optim\n\n# Model\nmodel = Colorization()  # your network\nmodel = model.cuda()    # move to GPU if available\n\n# Optimizer\noptimizer = optim.Adam(model.parameters(), lr=1e-4)\n\n# Loss\ndef colorization_loss(z_hat, z, w):\n    # z_hat: (B, 313, 64, 64)\n    # z: (B, 313, 64, 64)\n    weights_per_pixel = (z * w[:, None, None]).sum(dim=1)  # (B, 64, 64)\n    ce_loss = -(z * torch.log(z_hat + 1e-8)).sum(dim=1)    # (B, 64, 64)\n    weighted_loss = (weights_per_pixel * ce_loss).mean()\n    return weighted_loss\n\n# Training\nnum_epochs = 40\n\nfor epoch in range(num_epochs):\n    model.train()\n    running_loss = 0.0\n    print(len(train_loader))\n    for batch_idx, (tens_rs_l, z) in enumerate(train_loader):\n        print(batch_idx,end = \"  \")\n        tens_rs_l = tens_rs_l.cuda()        # (B, 1, 256, 256)\n        z = z.cuda()                        # (B, 313, 64, 64)\n\n        optimizer.zero_grad()\n        z_hat = model(tens_rs_l)             # (B, 313, 64, 64)\n        z_hat = torch.softmax(z_hat, dim=1)  # Softmax over class dimension\n\n        loss = colorization_loss(z_hat, z, w.cuda())\n        loss.backward()\n        optimizer.step()\n\n        running_loss += loss.item()\n\n    avg_loss = running_loss / len(train_loader)\n    print(f\"Epoch [{epoch+1}/{num_epochs}], Loss: {avg_loss:.6f}\")\n'''","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-10T07:44:07.548744Z","iopub.execute_input":"2025-05-10T07:44:07.549444Z","iopub.status.idle":"2025-05-10T11:06:08.949029Z","shell.execute_reply.started":"2025-05-10T07:44:07.549417Z","shell.execute_reply":"2025-05-10T11:06:08.945767Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Suppose your model is called 'model'\n#torch.save(model.state_dict(), 'colorization_model_1lakh.pth')","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-10T11:12:53.962765Z","iopub.execute_input":"2025-05-10T11:12:53.963269Z","iopub.status.idle":"2025-05-10T11:12:54.043828Z","shell.execute_reply.started":"2025-05-10T11:12:53.963244Z","shell.execute_reply":"2025-05-10T11:12:54.043261Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"'''\nimg_path = '/kaggle/input/imagenet-object-localization-challenge/ILSVRC/Data/CLS-LOC/train/n01440764/n01440764_10028.JPEG'\nimg_path = '/kaggle/input/imagenet-object-localization-challenge/ILSVRC/Data/CLS-LOC/train/n01440764/n01440764_10026.JPEG'\n\nimg_rgb_orig = load_img(img_path)\nimg_rgb_rs = resize_img(img_rgb_orig, HW=(256, 256))\n_, tens_rs_l,tens_rs_ab = preprocess_img(img_rgb_rs, HW=(256, 256))\n\n## Convolve to get z hat\nprint(tens_rs_l.shape)\n# Create the model architecture first\nmodel = Colorization()  # same model class\n# Load saved weights\nmodel.load_state_dict(torch.load('/kaggle/working/colorization_model_1lakh.pth', map_location='cuda',weights_only=True))  # use 'cuda' if you want\nmodel.eval()  # IMPORTANT: set to eval mode\n\nz_hat = model(tens_rs_l)\nz_hat = torch.softmax(z_hat, dim=1)\nprint(z_hat.shape)\n'''","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-11T03:33:50.831537Z","iopub.execute_input":"2025-05-11T03:33:50.832268Z","iopub.status.idle":"2025-05-11T03:33:51.191181Z","shell.execute_reply.started":"2025-05-11T03:33:50.832242Z","shell.execute_reply":"2025-05-11T03:33:51.190191Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"'''\ntens_rs_l = tens_rs_l\n\n# Forward\nz_hat = model(tens_rs_l)\nz_hat = torch.softmax(z_hat, dim=1)\n\n# Temperature sharpening\nT = 0.38\nz_hat_T = torch.pow(z_hat, 1.0 / T)\nz_hat_T = z_hat_T / z_hat_T.sum(dim=1, keepdim=True)\npred_ab = torch.einsum('ncxy,cd->ndxy', z_hat_T.cuda(), bin_centers.cuda())\n\n# Upsample\npred_ab_upsampled = F.interpolate(pred_ab, size=(256, 256), mode='bilinear', align_corners=False)\n\n# LAB fusion\nout_lab = torch.cat((tens_rs_l.cuda(), pred_ab_upsampled.cuda()), dim=1)\n\n# LAB -> RGB\nout_rgb = postprocess_tens(tens_rs_l.cuda(), pred_ab_upsampled.cuda())\n'''","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-11T03:33:54.021648Z","iopub.execute_input":"2025-05-11T03:33:54.022141Z","iopub.status.idle":"2025-05-11T03:33:54.270274Z","shell.execute_reply.started":"2025-05-11T03:33:54.022116Z","shell.execute_reply":"2025-05-11T03:33:54.269696Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"'''\nplt.figure(figsize=(15,5))\n\nplt.subplot(1,3,1)\nplt.title('Input L-channel')\nplt.imshow(tens_rs_l.cpu().numpy()[0,0], cmap='gray')\n\n# Show predicted color image\nplt.subplot(1,3,2)\nplt.title('Predicted colorized')\nplt.imshow(out_rgb)\n\n# Show ground truth RGB\nplt.subplot(1,3,3)\nplt.title('Ground Truth RGB')\nplt.imshow(img_rgb_rs)\n\nplt.show()\n'''","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-11T03:33:58.586717Z","iopub.execute_input":"2025-05-11T03:33:58.586997Z","iopub.status.idle":"2025-05-11T03:33:59.163322Z","shell.execute_reply.started":"2025-05-11T03:33:58.586978Z","shell.execute_reply":"2025-05-11T03:33:59.162616Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-11T16:09:29.651329Z","iopub.execute_input":"2025-05-11T16:09:29.652064Z","iopub.status.idle":"2025-05-11T16:09:29.658297Z","shell.execute_reply.started":"2025-05-11T16:09:29.652036Z","shell.execute_reply":"2025-05-11T16:09:29.657623Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-11T16:09:30.116334Z","iopub.execute_input":"2025-05-11T16:09:30.117029Z","iopub.status.idle":"2025-05-11T16:09:30.122816Z","shell.execute_reply.started":"2025-05-11T16:09:30.116989Z","shell.execute_reply":"2025-05-11T16:09:30.121942Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-11T16:13:43.252433Z","iopub.execute_input":"2025-05-11T16:13:43.253166Z","iopub.status.idle":"2025-05-11T16:13:43.848686Z","shell.execute_reply.started":"2025-05-11T16:13:43.253137Z","shell.execute_reply":"2025-05-11T16:13:43.848083Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-11T16:13:44.42234Z","iopub.execute_input":"2025-05-11T16:13:44.422941Z","iopub.status.idle":"2025-05-11T16:13:44.427068Z","shell.execute_reply.started":"2025-05-11T16:13:44.422921Z","shell.execute_reply":"2025-05-11T16:13:44.426213Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-11T16:13:45.367115Z","iopub.execute_input":"2025-05-11T16:13:45.367688Z","iopub.status.idle":"2025-05-11T16:18:51.450327Z","shell.execute_reply.started":"2025-05-11T16:13:45.367667Z","shell.execute_reply":"2025-05-11T16:18:51.449201Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-11T15:55:13.781748Z","iopub.execute_input":"2025-05-11T15:55:13.7824Z","iopub.status.idle":"2025-05-11T15:55:14.235091Z","shell.execute_reply.started":"2025-05-11T15:55:13.782369Z","shell.execute_reply":"2025-05-11T15:55:14.234084Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-11T16:07:34.816407Z","iopub.execute_input":"2025-05-11T16:07:34.81718Z","iopub.status.idle":"2025-05-11T16:07:35.881978Z","shell.execute_reply.started":"2025-05-11T16:07:34.817148Z","shell.execute_reply":"2025-05-11T16:07:35.881026Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2025-05-11T16:12:35.512977Z","iopub.execute_input":"2025-05-11T16:12:35.513348Z","iopub.status.idle":"2025-05-11T16:13:32.251406Z","shell.execute_reply.started":"2025-05-11T16:12:35.513325Z","shell.execute_reply":"2025-05-11T16:13:32.250586Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null}]}