Upload 3 files

discriminator_final.h5

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

generator_final.h5

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

visible-to-thermal-f7984f.ipynb

@@ -0,0 +1,1050 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "2f21528f",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2025-10-20T07:03:19.866733Z",
+     "iopub.status.busy": "2025-10-20T07:03:19.866103Z",
+     "iopub.status.idle": "2025-10-20T07:03:34.800621Z",
+     "shell.execute_reply": "2025-10-20T07:03:34.799988Z"
+    },
+    "papermill": {
+     "duration": 14.941555,
+     "end_time": "2025-10-20T07:03:34.802099",
+     "exception": false,
+     "start_time": "2025-10-20T07:03:19.860544",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import tensorflow as tf\n",
+    "from tensorflow.keras import Model, Input\n",
+    "from tensorflow.keras.layers import Conv2D, Conv2DTranspose, LeakyReLU\n",
+    "from tensorflow.keras.optimizers import Adam\n",
+    "import numpy as np\n",
+    "import os, glob, time, matplotlib.pyplot as plt\n",
+    "\n",
+    "# -------------------- SETTINGS --------------------\n",
+    "IMG_SIZE = 256\n",
+    "BATCH_SIZE = 16\n",
+    "EPOCHS = 100\n",
+    "PRINT_INTERVAL = 100\n",
+    "SAVE_INTERVAL_EPOCHS = 5\n",
+    "OUTPUT_DIR = \"new/output\"\n",
+    "CKPT_DIR = \"new/ckpt\"\n",
+    "os.makedirs(OUTPUT_DIR, exist_ok=True)\n",
+    "os.makedirs(CKPT_DIR, exist_ok=True)\n",
+    "\n",
+    "# -------------------- DATASET --------------------\n",
+    "BASE_DIR = \"data\"\n",
+    "def load_image_pair(v_path, i_path):\n",
+    "    vis = tf.image.decode_png(tf.io.read_file(v_path), channels=3)\n",
+    "    ir = tf.image.decode_png(tf.io.read_file(i_path), channels=3)\n",
+    "    vis = tf.image.resize(vis, (IMG_SIZE, IMG_SIZE))\n",
+    "    ir = tf.image.resize(ir, (IMG_SIZE, IMG_SIZE))\n",
+    "    vis = tf.cast(vis, tf.float32) / 127.5 - 1.0\n",
+    "    ir = tf.cast(ir, tf.float32) / 127.5 - 1.0\n",
+    "    return vis, ir\n",
+    "def augment(vis, ir):\n",
+    "    vis = tf.image.random_brightness(vis, 0.1)\n",
+    "    vis = tf.image.random_contrast(vis, 0.8, 1.2)\n",
+    "    return vis,ir\n",
+    "\n",
+    "def make_dataset(v_dir, i_dir,train=True):\n",
+    "    vis_files = sorted(glob.glob(os.path.join(v_dir, \"*\")))\n",
+    "    ir_files = sorted(glob.glob(os.path.join(i_dir, \"*\")))\n",
+    "    ds = tf.data.Dataset.from_tensor_slices((vis_files, ir_files))\n",
+    "    ds = ds.map(load_image_pair, num_parallel_calls=tf.data.AUTOTUNE)\n",
+    "    ds = ds.map(augment, num_parallel_calls=tf.data.AUTOTUNE)\n",
+    "    ds = ds.shuffle(500, reshuffle_each_iteration=True)\n",
+    "    ds = ds.batch(BATCH_SIZE).prefetch(tf.data.AUTOTUNE)\n",
+    "    return ds"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "d05541d3",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2025-10-20T07:03:34.810666Z",
+     "iopub.status.busy": "2025-10-20T07:03:34.809984Z",
+     "iopub.status.idle": "2025-10-20T07:03:36.136795Z",
+     "shell.execute_reply": "2025-10-20T07:03:36.135868Z"
+    },
+    "papermill": {
+     "duration": 1.332245,
+     "end_time": "2025-10-20T07:03:36.138219",
+     "exception": false,
+     "start_time": "2025-10-20T07:03:34.805974",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "#train_ds = make_dataset(f\"{BASE_DIR}/train/visible\", f\"{BASE_DIR}/train/infrared\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "c5fe4e05",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2025-10-20T07:03:36.146619Z",
+     "iopub.status.busy": "2025-10-20T07:03:36.146201Z",
+     "iopub.status.idle": "2025-10-20T07:03:37.528302Z",
+     "shell.execute_reply": "2025-10-20T07:03:37.527486Z"
+    },
+    "papermill": {
+     "duration": 1.387878,
+     "end_time": "2025-10-20T07:03:37.529837",
+     "exception": false,
+     "start_time": "2025-10-20T07:03:36.141959",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "from tensorflow.keras.layers import Input, Conv2D, Conv2DTranspose, LeakyReLU, BatchNormalization, Concatenate, Activation, Dropout\n",
+    "from tensorflow.keras.models import Model\n",
+    "from tensorflow.keras.optimizers import Adam\n",
+    "\n",
+    "def build_generator(img_size=256, dropout_rate=0.05):\n",
+    "    inp = Input(shape=(img_size, img_size, 3))\n",
+    "\n",
+    "    # ---- Encoder ----\n",
+    "    e1 = Conv2D(64, 4, strides=2, padding='same')(inp)             # 128x128\n",
+    "    e1 = LeakyReLU(0.2)(e1)\n",
+    "\n",
+    "    e2 = Conv2D(128, 4, strides=2, padding='same')(e1)             # 64x64\n",
+    "    e2 = BatchNormalization()(e2)\n",
+    "    e2 = LeakyReLU(0.2)(e2)\n",
+    "\n",
+    "    e3 = Conv2D(256, 4, strides=2, padding='same')(e2)             # 32x32\n",
+    "    e3 = BatchNormalization()(e3)\n",
+    "    e3 = LeakyReLU(0.2)(e3)\n",
+    "\n",
+    "    e4 = Conv2D(512, 4, strides=2, padding='same')(e3)             # 16x16\n",
+    "    e4 = BatchNormalization()(e4)\n",
+    "    e4 = LeakyReLU(0.2)(e4)\n",
+    "\n",
+    "    # ---- Bottleneck ----\n",
+    "    b = Conv2D(512, 4, strides=2, padding='same')(e4)              # 8x8\n",
+    "    b = Activation('relu')(b)\n",
+    "    b = Dropout(dropout_rate)(b)  # dropout in bottleneck\n",
+    "\n",
+    "    # ---- Decoder ----\n",
+    "    d1 = Conv2DTranspose(512, 4, strides=2, padding='same')(b)     # 16x16\n",
+    "    d1 = BatchNormalization()(d1)\n",
+    "    d1 = Activation('relu')(d1)\n",
+    "    d1 = Dropout(dropout_rate)(d1)  # optional decoder dropout\n",
+    "    d1 = Concatenate()([d1, e4])\n",
+    "\n",
+    "    d2 = Conv2DTranspose(256, 4, strides=2, padding='same')(d1)    # 32x32\n",
+    "    d2 = BatchNormalization()(d2)\n",
+    "    d2 = Activation('relu')(d2)\n",
+    "    d2 = Dropout(dropout_rate)(d2)\n",
+    "    d2 = Concatenate()([d2, e3])\n",
+    "\n",
+    "    d3 = Conv2DTranspose(128, 4, strides=2, padding='same')(d2)    # 64x64\n",
+    "    d3 = BatchNormalization()(d3)\n",
+    "    d3 = Activation('relu')(d3)\n",
+    "    d3 = Dropout(dropout_rate)(d3)\n",
+    "    d3 = Concatenate()([d3, e2])\n",
+    "\n",
+    "    d4 = Conv2DTranspose(64, 4, strides=2, padding='same')(d3)     # 128x128\n",
+    "    d4 = BatchNormalization()(d4)\n",
+    "    d4 = Activation('relu')(d4)\n",
+    "    d4 = Dropout(dropout_rate)(d4)\n",
+    "    d4 = Concatenate()([d4, e1])\n",
+    "\n",
+    "    out = Conv2DTranspose(3, 4, strides=2, padding='same', activation='tanh')(d4)  # 256x256\n",
+    "\n",
+    "    return Model(inp, out, name=\"UNet_Generator\")\n",
+    "\n",
+    "\n",
+    "def build_small_discriminator(img_size=256, dropout_rate=0.2):\n",
+    "    vis_inp = Input(shape=(img_size, img_size, 3))\n",
+    "    ir_inp  = Input(shape=(img_size, img_size, 3))\n",
+    "    x = Concatenate()([vis_inp, ir_inp])\n",
+    "    \n",
+    "    x = Conv2D(64, 4, strides=2, padding='same')(x)\n",
+    "    x = LeakyReLU(0.2)(x)\n",
+    "\n",
+    "    x = Conv2D(128, 4, strides=2, padding='same')(x)\n",
+    "    x = BatchNormalization()(x)\n",
+    "    x = LeakyReLU(0.2)(x)\n",
+    "    x = Dropout(dropout_rate)(x)  # optional\n",
+    "\n",
+    "    x = Conv2D(256, 4, strides=2, padding='same')(x)\n",
+    "    x = BatchNormalization()(x)\n",
+    "    x = LeakyReLU(0.2)(x)\n",
+    "    x = Dropout(dropout_rate)(x)\n",
+    "\n",
+    "    x = Conv2D(512, 4, strides=1, padding='same')(x)\n",
+    "    x = BatchNormalization()(x)\n",
+    "    x = LeakyReLU(0.2)(x)\n",
+    "    x = Dropout(dropout_rate)(x)\n",
+    "\n",
+    "    out = Conv2D(1, 4, strides=1, padding='same')(x)\n",
+    "    return Model([vis_inp, ir_inp], out, name=\"CondPatchGAN_Discriminator\")\n",
+    "\n",
+    "\n",
+    "# Instantiate models\n",
+    "generator = build_generator(IMG_SIZE)\n",
+    "discriminator = build_small_discriminator(IMG_SIZE)\n",
+    "initial_lr = 2e-4\n",
+    "lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(\n",
+    "    initial_learning_rate=initial_lr,\n",
+    "    decay_steps=500,  # number of steps before decay\n",
+    "    decay_rate=0.96,   # decay factor\n",
+    "    staircase=True     # True -> discrete steps\n",
+    ")\n",
+    "\n",
+    "gen_opt = Adam(learning_rate=lr_schedule, beta_1=0.5)\n",
+    "disc_opt = Adam(learning_rate=lr_schedule, beta_1=0.5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "1ffb77ec",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2025-10-20T07:03:38.403886Z",
+     "iopub.status.busy": "2025-10-20T07:03:38.403676Z",
+     "iopub.status.idle": "2025-10-20T07:03:38.410298Z",
+     "shell.execute_reply": "2025-10-20T07:03:38.409568Z"
+    },
+    "papermill": {
+     "duration": 0.011794,
+     "end_time": "2025-10-20T07:03:38.411366",
+     "exception": false,
+     "start_time": "2025-10-20T07:03:38.399572",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# -------------------- LOSSES --------------------\n",
+    "bce = tf.keras.losses.BinaryCrossentropy(from_logits=True)\n",
+    "\n",
+    "def perceptual_loss(y_true, y_pred):\n",
+    "    return tf.reduce_mean(tf.abs(y_true - y_pred))\n",
+    "\n",
+    "def brightness_loss(y_true, y_pred):\n",
+    "    true_b = tf.image.rgb_to_grayscale(y_true)\n",
+    "    pred_b = tf.image.rgb_to_grayscale(y_pred)\n",
+    "    return tf.reduce_mean(tf.abs(true_b - pred_b))\n",
+    "\n",
+    "def intensity_weighted_l1(y_true, y_pred):  \n",
+    "    weights = tf.abs(y_true) + 1  \n",
+    "    return tf.reduce_mean(weights * tf.abs(y_true - y_pred))\n",
+    "\n",
+    "def ssim_loss(y_true, y_pred):  \n",
+    "    return -tf.reduce_mean(tf.image.ssim(y_true, y_pred, max_val=2.0))  \n",
+    "\n",
+    "def generator_adv_loss(fake_pred):\n",
+    "    return bce(tf.ones_like(fake_pred), fake_pred)\n",
+    "\n",
+    "def discriminator_loss(real, fake):\n",
+    "    real_loss = bce(tf.ones_like(real) * 0.9, real)\n",
+    "    fake_loss = bce(tf.zeros_like(fake) + 0.1, fake)\n",
+    "    return (real_loss + fake_loss) * 0.5\n",
+    "def generator_adv_loss(fake_pred):\n",
+    "    return bce(tf.ones_like(fake_pred), fake_pred)\n",
+    "\n",
+    "def discriminator_loss(real, fake):\n",
+    "\n",
+    "    real_loss = bce(tf.ones_like(real) * 0.9, real)\n",
+    "    fake_loss = bce(tf.zeros_like(fake) + 0.1, fake)\n",
+    "\n",
+    "    return (real_loss + fake_loss) * 0.5"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "e7645bd3",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2025-10-20T07:03:38.419250Z",
+     "iopub.status.busy": "2025-10-20T07:03:38.418628Z",
+     "iopub.status.idle": "2025-10-20T07:03:38.425897Z",
+     "shell.execute_reply": "2025-10-20T07:03:38.425349Z"
+    },
+    "papermill": {
+     "duration": 0.012037,
+     "end_time": "2025-10-20T07:03:38.426854",
+     "exception": false,
+     "start_time": "2025-10-20T07:03:38.414817",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "@tf.function\n",
+    "def train_step(input_vis, target_ir, adv_weight=1.0, noise_std=0.05):\n",
+    "    with tf.GradientTape(persistent=True) as tape:\n",
+    "        gen_out = generator(input_vis, training=True)\n",
+    "        \n",
+    "        # Add noise to D inputs (helps stabilize D)\n",
+    "        noisy_real = target_ir \n",
+    "        noisy_fake = gen_out \n",
+    "        \n",
+    "        real_pred = discriminator([input_vis, noisy_real], training=True)\n",
+    "        fake_pred = discriminator([input_vis, noisy_fake], training=True)\n",
+    "\n",
+    "        # Compute losses\n",
+    "        p = perceptual_loss(target_ir, gen_out)\n",
+    "        b = brightness_loss(target_ir, gen_out)\n",
+    "        w = intensity_weighted_l1(target_ir, gen_out)\n",
+    "        s = ssim_loss(target_ir, gen_out)\n",
+    "        adv = generator_adv_loss(fake_pred)\n",
+    "        gen_total = p*20.0 + b*2 + w*10.0 + s*1 + adv*adv_weight\n",
+    "\n",
+    "        disc_total = discriminator_loss(real_pred, fake_pred)\n",
+    "\n",
+    "    gen_grads = tape.gradient(gen_total, generator.trainable_variables)\n",
+    "    disc_grads = tape.gradient(disc_total, discriminator.trainable_variables)\n",
+    "    gen_grads, _ = tf.clip_by_global_norm(gen_grads, 5.0)\n",
+    "    disc_grads, _ = tf.clip_by_global_norm(disc_grads, 5.0)\n",
+    "    gen_opt.apply_gradients(zip(gen_grads, generator.trainable_variables))\n",
+    "    disc_opt.apply_gradients(zip(disc_grads, discriminator.trainable_variables))\n",
+    "    return gen_total, disc_total\n",
+    "\n",
+    "@tf.function\n",
+    "def val_step(input_vis, target_ir, adv_weight=1.0):\n",
+    "    gen_out = generator(input_vis, training=False)\n",
+    "    fake_pred = discriminator([input_vis, gen_out], training=False)\n",
+    "    p = perceptual_loss(target_ir, gen_out)\n",
+    "    b = brightness_loss(target_ir, gen_out)\n",
+    "    w = intensity_weighted_l1(target_ir, gen_out)\n",
+    "    s = ssim_loss(target_ir, gen_out)\n",
+    "    adv = generator_adv_loss(fake_pred)\n",
+    "    gen_total = p*20.0 + b*2 + w*10.0 + s*1 + adv*adv_weight\n",
+    "    return gen_total"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "f9166e0b",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2025-10-20T07:03:38.434108Z",
+     "iopub.status.busy": "2025-10-20T07:03:38.433926Z",
+     "iopub.status.idle": "2025-10-20T07:03:38.439152Z",
+     "shell.execute_reply": "2025-10-20T07:03:38.438642Z"
+    },
+    "papermill": {
+     "duration": 0.010044,
+     "end_time": "2025-10-20T07:03:38.440202",
+     "exception": false,
+     "start_time": "2025-10-20T07:03:38.430158",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# -------------------- UTILITIES --------------------\n",
+    "def to_uint8(x):\n",
+    "    x = (x + 1.0) * 127.5\n",
+    "    return tf.cast(tf.clip_by_value(x, 0, 255), tf.uint8)\n",
+    "\n",
+    "def save_sample_images(model, val_ds, epoch):\n",
+    "    os.makedirs(OUTPUT_DIR, exist_ok=True)\n",
+    "    rows = []\n",
+    "    for i, (v_inp, v_tar) in enumerate(val_ds.take(5)):\n",
+    "        pred = model(v_inp, training=False)\n",
+    "        vis = to_uint8(v_inp[0])\n",
+    "        targ = to_uint8(v_tar[0])\n",
+    "        gen = to_uint8(pred[0])\n",
+    "        row = tf.concat([vis, targ, gen], axis=1)\n",
+    "        rows.append(row)\n",
+    "    grid = tf.concat(rows, axis=0)\n",
+    "    out_path = os.path.join(OUTPUT_DIR, f\"epoch_{epoch:03d}.png\")\n",
+    "    tf.keras.preprocessing.image.save_img(out_path, grid.numpy())\n",
+    "    print(f\"🖼 Saved sample images to {out_path}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "c09e0933",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2025-10-20T07:03:38.447653Z",
+     "iopub.status.busy": "2025-10-20T07:03:38.447428Z",
+     "iopub.status.idle": "2025-10-20T07:03:38.451198Z",
+     "shell.execute_reply": "2025-10-20T07:03:38.450576Z"
+    },
+    "papermill": {
+     "duration": 0.008507,
+     "end_time": "2025-10-20T07:03:38.452143",
+     "exception": false,
+     "start_time": "2025-10-20T07:03:38.443636",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import tensorflow as tf\n",
+    "\n",
+    "# Paths\n",
+    "WORKING_CKPT_DIR = \"new/ckpt\"\n",
+    "os.makedirs(WORKING_CKPT_DIR, exist_ok=True)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "de535ce2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ckpt = tf.train.Checkpoint(generator=generator, discriminator=discriminator, gen_opt=gen_opt, disc_opt=disc_opt)\n",
+    "manager = tf.train.CheckpointManager(ckpt, CKPT_DIR, max_to_keep=5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "90b6be9b",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2025-10-20T07:03:38.472856Z",
+     "iopub.status.busy": "2025-10-20T07:03:38.472285Z",
+     "iopub.status.idle": "2025-10-20T07:03:39.135324Z",
+     "shell.execute_reply": "2025-10-20T07:03:39.134544Z"
+    },
+    "papermill": {
+     "duration": 0.668272,
+     "end_time": "2025-10-20T07:03:39.136644",
+     "exception": false,
+     "start_time": "2025-10-20T07:03:38.468372",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "✅ Loaded checkpoint from new/ckpt\\best_val.ckpt-42\n"
+     ]
+    }
+   ],
+   "source": [
+    "input_ckpt = tf.train.latest_checkpoint(WORKING_CKPT_DIR)\n",
+    "if input_ckpt:\n",
+    "    ckpt.restore(input_ckpt).expect_partial()\n",
+    "    print(f\"✅ Loaded checkpoint from {input_ckpt}\")\n",
+    "else:\n",
+    "    print(\"⚠️ No checkpoint found in /kaggle/input, starting fresh.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "9df742f2",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2025-10-20T07:03:39.144718Z",
+     "iopub.status.busy": "2025-10-20T07:03:39.144465Z",
+     "iopub.status.idle": "2025-10-20T07:03:39.151276Z",
+     "shell.execute_reply": "2025-10-20T07:03:39.150570Z"
+    },
+    "papermill": {
+     "duration": 0.01204,
+     "end_time": "2025-10-20T07:03:39.152328",
+     "exception": false,
+     "start_time": "2025-10-20T07:03:39.140288",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# -------------------- TRAIN LOOP --------------------\n",
+    "\n",
+    "from time import time \n",
+    "def train(train_ds, val_ds, epochs=EPOCHS):\n",
+    "    best_val_loss = 50.0\n",
+    "    step = 0\n",
+    "    ckpt = tf.train.Checkpoint(generator=generator, discriminator=discriminator, gen_opt=gen_opt, disc_opt=disc_opt)\n",
+    "    manager = tf.train.CheckpointManager(ckpt, CKPT_DIR, max_to_keep=5)\n",
+    "\n",
+    "    for epoch in range(1, epochs + 1):\n",
+    "        start = time()\n",
+    "        g_losses, d_losses = [], []\n",
+    "        for vis, ir in train_ds:\n",
+    "            g_loss, d_loss = train_step(vis, ir)\n",
+    "            g_losses.append(g_loss)\n",
+    "            d_losses.append(d_loss)\n",
+    "            step += 1\n",
+    "        print(f\"time {time()-start} | G={tf.reduce_mean(g_losses):.4f} | D={tf.reduce_mean(d_losses):.4f}\")\n",
+    "        \n",
+    "        # Validation\n",
+    "        val_losses = [val_step(v, i) for v, i in val_ds]\n",
+    "        val_mean = tf.reduce_mean(val_losses)\n",
+    "        print(f\"Epoch {epoch}/{epochs} | Val_loss={val_mean:.4f}\")\n",
+    "\n",
+    "        # Save samples and checkpoints\n",
+    "        save_sample_images(generator, val_ds, epoch)\n",
+    "        if val_mean < best_val_loss:\n",
+    "            best_val_loss = val_mean\n",
+    "            ckpt_save_path = os.path.join(WORKING_CKPT_DIR, \"best_val.ckpt\")\n",
+    "            ckpt.save(ckpt_save_path)\n",
+    "            print(f\"🏆 Best checkpoint updated at {ckpt_save_path} | val_loss={val_mean:.4f}\")\n",
+    "        if epoch % SAVE_INTERVAL_EPOCHS == 0:\n",
+    "            manager.save()\n",
+    "            print(f\"💾 Checkpoint saved at epoch {epoch}\")\n",
+    "\n",
+    "    generator.save(os.path.join(OUTPUT_DIR, \"generator_final.h5\"))\n",
+    "    discriminator.save(os.path.join(OUTPUT_DIR, \"discriminator_final.h5\"))\n",
+    "    print(\"✅ Training complete and models saved!\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "a331caff",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2025-10-20T07:03:39.160218Z",
+     "iopub.status.busy": "2025-10-20T07:03:39.159814Z",
+     "iopub.status.idle": "2025-10-20T07:03:39.287611Z",
+     "shell.execute_reply": "2025-10-20T07:03:39.286778Z"
+    },
+    "papermill": {
+     "duration": 0.133149,
+     "end_time": "2025-10-20T07:03:39.289009",
+     "exception": false,
+     "start_time": "2025-10-20T07:03:39.155860",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "#test_ds = make_dataset(f\"{BASE_DIR}/train/visible\", f\"{BASE_DIR}/train/infrared\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "8c10ff7d",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2025-10-20T07:03:39.297249Z",
+     "iopub.status.busy": "2025-10-20T07:03:39.296775Z",
+     "iopub.status.idle": "2025-10-20T07:03:39.301287Z",
+     "shell.execute_reply": "2025-10-20T07:03:39.300656Z"
+    },
+    "papermill": {
+     "duration": 0.009607,
+     "end_time": "2025-10-20T07:03:39.302268",
+     "exception": false,
+     "start_time": "2025-10-20T07:03:39.292661",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# import tensorflow as tf\n",
+    "\n",
+    "# num_elements = tf.data.experimental.cardinality(train_ds).numpy()\n",
+    "# print(num_elements)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "9690af89",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2025-10-20T07:03:39.310045Z",
+     "iopub.status.busy": "2025-10-20T07:03:39.309644Z",
+     "iopub.status.idle": "2025-10-20T07:03:39.319137Z",
+     "shell.execute_reply": "2025-10-20T07:03:39.318632Z"
+    },
+    "papermill": {
+     "duration": 0.014508,
+     "end_time": "2025-10-20T07:03:39.320245",
+     "exception": false,
+     "start_time": "2025-10-20T07:03:39.305737",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# val_ds = train_ds.take(num_elements * 0.1)\n",
+    "# train_ds = train_ds.skip(num_elements * 0.1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6a74164a",
+   "metadata": {
+    "papermill": {
+     "duration": 0.003313,
+     "end_time": "2025-10-20T07:03:39.327070",
+     "exception": false,
+     "start_time": "2025-10-20T07:03:39.323757",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "ddf341ff",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2025-10-20T07:03:39.334784Z",
+     "iopub.status.busy": "2025-10-20T07:03:39.334320Z",
+     "iopub.status.idle": "2025-10-20T07:05:21.060089Z",
+     "shell.execute_reply": "2025-10-20T07:05:21.059479Z"
+    },
+    "papermill": {
+     "duration": 101.734509,
+     "end_time": "2025-10-20T07:05:21.064884",
+     "exception": false,
+     "start_time": "2025-10-20T07:03:39.330375",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "# import matplotlib.pyplot as plt\n",
+    "# import tensorflow as tf\n",
+    "# import numpy as np\n",
+    "\n",
+    "# def to_uint8(x):\n",
+    "#     \"\"\"Convert tensor from [-1,1] → uint8 [0,255].\"\"\"\n",
+    "#     x = (x + 1.0) * 127.5\n",
+    "#     x = tf.clip_by_value(x, 0, 255)\n",
+    "#     return tf.cast(x, tf.uint8)\n",
+    "\n",
+    "# # Shuffle the dataset to take random samples\n",
+    "# train_ds_shuffled = train_ds.shuffle(buffer_size=1000, reshuffle_each_iteration=True)\n",
+    "\n",
+    "# # Take 10 images\n",
+    "# sample_ds = train_ds_shuffled.take(10)\n",
+    "\n",
+    "# # Plot RGB and IR pairs side by side\n",
+    "# fig, axes = plt.subplots(10, 2, figsize=(6, 30))\n",
+    "\n",
+    "# for i, (vis, ir) in enumerate(sample_ds):\n",
+    "#     # If batch size > 1, take the first image in the batch\n",
+    "#     vis_img = vis[0].numpy() if vis.shape[0] > 1 else vis.numpy()[0]\n",
+    "#     ir_img = ir[0].numpy() if ir.shape[0] > 1 else ir.numpy()[0]\n",
+    "\n",
+    "#     # Denormalize\n",
+    "#     vis_img = to_uint8(vis_img)\n",
+    "#     ir_img = to_uint8(ir_img)\n",
+    "#     # print(vis_img)\n",
+    "#     # print(ir_img)\n",
+    "\n",
+    "#     # Plot RGB input\n",
+    "#     axes[i, 0].imshow(vis_img.numpy())\n",
+    "#     axes[i, 0].set_title('RGB Input')\n",
+    "#     axes[i, 0].axis('off')\n",
+    "\n",
+    "#     # Plot IR output\n",
+    "#     if ir_img.shape[-1] == 1:  # single-channel IR\n",
+    "#         axes[i, 1].imshow(ir_img.numpy().squeeze(), cmap='gray')\n",
+    "#     else:\n",
+    "#         axes[i, 1].imshow(ir_img.numpy())\n",
+    "#     axes[i, 1].set_title('IR Output')\n",
+    "#     axes[i, 1].axis('off')\n",
+    "# os.makedirs(OUTPUT_DIR, exist_ok=True)\n",
+    "# save_path = os.path.join(OUTPUT_DIR, 'rgb_ir_pairs.png')\n",
+    "# plt.savefig(save_path)\n",
+    "# plt.close()  \n",
+    "# print(f\"Saved visualization to {save_path}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "ba0c423b",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2025-10-20T07:05:21.073518Z",
+     "iopub.status.busy": "2025-10-20T07:05:21.072865Z",
+     "iopub.status.idle": "2025-10-20T13:26:23.243918Z",
+     "shell.execute_reply": "2025-10-20T13:26:23.243151Z"
+    },
+    "papermill": {
+     "duration": 22862.17716,
+     "end_time": "2025-10-20T13:26:23.245759",
+     "exception": false,
+     "start_time": "2025-10-20T07:05:21.068599",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "#train(train_ds, val_ds, epochs=EPOCHS)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "7a020d03",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2025-10-20T13:26:23.281045Z",
+     "iopub.status.busy": "2025-10-20T13:26:23.280518Z",
+     "iopub.status.idle": "2025-10-20T13:26:55.305284Z",
+     "shell.execute_reply": "2025-10-20T13:26:55.304379Z"
+    },
+    "papermill": {
+     "duration": 32.043319,
+     "end_time": "2025-10-20T13:26:55.306642",
+     "exception": false,
+     "start_time": "2025-10-20T13:26:23.263323",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import tensorflow as tf\n",
+    "from tqdm import tqdm\n",
+    "import numpy as np\n",
+    "\n",
+    "model = tf.keras.models.load_model(\"generator_final.h5\",compile=False)\n",
+    "\n",
+    "# Load test dataset\n",
+    "test_ds = make_dataset(f\"{BASE_DIR}/train/visible\", f\"{BASE_DIR}/train/infrared\",train=False)\n",
+    "def l1_loss(y_true, y_pred):\n",
+    "    return tf.reduce_mean(tf.abs(y_true - y_pred))\n",
+    "def evaluate(test_ds):\n",
+    "    l1_list, psnr_list, ssim_list = [], [], []\n",
+    "    for vis, ir in tqdm(test_ds):\n",
+    "        pred = generator(vis, training=False)\n",
+    "        l1 = l1_loss(ir, pred).numpy()\n",
+    "        psnr = tf.image.psnr(ir, pred, max_val=2.0).numpy()\n",
+    "        ssim = tf.image.ssim(ir, pred, max_val=2.0).numpy()\n",
+    "\n",
+    "        l1_list.append(l1)\n",
+    "        psnr_list.append(np.mean(psnr))\n",
+    "        ssim_list.append(np.mean(ssim))\n",
+    "\n",
+    "    print(\"==== Test Dataset Metrics ====\")\n",
+    "    print(f\"L1 Loss   : {np.mean(l1_list):.4f}\")\n",
+    "    print(f\"PSNR      : {np.mean(psnr_list):.4f}\")\n",
+    "    print(f\"SSIM      : {np.mean(ssim_list):.4f}\")\n",
+    "\n",
+    "\n",
+    "# -------------------- TEST INFERENCE SIDE BY SIDE --------------------\n",
+    "def test_and_save_predictions(test_ds, save_dir=\"output/test_results\"):\n",
+    "    os.makedirs(save_dir, exist_ok=True)\n",
+    "    l1_list, psnr_list, ssim_list = [], [], []\n",
+    "\n",
+    "    for idx, (vis, ir) in enumerate(tqdm(test_ds)):\n",
+    "        pred = generator(vis, training=False)\n",
+    "\n",
+    "        # Metrics\n",
+    "        l1 = tf.reduce_mean(tf.abs(ir - pred)).numpy()\n",
+    "        psnr = tf.reduce_mean(tf.image.psnr(ir, pred, max_val=2.0)).numpy()\n",
+    "        ssim = tf.reduce_mean(tf.image.ssim(ir, pred, max_val=2.0)).numpy()\n",
+    "        l1_list.append(l1)\n",
+    "        psnr_list.append(psnr)\n",
+    "        ssim_list.append(ssim)\n",
+    "\n",
+    "        # Side-by-side image saving\n",
+    "        for i in range(vis.shape[0]):\n",
+    "            vis_img = to_uint8(vis[i])\n",
+    "            ir_img = to_uint8(ir[i])\n",
+    "            gen_img = to_uint8(pred[i])\n",
+    "            row = tf.concat([vis_img, ir_img, gen_img], axis=1)\n",
+    "            save_path = os.path.join(save_dir, f\"test_{idx*vis.shape[0]+i:03d}.png\")\n",
+    "            tf.keras.preprocessing.image.save_img(save_path, row.numpy())\n",
+    "\n",
+    "    print(\"==== Test Dataset Metrics ====\")\n",
+    "    print(f\"L1 Loss   : {np.mean(l1_list):.4f}\")\n",
+    "    print(f\"PSNR      : {np.mean(psnr_list):.4f}\")\n",
+    "    print(f\"SSIM      : {np.mean(ssim_list):.4f}\")\n",
+    "    print(f\"All predictions saved to {save_dir}\")\n",
+    "\n",
+    "#evaluate(test_ds)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "b0a9832b",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2025-10-20T13:26:55.355553Z",
+     "iopub.status.busy": "2025-10-20T13:26:55.354912Z",
+     "iopub.status.idle": "2025-10-20T13:31:04.873369Z",
+     "shell.execute_reply": "2025-10-20T13:31:04.872355Z"
+    },
+    "papermill": {
+     "duration": 249.544369,
+     "end_time": "2025-10-20T13:31:04.874842",
+     "exception": false,
+     "start_time": "2025-10-20T13:26:55.330473",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "#test_and_save_predictions(test_ds)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "b3b09c3c",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2025-10-20T13:31:04.941670Z",
+     "iopub.status.busy": "2025-10-20T13:31:04.941353Z",
+     "iopub.status.idle": "2025-10-20T13:44:19.143047Z",
+     "shell.execute_reply": "2025-10-20T13:44:19.142083Z"
+    },
+    "papermill": {
+     "duration": 794.236367,
+     "end_time": "2025-10-20T13:44:19.144324",
+     "exception": false,
+     "start_time": "2025-10-20T13:31:04.907957",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "#test_and_save_predictions(train_ds,save_dir=\"output/train_results\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e627ddf6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "=== Evaluating checkpoint: new/ckpt\\ckpt-45 ===\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 752/752 [21:46<00:00,  1.74s/it]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "==== Test Dataset Metrics ====\n",
+      "L1 Loss   : 0.0611\n",
+      "PSNR      : 24.3096\n",
+      "SSIM      : 0.8386\n",
+      "All predictions saved to op/ckpt-45\n"
+     ]
+    },
+    {
+     "ename": "TypeError",
+     "evalue": "cannot unpack non-iterable NoneType object",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[19], line 68\u001b[0m\n\u001b[0;32m     66\u001b[0m ckpt\u001b[38;5;241m.\u001b[39mrestore(ckpt_path)\u001b[38;5;241m.\u001b[39mexpect_partial()\n\u001b[0;32m     67\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m=== Evaluating checkpoint: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mckpt_path\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m ===\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m---> 68\u001b[0m l1, psnr, ssim \u001b[38;5;241m=\u001b[39m test_and_save_predictions(test_ds,save_dir\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mop/\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m+\u001b[39mckpt_file\u001b[38;5;241m.\u001b[39mreplace(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m.index\u001b[39m\u001b[38;5;124m\"\u001b[39m,\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m\"\u001b[39m))\n\u001b[0;32m     69\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mL1 Loss : \u001b[39m\u001b[38;5;132;01m{\u001b[39;00ml1\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m.4f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m | PSNR : \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mpsnr\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m.4f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m | SSIM : \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mssim\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m.4f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m     70\u001b[0m results\u001b[38;5;241m.\u001b[39mappend((ckpt_path, l1, psnr, ssim))\n",
+      "\u001b[1;31mTypeError\u001b[0m: cannot unpack non-iterable NoneType object"
+     ]
+    }
+   ],
+   "source": [
+    "import tensorflow as tf\n",
+    "from tqdm import tqdm\n",
+    "import numpy as np\n",
+    "import os\n",
+    "\n",
+    "# Assuming generator, discriminator, gen_opt, disc_opt are defined\n",
+    "ckpt = tf.train.Checkpoint(generator=generator,\n",
+    "                           discriminator=discriminator,\n",
+    "                           gen_opt=gen_opt,\n",
+    "                           disc_opt=disc_opt)\n",
+    "manager = tf.train.CheckpointManager(ckpt, CKPT_DIR, max_to_keep=5)\n",
+    "\n",
+    "\n",
+    "def l1_loss(y_true, y_pred):\n",
+    "    return tf.reduce_mean(tf.abs(y_true - y_pred))\n",
+    "\n",
+    "def evaluate(test_ds):\n",
+    "    l1_list, psnr_list, ssim_list = [], [], []\n",
+    "    for vis, ir in tqdm(test_ds):\n",
+    "        pred = generator(vis, training=False)\n",
+    "        l1 = l1_loss(ir, pred).numpy()\n",
+    "        psnr = tf.image.psnr(ir, pred, max_val=2.0).numpy()\n",
+    "        ssim = tf.image.ssim(ir, pred, max_val=2.0).numpy()\n",
+    "\n",
+    "        l1_list.append(l1)\n",
+    "        psnr_list.append(np.mean(psnr))\n",
+    "        ssim_list.append(np.mean(ssim))\n",
+    "\n",
+    "    return np.mean(l1_list), np.mean(psnr_list), np.mean(ssim_list)\n",
+    "\n",
+    "# -------------------- TEST INFERENCE SIDE BY SIDE --------------------\n",
+    "def test_and_save_predictions(test_ds, save_dir=\"output/test_results\"):\n",
+    "    os.makedirs(save_dir, exist_ok=True)\n",
+    "    l1_list, psnr_list, ssim_list = [], [], []\n",
+    "\n",
+    "    for idx, (vis, ir) in enumerate(tqdm(test_ds)):\n",
+    "        pred = generator(vis, training=False)\n",
+    "\n",
+    "        # Metrics\n",
+    "        l1 = tf.reduce_mean(tf.abs(ir - pred)).numpy()\n",
+    "        psnr = tf.reduce_mean(tf.image.psnr(ir, pred, max_val=2.0)).numpy()\n",
+    "        ssim = tf.reduce_mean(tf.image.ssim(ir, pred, max_val=2.0)).numpy()\n",
+    "        l1_list.append(l1)\n",
+    "        psnr_list.append(psnr)\n",
+    "        ssim_list.append(ssim)\n",
+    "\n",
+    "        # Side-by-side image saving\n",
+    "        for i in range(vis.shape[0]):\n",
+    "            vis_img = to_uint8(vis[i])\n",
+    "            ir_img = to_uint8(ir[i])\n",
+    "            gen_img = to_uint8(pred[i])\n",
+    "            row = tf.concat([vis_img, ir_img, gen_img], axis=1)\n",
+    "            save_path = os.path.join(save_dir, f\"test_{idx*vis.shape[0]+i:03d}.png\")\n",
+    "            tf.keras.preprocessing.image.save_img(save_path, row.numpy())\n",
+    "\n",
+    "    print(\"==== Test Dataset Metrics ====\")\n",
+    "    print(f\"L1 Loss   : {np.mean(l1_list):.4f}\")\n",
+    "    print(f\"PSNR      : {np.mean(psnr_list):.4f}\")\n",
+    "    print(f\"SSIM      : {np.mean(ssim_list):.4f}\")\n",
+    "    print(f\"All predictions saved to {save_dir}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e363024c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# === Evaluating checkpoint: new/ckpt\\best_val.ckpt-42 ===\n",
+    "# 100%|██████████| 752/752 [21:29<00:00,  1.71s/it]\n",
+    "# ==== Test Dataset Metrics ====\n",
+    "# L1 Loss   : 0.0613\n",
+    "# PSNR      : 24.3060\n",
+    "# SSIM      : 0.8382\n",
+    "# All predictions saved to op/best_val.ckpt-42"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "220843eb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# === Evaluating checkpoint: new/ckpt\\ckpt-45 ===\n",
+    "# 100%|██████████| 752/752 [21:46<00:00,  1.74s/it]\n",
+    "# ==== Test Dataset Metrics ====\n",
+    "# L1 Loss   : 0.0611\n",
+    "# PSNR      : 24.3096\n",
+    "# SSIM      : 0.8386\n",
+    "# All predictions saved to op/ckpt-45"
+   ]
+  }
+ ],
+ "metadata": {
+  "kaggle": {
+   "accelerator": "gpu",
+   "dataSources": [
+    {
+     "datasetId": 8436032,
+     "sourceId": 13308561,
+     "sourceType": "datasetVersion"
+    },
+    {
+     "modelId": 472226,
+     "modelInstanceId": 456192,
+     "sourceId": 607810,
+     "sourceType": "modelInstanceVersion"
+    },
+    {
+     "isSourceIdPinned": true,
+     "modelId": 477033,
+     "modelInstanceId": 461278,
+     "sourceId": 613905,
+     "sourceType": "modelInstanceVersion"
+    }
+   ],
+   "dockerImageVersionId": 31154,
+   "isGpuEnabled": true,
+   "isInternetEnabled": false,
+   "language": "python",
+   "sourceType": "notebook"
+  },
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.11"
+  },
+  "papermill": {
+   "default_parameters": {},
+   "duration": 24066.997657,
+   "end_time": "2025-10-20T13:44:23.261563",
+   "environment_variables": {},
+   "exception": null,
+   "input_path": "__notebook__.ipynb",
+   "output_path": "__notebook__.ipynb",
+   "parameters": {},
+   "start_time": "2025-10-20T07:03:16.263906",
+   "version": "2.6.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}