🤖 machine learning

Lightweight Low-Light Image Enhancement via Distribution-Normalizing Preprocessing and Depthwise U-Net

This paper presents a lightweight, two-stage low-light image enhancement framework that combines frozen distribution-normalizing preprocessing with a compact depthwise U-Net to achieve competitive perceptual quality with significantly fewer parameters, securing 4th place in the CVPR 2026 NTIRE Efficient Low-Light Image Enhancement Challenge.

Original authors: Shimon Murai, Teppei Kurita, Ryuta Satoh, Yusuke Moriuchi

Published 2026-04-14

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Shimon Murai, Teppei Kurita, Ryuta Satoh, Yusuke Moriuchi

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a photo taken in a pitch-black cave. It's grainy, the colors are muddy, and you can barely see anything. You want to fix it, but you only have a tiny, battery-powered flashlight (a very small computer) to do the work. Most experts would say, "You need a massive, super-complex machine to fix this!"

This paper says, "Actually, you don't need a supercomputer. You just need a clever two-step trick."

Here is the story of their solution, broken down into simple concepts:

The Problem: The "Heavy Lifting" Trap

Usually, when AI tries to fix a dark photo, it tries to do everything at once:

Make it bright.
Remove the grainy noise.
Fix the weird colors.
Sharpen the details.

Doing all four things requires a huge, heavy brain (a massive AI model). If you try to shrink that brain to make it small and fast, it gets confused and fails. It's like trying to ask a toddler to juggle chainsaws, cook a gourmet meal, and solve a math problem simultaneously. They just can't handle the load.

The Solution: The "Two-Stage Team"

The authors (from Sony) came up with a team of two: The Pre-Processor and The Artist.

Stage 1: The Pre-Processor (The "Flashlight")

Before the AI even looks at the photo, they use a simple, old-school math trick (like a flashlight or a histogram equalizer) to brighten the image first.

The Analogy: Imagine you are trying to paint a picture in the dark. Instead of trying to paint while squinting in the dark, you first turn on a bright lamp.
The Magic: This "lamp" doesn't need to be perfect. It just needs to make the image bright enough so the colors aren't muddy anymore. The best part? This "lamp" is frozen. It's a simple rule, not a learning brain. It doesn't take up any memory space. It just does the heavy lifting of "making it bright" so the AI doesn't have to.

Stage 2: The Artist (The "Tiny U-Net")

Now that the image is bright, the actual AI (a tiny, lightweight network called a "Depthwise U-Net") steps in.

The Analogy: Because the room is now lit, the artist doesn't need to worry about "finding the light." They can focus entirely on the fun part: fixing the colors and cleaning up the noise.
The Efficiency: Since the AI only has to do one job (color correction) instead of four, it can be incredibly small and fast. It's like hiring a specialist painter instead of a general contractor who tries to do plumbing, electrical, and painting all at once.

Why This is a Big Deal

The paper tested this on a famous competition (NTIRE 2026) and got 4th place. But the real win is the size.

Old Way: To get a great result, you needed a model with 1.6 million or 2 million "brain cells" (parameters).
Their Way: They got a result almost as good with only 859,000 cells.
The Tiny Version: Even their smallest model (338k cells) beat the "scaled-down" versions of the giant models.

The Metaphor:
Imagine two runners.

Runner A (The Old Way): Carries a heavy backpack full of tools (learning to brighten, denoise, and color-correct). They are fast when the backpack is full, but if you try to make them run faster by cutting the backpack in half, they stumble and fall.
Runner B (This Paper): Has a helper who carries the heavy backpack (the frozen pre-processor). Runner B only carries a tiny pencil (the small AI). Because the heavy stuff is already handled, Runner B can run incredibly fast and light, even with a tiny backpack, and still finish the race right behind the giants.

The Key Takeaway

The authors discovered that you don't need to teach the AI how to turn on the lights. If you give it a photo that is already bright (thanks to simple math tricks), the AI can focus its tiny brain on making the picture look beautiful.

This is a huge step forward for phones and cameras, where we need powerful photo editing that doesn't drain the battery or require a supercomputer. It proves that sometimes, the smartest thing an AI can do is let a simple algorithm do the boring work.

1. Problem Statement

Low-light image enhancement (LLIE) aims to recover visibility, reduce noise, and correct color distortion in images captured under poor lighting. While deep learning methods have achieved state-of-the-art results, they often rely on heavy architectures (e.g., Transformers, large CNNs) and complex learned preprocessing front-ends (e.g., illumination-guided attention, learnable color spaces).

The Challenge: Existing methods struggle when scaled down to extremely small parameter budgets (e.g., <1 MB). When forced into sub-1M parameter regimes, learned front-ends fail because they lack the representational capacity to simultaneously handle brightness recovery, color correction, and denoising.
The Goal: Design an LLIE network that fits within 1 MB (fp16) storage while maintaining competitive perceptual quality, specifically targeting the constraints of mobile and embedded vision systems.

2. Methodology

The authors propose a two-stage framework that decouples brightness normalization from color restoration.

Stage 1: Distribution-Normalizing Preprocessing (Frozen)

Instead of learning how to brighten the image, the authors use frozen, algorithm-based preprocessors to normalize the input distribution.

Mechanism: The low-light input is processed by two complementary methods alongside the original image:
1. CPGA-Net: A lightweight network using channel priors and gamma correction for adaptive brightness enhancement.
2. CLAHE: Contrast-Limited Adaptive Histogram Equalization applied to the L-channel of CIE Lab space for local contrast enhancement.
Input Construction: The outputs of these three branches (Original, CPGA, CLAHE) are concatenated to form a 9-channel input tensor.
Rationale: This strategy "externalizes" the difficult task of brightness correction to classical/lightweight algorithms. It shifts the input distribution closer to the ground truth (reducing inter-image and intra-image variance), allowing the trainable network to focus solely on residual color correction.

Stage 2: Lightweight Depthwise U-Net (Trainable)

The trainable component is a compact, 3-level U-Net designed for maximum parameter efficiency.

Architecture: The entire backbone is built using Depthwise-Separable Convolutions (DWConv) rather than standard convolutions or Transformers.
Structure:
- Encoder: Projects the 9-channel input to feature channels ( $f_1$ ), followed by two stride-2 downsampling stages ( $f_1 \to 2f_1 \to 4f_1$ ).
- Decoder: Mirrors the encoder with bilinear upsampling, skip connections, and $1\times1$ fusion.
- Blocks: Each block uses DWConv, GroupNorm, GELU activation, and residual connections.
Output: A global residual connection adds the CPGA output to the final network output.
Loss Function: A combination of pixel-wise L1 loss and LPIPS perceptual loss to ensure both structural accuracy and visual fidelity.

3. Key Contributions

Two-Stage Framework: A novel architecture combining frozen algorithmic preprocessing with a lightweight DWConv U-Net, achieving high performance within a <1 MB footprint.
Distribution Normalization Insight: The paper demonstrates that the specific algorithm used for preprocessing is less critical than the principle of providing complementary, brightness-normalized views. This reduces the distribution variance the network must learn, making the task tractable for small models.
Parameter Efficiency: The authors prove that offloading brightness correction to frozen algorithms is significantly more efficient than using learned front-ends (like those in RetinexFormer or HVI-CIDNet) when parameters are constrained.
Benchmark Achievement: The method secured 4th place in the CVPR 2026 NTIRE Efficient Low-Light Image Enhancement (ELLIE) Challenge.

4. Experimental Results

The method was evaluated on LOLv1, LOLv2-Real, and LOLv2-Synthetic datasets.

Performance vs. Parameter Count:
- Ours-Mid (859K params): Achieved an LPIPS of 0.099 on LOLv1, outperforming RetinexFormer (1.6M params, LPIPS 0.161) and approaching HVI-CIDNet (2.0M params, LPIPS 0.086).
- Ours-Tiny (338K params): When compared against scaled-down versions of RetinexFormer and HVI-CIDNet (matched at ~338K), the proposed method achieved superior PSNR, LPIPS, and DISTS scores.
Ablation Studies:
- Preprocessing: Replacing CPGA with simple Gamma correction or Histogram Equalization yielded comparable results, confirming that the diversity of views matters more than the specific algorithm.
- Loss Function: Adding LPIPS loss significantly improved perceptual quality (LPIPS dropped from 0.224 to 0.099) without sacrificing PSNR.
Generalization: The model maintained strong performance on LOLv2 datasets, outperforming larger baselines in perceptual metrics (LIQE, MUSIQ) while using a fraction of the parameters.

5. Significance and Conclusion

This paper establishes a new design paradigm for efficient computer vision: decouple complex sub-tasks (brightness) from the main network using classical algorithms.

Efficiency: By removing the need for the neural network to learn illumination estimation, the model can dedicate its entire parameter budget to color correction and detail restoration.
Practicality: The approach enables high-quality LLIE on resource-constrained devices (mobile phones, IoT) where large Transformer-based models are infeasible.
Generalizability: The findings suggest that for tasks involving large input distribution variances (like low-light imaging), "freezing" the normalization step is a more robust strategy than attempting to learn it end-to-end in small models.

Limitations: The method relies on the quality of the frozen preprocessor; if the preprocessor fails (e.g., in extremely saturated or dark regions), the downstream network cannot fully recover. Additionally, there is still a slight gap in structural fidelity (SSIM) compared to much larger models.