Upload folder using huggingface_hub

.gitattributes

@@ -1,35 +1,4 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz 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
+DGFF_full.ipynb filter=lfs diff=lfs merge=lfs -text
+Dataset/exdarkimg.gif filter=lfs diff=lfs merge=lfs -text

.ipynb_checkpoints/Untitled-checkpoint.ipynb

@@ -0,0 +1,6 @@
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

.ipynb_checkpoints/additional_revew_test-checkpoint.ipynb

@@ -0,0 +1,6 @@
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

.ipynb_checkpoints/dgff-checkpoint.py

@@ -0,0 +1,367 @@
+"""
+Detection-Guided Feature Feedback (DGFF) Module
+================================================
+The DGFF module is the core architectural contribution of this thesis.
+
+During training it:
+  1. Hooks into the YOLOv8 backbone to extract intermediate feature maps
+     at P4 (stride-16) and P5 (stride-32) — the semantically richest layers.
+  2. Projects each feature map to match the channel depth of the corresponding
+     LLEN decoder stage via lightweight 1×1 convolutional adapters.
+  3. Returns the projected tensors so LLEN.forward() can inject them via
+     element-wise addition at decoder stages D4 and D3.
+
+At inference the DGFF module is NOT used — LLEN runs alone with no overhead.
+
+YOLOv8n backbone channel dimensions (verified for 640×640 input):
+  P4: (B, 256, H/16, W/16)   stride-16, semantically rich
+  P5: (B, 512, H/32, W/32)   stride-32, most semantic
+
+LLEN decoder injection targets:
+  dec4 output: (B, 128, H/8,  W/8)   ← receives projected P5
+  dec3 output: (B,  64, H/4,  W/4)   ← receives projected P4
+
+Data flow during training:
+  low_img
+    │
+    ▼
+  LLEN encoder → bottleneck
+    │                          YOLOv8 backbone
+    │         enhanced_img ──────────────────────► P4 (256ch)
+    │              ▲                             ► P5 (512ch)
+    │              │                                  │
+    │         LLEN head                          DGFF adapters
+    │              ▲                            P4→64ch, P5→128ch
+    │              │                                  │
+    └── dec1 ◄ dec2 ◄ dec3 ◄──────── dgff_p4        │
+                         dec4 ◄──────────────── dgff_p5
+                              (element-wise +)
+
+Usage:
+    from dgff import DGFFModule
+    dgff = DGFFModule()
+
+    # During joint training forward pass:
+    enhanced        = llen(low_img)                      # first pass: no feedback
+    dgff_p4, dgff_p5 = dgff(enhanced)                   # extract + project features
+    enhanced        = llen(low_img, dgff_p5, dgff_p4)   # second pass: with feedback
+    loss            = detection_loss + l1_loss(enhanced, high_img)
+    loss.backward()
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from ultralytics import YOLO
+
+
+# ─────────────────────────────────────────────────────────────
+# Adapter — lightweight 1×1 projection
+# ─────────────────────────────────────────────────────────────
+
+class FeatureAdapter(nn.Module):
+    """
+    Projects a YOLOv8 feature map to the channel depth expected by LLEN.
+
+    1×1 Conv keeps spatial size unchanged and adds negligible parameter cost.
+    BN + ReLU stabilise training when detection gradients flow back.
+
+    Args:
+        in_ch  : channels from YOLOv8 backbone (P4=256, P5=512)
+        out_ch : channels expected by LLEN decoder (dec3=64, dec4=128)
+    """
+    def __init__(self, in_ch: int, out_ch: int):
+        super().__init__()
+        self.adapt = nn.Sequential(
+            nn.Conv2d(in_ch, out_ch, kernel_size=1, bias=False),
+            nn.BatchNorm2d(out_ch),
+            nn.ReLU(inplace=True),
+        )
+
+    def forward(self, x):
+        return self.adapt(x)
+
+
+# ─────────────────────────────────────────────────────────────
+# DGFF Module
+# ─────────────────────────────────────────────────────────────
+
+class DGFFModule(nn.Module):
+    """
+    Detection-Guided Feature Feedback module.
+
+    Wraps a frozen-or-trainable YOLOv8 backbone and attaches forward hooks
+    to capture P4 and P5 feature maps. Lightweight adapters project them to
+    match the LLEN decoder channel depths.
+
+    Args:
+        yolo_weights : YOLOv8 model weights string (e.g. 'yolov8n.pt')
+                       Downloads automatically on first use.
+        llen_base_ch : base channel count of the LLEN (default 32).
+                       dec4 expects llen_base_ch*4, dec3 expects llen_base_ch*2.
+        freeze_backbone : if True, YOLOv8 backbone weights are frozen and
+                          only the adapter layers are trained in this module.
+                          Set False to fine-tune backbone end-to-end.
+
+    YOLOv8n P-layer channels (hard-coded for yolov8n):
+        P4 → 128 channels  (layer 6 C2f output)
+        P5 → 256 channels  (layer 9 C2f output)
+    If you switch to yolov8s/m/l/x, update P4_CH and P5_CH accordingly:
+        yolov8s: P4=256,  P5=512
+        yolov8m: P4=384,  P5=576
+        yolov8l: P4=512,  P5=512
+        yolov8x: P4=640,  P5=640
+    """
+
+    # YOLOv8n backbone output channels at P4 and P5
+    # Verified by probing layer outputs on 640×640 input:
+    #   layer 6 (C2f) → 128ch  = P4
+    #   layer 9 (C2f) → 256ch  = P5
+    P4_CH = 128
+    P5_CH = 256
+
+    # YOLOv8 layer indices where P4 and P5 are produced
+    # (these are the C2f output layers in the YOLOv8n backbone)
+    P4_LAYER_IDX = 6    # stride-16 feature map
+    P5_LAYER_IDX = 9    # stride-32 feature map
+
+    def __init__(
+        self,
+        yolo_weights: str = 'yolov8n.pt',
+        llen_base_ch: int = 32,
+        freeze_backbone: bool = True,
+    ):
+        super().__init__()
+
+        # ── Load YOLOv8 ──────────────────────────────────────
+        yolo = YOLO(yolo_weights)
+        self.backbone = yolo.model.model   # nn.Sequential of backbone layers
+
+        if freeze_backbone:
+            for p in self.backbone.parameters():
+                p.requires_grad_(False)
+
+        # ── Verify actual backbone channel depths ────────────
+        # Run a tiny probe so we catch channel mismatches at init time
+        # rather than deep inside a training loop.
+        with torch.no_grad():
+            _probe   = torch.zeros(1, 3, 64, 64)
+            _out     = _probe
+            for _i, _layer in enumerate(list(self.backbone)[:self.P5_LAYER_IDX + 1]):
+                _out = _layer(_out)
+                if _i == self.P4_LAYER_IDX:
+                    _actual_p4 = _out.shape[1]
+                if _i == self.P5_LAYER_IDX:
+                    _actual_p5 = _out.shape[1]
+            if _actual_p4 != self.P4_CH or _actual_p5 != self.P5_CH:
+                raise ValueError(
+                    f"YOLOv8 backbone channel mismatch!\n"
+                    f"  P4: expected {self.P4_CH}, got {_actual_p4}\n"
+                    f"  P5: expected {self.P5_CH}, got {_actual_p5}\n"
+                    f"Update P4_CH and P5_CH class attributes to match."
+                )
+
+        # ── Hook storage ─────────────────────────────────────
+        self._p4_feat = None
+        self._p5_feat = None
+        self._hooks   = []
+        self._register_hooks()
+
+        # ── Adapter layers ───────────────────────────────────
+        # Project YOLOv8 channels → LLEN decoder channels
+        dec4_ch = llen_base_ch * 4   # 128  (dec4 out_ch)
+        dec3_ch = llen_base_ch * 2   #  64  (dec3 out_ch)
+
+        self.adapter_p5 = FeatureAdapter(self.P5_CH, dec4_ch)  # 256 → 128
+        self.adapter_p4 = FeatureAdapter(self.P4_CH, dec3_ch)  # 128 →  64
+
+    # ----------------------------------------------------------
+    def _register_hooks(self):
+        """Attach forward hooks to the P4 and P5 backbone layers."""
+
+        def make_hook(name):
+            def hook(module, input, output):
+                if name == 'p4':
+                    self._p4_feat = output
+                else:
+                    self._p5_feat = output
+            return hook
+
+        layer_list = list(self.backbone)
+        h4 = layer_list[self.P4_LAYER_IDX].register_forward_hook(make_hook('p4'))
+        h5 = layer_list[self.P5_LAYER_IDX].register_forward_hook(make_hook('p5'))
+        self._hooks = [h4, h5]
+
+    # ----------------------------------------------------------
+    def remove_hooks(self):
+        """Call this if you want to detach hooks (e.g. at inference)."""
+        for h in self._hooks:
+            h.remove()
+        self._hooks = []
+
+    # ----------------------------------------------------------
+    def forward(self, enhanced_img: torch.Tensor):
+        """
+        Run the enhanced image through the YOLOv8 backbone to extract
+        P4 and P5 features, then project them via adapter layers.
+
+        Args:
+            enhanced_img : (B, 3, H, W) enhanced output from LLEN, [0,1]
+                           Will be resized to 640×640 for YOLOv8 if needed.
+
+        Returns:
+            dgff_p4 : (B, llen_base_ch*2, H/4,  W/4)  — for LLEN dec3
+            dgff_p5 : (B, llen_base_ch*4, H/8,  W/8)  — for LLEN dec4
+        """
+        B, C, H, W = enhanced_img.shape
+
+        # YOLOv8 expects 640×640 input; resize if necessary
+        if H != 640 or W != 640:
+            x = F.interpolate(
+                enhanced_img, size=(640, 640),
+                mode='bilinear', align_corners=False
+            )
+        else:
+            x = enhanced_img
+
+        # Run backbone layer-by-layer up to P5_LAYER_IDX.
+        # We cannot call self.backbone(x) directly because layers after
+        # the pure backbone use Concat ops that expect list inputs — they
+        # crash when called sequentially. The pure backbone layers 0-9
+        # are all simple Conv/C2f/SPPF blocks that accept a single tensor.
+        # YOLOv8 also saves certain intermediate outputs for skip routes;
+        # we replicate that here by keeping a `saved` dict keyed by index.
+        layer_list = list(self.backbone)
+        saved = {}   # stores outputs of layers that feed into later Concat ops
+        # Layer save indices for YOLOv8n backbone (layers 4 and 6 are reused)
+        SAVE_LAYERS = {4, 6}
+        out = x
+        for i, layer in enumerate(layer_list[:self.P5_LAYER_IDX + 1]):
+            out = layer(out)
+            if i in SAVE_LAYERS:
+                saved[i] = out
+        # hooks already captured p4 (layer 6) and p5 (layer 9) via register_forward_hook
+
+        p4_raw = self._p4_feat   # (B, 128, 40, 40)  for 640×640 input
+        p5_raw = self._p5_feat   # (B, 256, 20, 20)  for 640×640 input
+
+        if p4_raw is None or p5_raw is None:
+            raise RuntimeError(
+                "DGFF hooks did not capture features. "
+                "Check P4_LAYER_IDX and P5_LAYER_IDX match your YOLOv8 version."
+            )
+
+        # Project to LLEN decoder channel depths
+        dgff_p4_proj = self.adapter_p4(p4_raw)   # (B,  64, 40, 40)  128→64
+        dgff_p5_proj = self.adapter_p5(p5_raw)   # (B, 128, 20, 20)  256→128
+
+        # Resize projected features to match LLEN decoder spatial sizes
+        # LLEN decoder spatial sizes depend on input resolution (H, W)
+        # dec4 operates at H/8, W/8 — matches P5 after resize
+        # dec3 operates at H/4, W/4 — matches P4 after resize
+        dgff_p5_out = F.interpolate(
+            dgff_p5_proj, size=(H // 8, W // 8),
+            mode='bilinear', align_corners=False
+        )
+        dgff_p4_out = F.interpolate(
+            dgff_p4_proj, size=(H // 4, W // 4),
+            mode='bilinear', align_corners=False
+        )
+
+        return dgff_p4_out, dgff_p5_out
+
+    # ----------------------------------------------------------
+    def count_parameters(self):
+        total    = sum(p.numel() for p in self.parameters())
+        trainable = sum(p.numel() for p in self.parameters() if p.requires_grad)
+        return total, trainable
+
+
+# ─────────────────────────────────────────────────────────────
+# Smoke Test
+# ─────────────────────────────────────────────────────────────
+
+if __name__ == '__main__':
+    import sys
+    from pathlib import Path
+
+    print("=" * 55)
+    print("  DGFF Module Smoke Test")
+    print("=" * 55)
+
+    device = (
+        torch.device('mps')   if torch.backends.mps.is_available() else
+        torch.device('cuda')  if torch.cuda.is_available()         else
+        torch.device('cpu')
+    )
+    print(f"  Device : {device}")
+
+    # ── Load DGFF ────────────────────────────────────────────
+    print("  Loading YOLOv8n backbone ...")
+    dgff = DGFFModule(
+        yolo_weights    = 'yolov8n.pt',
+        llen_base_ch    = 32,
+        freeze_backbone = True,
+    ).to(device)
+
+    total, trainable = dgff.count_parameters()
+    print(f"  Total parameters    : {total:,}")
+    print(f"  Trainable (adapters): {trainable:,}")
+
+    # ── Forward pass test ────────────────────────────────────
+    dummy_enhanced = torch.rand(2, 3, 256, 256).to(device)
+
+    print(f"\n  Input  : {tuple(dummy_enhanced.shape)}")
+    dgff_p4, dgff_p5 = dgff(dummy_enhanced)
+    print(f"  dgff_p4 (→ dec3) : {tuple(dgff_p4.shape)}")   # expect (2, 64, 64, 64)
+    print(f"  dgff_p5 (→ dec4) : {tuple(dgff_p5.shape)}")   # expect (2, 128, 32, 32)
+
+    assert dgff_p4.shape == (2, 64,  64, 64), f"P4 shape wrong: {dgff_p4.shape}"
+    assert dgff_p5.shape == (2, 128, 32, 32), f"P5 shape wrong: {dgff_p5.shape}"
+    print("  Shape assertions passed ✓")
+
+    # ── Full pipeline test: LLEN + DGFF ─────────────────────
+    print("\n  Testing LLEN + DGFF combined forward pass ...")
+    sys.path.insert(0, str(Path(__file__).parent if '__file__' in dir() else Path('.')))
+    from llen import LLEN
+
+    llen = LLEN(base_ch=32).to(device)
+
+    # Simulate the two-pass training forward:
+    # Pass 1: LLEN enhances without feedback (cold start)
+    enhanced = llen(dummy_enhanced)
+    print(f"  Pass 1 enhanced : {tuple(enhanced.shape)}")
+
+    # Pass 2: DGFF extracts features from enhanced image
+    dgff_p4, dgff_p5 = dgff(enhanced)
+
+    # Pass 3: LLEN re-enhances with detection feedback injected
+    enhanced_guided = llen(dummy_enhanced, dgff_p5=dgff_p5, dgff_p4=dgff_p4)
+    print(f"  Pass 2 guided   : {tuple(enhanced_guided.shape)}")
+
+    assert enhanced_guided.shape == dummy_enhanced.shape
+    print("  Combined pipeline ✓")
+
+    # ── Gradient flow test ─��─────────────────────────────────
+    print("\n  Testing gradient flow through DGFF adapters ...")
+    import torch.nn.functional as F_test
+
+    llen.train()
+    dgff.train()
+
+    enhanced      = llen(dummy_enhanced)
+    dgff_p4, dgff_p5 = dgff(enhanced)
+    enhanced_guided  = llen(dummy_enhanced, dgff_p5=dgff_p5, dgff_p4=dgff_p4)
+
+    dummy_target = torch.rand_like(enhanced_guided)
+    loss = F_test.l1_loss(enhanced_guided, dummy_target)
+    loss.backward()
+
+    # Check adapter grads received signal
+    for name, param in dgff.adapter_p5.named_parameters():
+        assert param.grad is not None, f"adapter_p5.{name} has no gradient!"
+    for name, param in dgff.adapter_p4.named_parameters():
+        assert param.grad is not None, f"adapter_p4.{name} has no gradient!"
+
+    print("  Adapter gradients flowing ✓")
+    print("\n  All DGFF tests passed ✓")

.ipynb_checkpoints/dgff_v2-checkpoint.py

@@ -0,0 +1,178 @@
+"""
+dgff_v2.py — DGFF Module with Channel Gating
+=============================================
+Improvement over v1: 1×1 adapter + sigmoid gate replaces plain
+element-wise addition. The gate learns which detector channels
+to incorporate per-spatial-location, making the feedback selective
+and more theoretically principled.
+
+Change from v1:
+  v1:  x_decoder = x_decoder + adapter(f_det)
+  v2:  gate = sigmoid(gate_conv(f_det))
+       x_decoder = x_decoder + gate * adapter(f_det)
+
+The gate suppresses irrelevant detector features (e.g. background
+texture channels that don't help enhancement) while amplifying
+object-boundary and semantic channels.
+"""
+
+import torch
+import torch.nn as nn
+from ultralytics import YOLO
+
+
+class GatedAdapter(nn.Module):
+    """
+    Projects YOLOv8 backbone features into LLEN decoder space
+    with a learned sigmoid gate.
+
+    Args:
+        in_ch  : YOLOv8 feature channels (256 for P4, 512 for P5 on yolov8n)
+        out_ch : LLEN decoder channels at the injection point
+    """
+    def __init__(self, in_ch: int, out_ch: int):
+        super().__init__()
+        # Value path: projects detector features to decoder space
+        self.proj = nn.Sequential(
+            nn.Conv2d(in_ch, out_ch, kernel_size=1, bias=False),
+            nn.BatchNorm2d(out_ch),
+            nn.ReLU(inplace=True),
+        )
+        # Gate path: learns a channel-wise attention mask in [0, 1]
+        self.gate = nn.Sequential(
+            nn.Conv2d(in_ch, out_ch, kernel_size=1, bias=False),
+            nn.Sigmoid(),
+        )
+
+    def forward(self, f_det, target_size):
+        """
+        Args:
+            f_det       : (B, in_ch, H', W')  raw backbone feature
+            target_size : (H, W) spatial size of the decoder stage
+
+        Returns:
+            (B, out_ch, H, W) gated feature feedback
+        """
+        # Resize to match decoder spatial resolution
+        f_det = nn.functional.interpolate(
+            f_det, size=target_size, mode='bilinear', align_corners=False
+        )
+        return self.gate(f_det) * self.proj(f_det)   # element-wise gated projection
+
+
+class DGFFModule(nn.Module):
+    """
+    Detection-Guided Feature Feedback module.
+
+    Wraps a frozen YOLOv8 backbone and two GatedAdapters that project
+    P4 and P5 backbone features into the LLEN decoder spatial dimensions.
+
+    Args:
+        yolo_weights    : path to YOLOv8 .pt file
+        llen_base_ch    : base channel width of the LLEN (default 32)
+        freeze_backbone : if True, backbone weights are not updated
+    """
+
+    # YOLOv8n backbone channel counts at P4 and P5
+    # These depend on the variant (n/s/m/l/x). yolov8n:
+    YOLO_P4_CH = 256
+    YOLO_P5_CH = 512
+
+    def __init__(
+        self,
+        yolo_weights:    str  = 'yolov8n.pt',
+        llen_base_ch:    int  = 32,
+        freeze_backbone: bool = True,
+    ):
+        super().__init__()
+
+        # ── Load YOLOv8 backbone ──────────────────────────────
+        yolo = YOLO(yolo_weights)
+        # Extract the backbone (model.model.model[:10] for YOLOv8)
+        # This gives us the CSP + C2f feature extraction up to P5
+        self.backbone = yolo.model.model[:10]
+
+        if freeze_backbone:
+            for p in self.backbone.parameters():
+                p.requires_grad_(False)
+
+        # ── Gated adapters ───────────────────────────────────
+        c = llen_base_ch
+        # P5 feedback → decoder stage D4 (out_ch = c*4 = 128)
+        self.adapter_p5 = GatedAdapter(self.YOLO_P5_CH, c * 4)
+        # P4 feedback → decoder stage D3 (out_ch = c*2 = 64)
+        self.adapter_p4 = GatedAdapter(self.YOLO_P4_CH, c * 2)
+
+        self._llen_base_ch = c
+
+    # ----------------------------------------------------------
+    def forward(self, enhanced_img):
+        """
+        Args:
+            enhanced_img : (B, 3, H, W)  enhanced image from LLEN Pass 1
+
+        Returns:
+            (p4_feedback, p5_feedback) — tensors ready to inject into LLEN decoder
+        """
+        # Run backbone — collect intermediate feature maps
+        x      = enhanced_img
+        p4_raw = None
+        p5_raw = None
+
+        for i, layer in enumerate(self.backbone):
+            x = layer(x)
+            # YOLOv8n: P4 at layer 6, P5 at layer 9 (backbone output)
+            if i == 6:
+                p4_raw = x
+            if i == 9:
+                p5_raw = x
+
+        if p4_raw is None or p5_raw is None:
+            raise RuntimeError(
+                "Could not extract P4/P5 from backbone. "
+                "Check layer indices for your YOLOv8 variant."
+            )
+
+        c = self._llen_base_ch
+        H_input, W_input = enhanced_img.shape[-2:]
+
+        # Compute decoder target sizes (matching LLEN decoder stages)
+        p5_size = (H_input // 8,  W_input // 8)   # D4 spatial dim
+        p4_size = (H_input // 4,  W_input // 4)   # D3 spatial dim
+
+        p5_feedback = self.adapter_p5(p5_raw, p5_size)  # (B, c*4, H/8, W/8)
+        p4_feedback = self.adapter_p4(p4_raw, p4_size)  # (B, c*2, H/4, W/4)
+
+        return p4_feedback, p5_feedback
+
+    # ----------------------------------------------------------
+    def count_parameters(self):
+        total   = sum(p.numel() for p in self.parameters())
+        trainable = sum(p.numel() for p in self.parameters() if p.requires_grad)
+        return total, trainable
+
+
+# ─────────────────────────────────────────────────────────────
+# Smoke test
+# ─────────────────────────────────────────────────────────────
+
+if __name__ == '__main__':
+    import sys
+
+    print("DGFFv2 Smoke Test")
+    device = torch.device('cpu')
+
+    try:
+        dgff = DGFFModule(yolo_weights='yolov8n.pt', llen_base_ch=32).to(device)
+    except Exception as e:
+        print(f"[SKIP] Could not load YOLOv8: {e}")
+        sys.exit(0)
+
+    total, trainable = dgff.count_parameters()
+    print(f"  Params total / trainable: {total:,} / {trainable:,}")
+
+    dummy = torch.rand(2, 3, 256, 256)
+    p4, p5 = dgff(dummy)
+    print(f"  P4 feedback shape: {tuple(p4.shape)}  (expected: 2, 64, 64, 64)")
+    print(f"  P5 feedback shape: {tuple(p5.shape)}  (expected: 2, 128, 32, 32)")
+    print("  Smoke test passed ✓")

.ipynb_checkpoints/llen-checkpoint.py

@@ -0,0 +1,62 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from ultralytics import YOLO
+
+# ── PASTE THIS into your DGFF smoke-test cell, replacing the import block ──
+#
+# The problem: your notebook has all code in cells, so there is no llen.py
+# file on disk to import. LLEN is already defined in a previous cell though,
+# so we just skip the import entirely and use it directly.
+#
+# BEFORE (broken):
+#   sys.path.insert(0, str(Path(__file__).parent if '__file__' in dir() else Path('.')))
+#   from llen import LLEN
+#
+# AFTER (fixed) — replace those two lines with:
+
+# Check if LLEN is already defined in this notebook session
+if 'LLEN' not in dir():
+    # Only needed if running dgff.py as a standalone script
+    import sys
+    sys.path.insert(0, '.')   # assumes llen.py is in the same folder as notebook
+    from llen import LLEN
+
+# Everything below stays exactly the same
+llen_model = LLEN(base_ch=32).to(device)
+
+# Pass 1: LLEN enhances without feedback
+enhanced = llen_model(dummy_enhanced)
+print(f"  Pass 1 enhanced : {tuple(enhanced.shape)}")
+
+# Pass 2: DGFF extracts features from enhanced image
+dgff_p4, dgff_p5 = dgff(enhanced)
+
+# Pass 3: LLEN re-enhances with detection feedback injected
+enhanced_guided = llen_model(dummy_enhanced, dgff_p5=dgff_p5, dgff_p4=dgff_p4)
+print(f"  Pass 2 guided   : {tuple(enhanced_guided.shape)}")
+
+assert enhanced_guided.shape == dummy_enhanced.shape
+print("  Combined pipeline ✓")
+
+# ── Gradient flow test ──────────────────────────────────────
+print("\n  Testing gradient flow through DGFF adapters ...")
+
+llen_model.train()
+dgff.train()
+
+enhanced         = llen_model(dummy_enhanced)
+dgff_p4, dgff_p5 = dgff(enhanced)
+enhanced_guided  = llen_model(dummy_enhanced, dgff_p5=dgff_p5, dgff_p4=dgff_p4)
+
+dummy_target = torch.rand_like(enhanced_guided)
+loss = torch.nn.functional.l1_loss(enhanced_guided, dummy_target)
+loss.backward()
+
+for name, param in dgff.adapter_p5.named_parameters():
+    assert param.grad is not None, f"adapter_p5.{name} has no gradient!"
+for name, param in dgff.adapter_p4.named_parameters():
+    assert param.grad is not None, f"adapter_p4.{name} has no gradient!"
+
+print("  Adapter gradients flowing ✓")
+print("\n  All DGFF tests passed ✓")

.ipynb_checkpoints/lol_dataset-checkpoint.py

@@ -0,0 +1,226 @@
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+# ─────────────────────────────────────────────────────────────
+# 1.  Core Dataset Class
+# ─────────────────────────────────────────────────────────────
+
+class LOLDataset(Dataset):
+    """
+    Loads paired (low-light, normal-light) images from the LOL dataset.
+
+    Args:
+        root      : path to the LOL root folder
+        split     : 'train'  → uses our485/
+                    'val'    → uses eval15/
+        crop_size : if not None, randomly crops both images to this size
+                    during training (e.g. 256 or 384).
+                    Set to None to use full images (600×400 for LOL).
+        augment   : apply random horizontal flip during training
+    """
+
+    SPLIT_DIRS = {
+        'train': 'our485',
+        'val':   'eval15',
+    }
+
+    def __init__(
+        self,
+        root: str,
+        split: str = 'train',
+        crop_size: int | None = 256,
+        augment: bool = True,
+    ):
+        super().__init__()
+
+        assert split in self.SPLIT_DIRS, f"split must be 'train' or 'val', got '{split}'"
+
+        self.split      = split
+        self.crop_size  = crop_size
+        self.augment    = augment and (split == 'train')
+
+        split_dir  = Path(root) / self.SPLIT_DIRS[split]
+        self.low_dir  = split_dir / 'low'
+        self.high_dir = split_dir / 'high'
+
+        self._verify_dirs()
+
+        # Collect filenames — sorted so low/high pairs always align
+        # Filter to image files only (excludes .DS_Store and other macOS metadata)
+        _IMG_EXTS = {'.png', '.jpg', '.jpeg', '.bmp', '.tif', '.tiff'}
+        self.filenames = sorted(
+            f for f in os.listdir(self.low_dir)
+            if Path(f).suffix.lower() in _IMG_EXTS
+        )
+
+        # Sanity check: every low image has a matching high image
+        missing = [f for f in self.filenames if not (self.high_dir / f).exists()]
+        if missing:
+            raise FileNotFoundError(
+                f"No matching high-light image for: {missing[:5]} ..."
+            )
+
+        # Simple normalisation: PIL image [0,255] → tensor [0,1]
+        self.to_tensor = T.ToTensor()
+
+    # ----------------------------------------------------------
+    def _verify_dirs(self):
+        for d in (self.low_dir, self.high_dir):
+            if not d.is_dir():
+                raise FileNotFoundError(
+                    f"Directory not found: {d}\n"
+                    f"Make sure your LOL dataset is at the correct path."
+                )
+
+    # ----------------------------------------------------------
+    def __len__(self):
+        return len(self.filenames)
+
+    # ----------------------------------------------------------
+    def __getitem__(self, idx):
+        fname = self.filenames[idx]
+
+        # Load images as RGB PIL
+        low_img  = Image.open(self.low_dir  / fname).convert('RGB')
+        high_img = Image.open(self.high_dir / fname).convert('RGB')
+
+        # ── Random crop (same crop for both images) ──
+        if self.crop_size is not None:
+            low_img, high_img = self._paired_random_crop(low_img, high_img)
+
+        # ── Random horizontal flip ──
+        if self.augment and random.random() > 0.5:
+            low_img  = TF.hflip(low_img)
+            high_img = TF.hflip(high_img)
+
+        # ── PIL → float tensor [0, 1] ──
+        low_tensor  = self.to_tensor(low_img)   # shape: (3, H, W)
+        high_tensor = self.to_tensor(high_img)  # shape: (3, H, W)
+
+        return low_tensor, high_tensor, fname
+
+    # ----------------------------------------------------------
+    def _paired_random_crop(self, low_pil, high_pil):
+        """Apply the SAME random crop to both images."""
+        w, h = low_pil.size                          # PIL gives (width, height)
+        crop = self.crop_size
+
+        if w < crop or h < crop:
+            # If image is smaller than desired crop, just resize both
+            low_pil  = TF.resize(low_pil,  [crop, crop])
+            high_pil = TF.resize(high_pil, [crop, crop])
+            return low_pil, high_pil
+
+        # Random top-left corner
+        top  = random.randint(0, h - crop)
+        left = random.randint(0, w - crop)
+
+        low_pil  = TF.crop(low_pil,  top, left, crop, crop)
+        high_pil = TF.crop(high_pil, top, left, crop, crop)
+        return low_pil, high_pil
+
+
+# ─────────────────────────────────────────────────────────────
+# 2.  Convenience Factory Function
+# ──────────────────────────────────────────────��──────────────
+
+def get_lol_dataloaders(
+    root: str,
+    batch_size: int = 8,
+    crop_size: int | None = 256,
+    num_workers: int = 0,   # 0 = safe for Jupyter notebooks on Mac/Windows
+    pin_memory: bool = False,  # False = safe for MPS (Apple Silicon) and CPU
+) -> tuple[DataLoader, DataLoader]:
+    """
+    Build train and validation DataLoaders for the LOL dataset.
+
+    Args:
+        root        : path to the LOL root folder (contains our485/ and eval15/)
+        batch_size  : number of image pairs per batch
+        crop_size   : random crop size during training. None = full image.
+        num_workers : parallel workers for data loading
+        pin_memory  : speeds up CPU→GPU transfer (set True when using CUDA)
+
+    Returns:
+        (train_loader, val_loader)
+    """
+    train_set = LOLDataset(root=root, split='train', crop_size=crop_size, augment=True)
+    val_set   = LOLDataset(root=root, split='val',   crop_size=None,      augment=False)
+
+    train_loader = DataLoader(
+        train_set,
+        batch_size  = batch_size,
+        shuffle     = True,          # shuffle every epoch
+        num_workers = num_workers,
+        pin_memory  = pin_memory,
+        drop_last   = True,          # keeps batch size consistent
+    )
+
+    val_loader = DataLoader(
+        val_set,
+        batch_size  = 1,             # validate one image at a time (full resolution)
+        shuffle     = False,
+        num_workers = num_workers,
+        pin_memory  = pin_memory,
+        drop_last   = False,
+    )
+
+    return train_loader, val_loader
+
+
+# ─────────────────────────────────────────────────────────────
+# 3.  Quick Sanity Check  (run this file directly to test)
+# ─────────────────────────────────────────────────────────────
+
+if __name__ == '__main__':
+    import sys
+    import matplotlib.pyplot as plt
+
+    # ── Point this at your LOL folder ──
+    LOL_ROOT = './LOL'   # <-- change this if your path is different
+
+    print(f"Loading LOL dataset from: {LOL_ROOT}")
+
+    try:
+        train_loader, val_loader = get_lol_dataloaders(
+            root        = LOL_ROOT,
+            batch_size  = 4,
+            crop_size   = 256,
+            num_workers = 0,      # always 0 when running directly as __main__
+            pin_memory  = False,  # False for MPS (Apple Silicon) and CPU
+        )
+    except FileNotFoundError as e:
+        print(f"\n[ERROR] {e}")
+        sys.exit(1)
+
+    print(f"  Train batches : {len(train_loader)}  "
+          f"({len(train_loader.dataset)} image pairs)")
+    print(f"  Val   batches : {len(val_loader)}  "
+          f"({len(val_loader.dataset)} image pairs)")
+
+    # ── Grab one batch and print tensor info ──
+    low_batch, high_batch, fnames = next(iter(train_loader))
+
+    print(f"\nBatch shapes  : low={tuple(low_batch.shape)}  "
+          f"high={tuple(high_batch.shape)}")
+    print(f"Value range   : [{low_batch.min():.3f}, {low_batch.max():.3f}]")
+    print(f"Filenames     : {list(fnames)}")
+
+    # ── Visualise the first pair ──
+    fig, axes = plt.subplots(1, 2, figsize=(10, 4))
+    # Convert tensor (C,H,W) → numpy (H,W,C) for matplotlib
+    axes[0].imshow(low_batch[0].permute(1, 2, 0).numpy())
+    axes[0].set_title(f'Low-light input\n{fnames[0]}')
+    axes[0].axis('off')
+
+    axes[1].imshow(high_batch[0].permute(1, 2, 0).numpy())
+    axes[1].set_title(f'Normal-light reference\n{fnames[0]}')
+    axes[1].axis('off')
+
+    plt.tight_layout()
+    plt.savefig('lol_sample.png', dpi=120)
+    print("\nSaved sample visualisation → lol_sample.png")
+    plt.show()
+

.ipynb_checkpoints/train-checkpoint.ipynb

@@ -0,0 +1,6 @@
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

DGFF_full.ipynb

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

Dataset/README.md

@@ -0,0 +1,40 @@
+## Description
+
+The ExDark dataset can be downloaded at [this https URL](https://drive.google.com/file/d/1BHmPgu8EsHoFDDkMGLVoXIlCth2dW6Yx/view?usp=sharing) (size = 1.5Gb).
+
+![exdark](Thumbnails.png)
+
+## Dataset Information
+
+The images are kept in individual class folders following the image class labels:
+1. Bicycle - 652 images
+2. Boat - 679 images
+3. Bottle - 547 images
+4. Bus - 527 images
+5. Car - 638 images
+6. Cat - 735 images
+7. Chair - 648 images
+8. Cup - 519 images
+9. Dog - 801 images
+10. Motorbike - 503 images
+11. People - 609 images
+12. Table - 505 images 
+
+Total : 7,363 images
+
+![demo](exdarkimg.gif)
+
+For the experiments in our paper that involves training, the data are split as follows:
+
+(a) Training - 3,000 images (250 images per class)
+
+(b) Validation - 1,800 images (150 images per class)
+
+(c) Testing - 2,563 images
+
+* See [annotation](https://github.com/cs-chan/Exclusively-Dark-Image-Dataset/tree/master/Groundtruth) for further details.
+
+Note:
+1. The ExDark dataset can be used only for non-commercial research purpose.
+
+2. For commercial purpose usage, please contact Dr. Chee Seng Chan at `cs.chan at um.edu.my`