LiteDenoiseNet: Lightweight NPU Denoiser

• The paper introduces LiteDenoiseNet, a lightweight student network trained via high-α knowledge distillation to recover 99.8% of the teacher’s quality with only 1.96M parameters.
• It employs a compact U-Net architecture with hardware-aware design, using only NPU-native operators and replacing transposed convolutions with efficient upsampling methods for realistic mobile deployment.
• The model is optimized for real-image denoising under strict latency and memory constraints, achieving impressive benchmarks on MediaTek and Snapdragon NPUs while preserving fine textures.

Searching arXiv for LiteDenoiseNet and closely related lightweight denoising references. Searching arXiv for (Kayani et al., 5 May 2026). LiteDenoiseNet is the lightweight student network introduced for real-image denoising in mobile Neural Processing Unit deployment, with an explicit focus on realistic smartphone noise, native accelerator compatibility, and high-resolution inference under strict latency and memory constraints. It was developed in the context of the Mobile AI 2026 Image Denoising Challenge, where image quality is evaluated on full-resolution images at $2432 \times 3200$ and runtime is measured under an official Full HD protocol at $1088 \times 1920$. In that setting, the model reaches $37.66$ dB PSNR / $0.9278$ SSIM on the validation benchmark and $37.58$ dB / $0.9098$ SSIM on the held-out test benchmark, while running in $34.0$ ms on the MediaTek Dimensity 9500 NPU and $46.1$ ms on the Qualcomm Snapdragon 8 Elite NPU (Kayani et al., 5 May 2026).

1. Definition and problem setting

LiteDenoiseNet addresses real-image denoising for smartphone imagery rather than synthetic additive white Gaussian noise alone. Its stated purpose is to remove realistic sensor noise while preserving fine texture and structure under the practical constraints of mobile deployment: limited on-chip memory, operator support restrictions, bandwidth bottlenecks, and strict latency requirements. The target deployment environment is therefore not a generic GPU workstation but tiled-memory mobile accelerators such as the MediaTek APU and Qualcomm Hexagon NPU.

The model belongs to a hardware-algorithm co-design framework rather than a purely algorithmic compression pipeline. The paper explicitly states that LiteDenoiseNet is not a compressed desktop denoiser retrofitted afterward; instead, it is a student architecture constrained a priori to an NPU-native operator set and trained to recover the behavior of a much larger teacher via knowledge distillation. This distinction is central to its identity. The model is lightweight in parameter count, operator set, and deployment behavior simultaneously.

A recurring point in the evaluation protocol is the separation between fidelity and timing resolutions. Full-resolution images at $2432 \times 3200$ are used for denoising-quality assessment, whereas runtime is measured on Full HD $1088 \times 1920$ inputs according to challenge rules. The authors stress that this split is official and enables direct comparison, but they also note that Full HD runtime does not directly equal true end-to-end latency at 8MP deployment.

2. Network architecture

Architecturally, LiteDenoiseNet is a compact U-Net-style encoder-decoder. The student uses a base width of 16 channels and scales channels progressively across four downsampling stages, although the exact per-stage channel multipliers are not explicitly tabulated. The choice $1088 \times 1920$0 is described as hardware-aware: it aligns better with SIMD and vectorized execution on mobile NPUs than an even smaller width, and a narrower $1088 \times 1920$1 baseline, while faster, was substantially worse in quality.

Its repeated computational unit is the LiteDenoisingBlock, a bottlenecked residual convolutional block built entirely from standard $1088 \times 1920$2 convolutions and ReLU activations. Internally, the block uses the channel pattern

$1088 \times 1920$3

The figure and text indicate that the block reduces width from $1088 \times 1920$4 to $1088 \times 1920$5 between standard $1088 \times 1920$6 convolutions, restores it, and wraps the sequence with a local residual connection. Unlike the teacher’s denser DenoisingBlock, this student block avoids dense concatenative aggregation and wider intermediate activations.

Downsampling is performed with strided convolutions. In the decoder, transposed convolutions are entirely removed; upsampling is implemented as parameter-free nearest-neighbor interpolation followed by a standard $1088 \times 1920$7 convolution for refinement. This substitution is one of the model’s defining design choices, because transposed convolutions in the teacher are described as prone to complex zero-padding logic and hardware fallback on mobile NPUs, whereas nearest-neighbor upsampling plus convolution maps cleanly to mobile accelerators. Skip features from the encoder are fused into the decoder in the U-Net style, although the exact fusion operator is not separately detailed for the student.

The output stage uses global residual learning. The network predicts a residual that is added to the noisy image, and the result is clipped to $1088 \times 1920$8. The operator set is deliberately conservative: standard $1088 \times 1920$9 convolutions, ReLU, strided convolution downsampling, nearest-neighbor upsampling, and ordinary residual additions. The student explicitly avoids transposed convolutions and also avoids global self-attention, deformable convolutions, dynamic upsampling operators, and nonlinearities such as GELU or Swish.

3. Distillation framework and training procedure

LiteDenoiseNet is trained against a frozen teacher denoiser with 41.6M trainable parameters and validation PSNR of $37.66$0 dB. That teacher is itself a larger U-Net-style model with a three-level encoder-bottleneck-decoder and channel range $37.66$1–$37.66$2. Its encoder stages use two DenoisingBlocks followed by a $37.66$3 stride-2 convolution, the bottleneck contains two additional DenoisingBlocks, and the decoder mirrors the encoder with $37.66$4 transposed convolutions, skip concatenation, and PReLU-based fusion.

The student is optimized with three losses: $37.66$5

$37.66$6

$37.66$7

The total objective is

$37.66$8

with the reported best setting

$37.66$9

The paper describes this as high-$0.9278$0 distillation with $0.9278$1, meaning that $0.9278$2 of the main quadratic supervision is assigned to teacher matching and $0.9278$3 to direct ground-truth matching. The stated rationale is that real-image denoising targets may still contain residual sensor noise, so heavy reliance on teacher predictions helps the student learn a cleaner restoration manifold rather than overfitting to imperfections in the ground truth.

Training uses the official Mobile AI 2026 challenge data: 650 paired noisy/clean training images and 50 validation pairs. Crops are extracted after a 2-pixel buffer padding to reduce edge bias. Data augmentation consists of random horizontal and vertical flips and orthogonal rotations by $0.9278$4, $0.9278$5, and $0.9278$6. Optimization is implemented in PyTorch 2.4 on a single NVIDIA RTX 4090 using the LEMUR NN Dataset framework, with Optuna-based hyperparameter exploration. Adam with cosine annealing is used, with

$0.9278$7

and gradient clipping with maximum norm $0.9278$8, which is specifically noted as useful under high-$0.9278$9 distillation. The final student is trained for 200 epochs and then fine-tuned for an additional 20–30 epochs, with total training plus fine-tuning taking about 3–6 hours on one RTX 4090.

A distinctive part of the training pipeline is Progressive Context Expansion. Training begins extensively on $37.58$0 paired crops, then in fine-tuning expands to $37.58$1, and finally to $37.58$2 crops. The stated motivation is that a lightweight local-convolution model has a limited effective receptive field and can struggle with broad spatial structure, luminance gradients, and long-range coherence when trained only on small patches.

4. Hardware-aware deployment and “Inference Inversion”

The deployment logic of LiteDenoiseNet is inseparable from mobile memory architecture. The paper repeatedly emphasizes that practical NPU throughput is governed not only by nominal MAC count but by whether intermediate tensors fit into on-chip SRAM or cache tiles, allowing reuse without frequent off-chip transfers. Wide feature maps, transposed convolutions, and large intermediate activations are identified as obstacles to this execution style; the student is designed to avoid them.

The final model has 1.96M parameters, a 7.52 MB storage footprint, and 14.13 GMACs at Full HD resolution. Relative to the 41.6M-parameter teacher, this is a $37.58$3 parameter reduction. The trained student is exported from PyTorch to TensorFlow Lite using AI Edge Torch. The authors introduce a wrapper for the tensor-layout conversion from PyTorch’s NCHW to NHWC so that the permutations are fused into the execution graph, making the model compatible with standard Android image buffers and avoiding explicit runtime tensor rearrangement overhead. They report numerical parity between PyTorch and CPU-executed TFLite, with maximum deviation less than $37.58$4. Two TFLite variants are generated: a dynamic-resolution model for full-resolution quality evaluation and a fixed-resolution FP16 model with input shape $37.58$5 for official latency benchmarking.

The paper characterizes the resulting deployment behavior as “Inference Inversion.” Because LiteDenoiseNet uses only NPU-native operators and avoids fallback-prone components, the dedicated NPU becomes faster than the integrated mobile GPU. Under the Full HD benchmark protocol, the model takes 132.0 ms on the mobile GPU on average, compared with 46.1 ms on the Snapdragon 8 Elite NPU and 34.0 ms on the Dimensity 9500 NPU. The corresponding speedups are about $37.58$6 on Snapdragon and $37.58$7 on Dimensity (Kayani et al., 5 May 2026).

5. Quantitative performance and ablation evidence

The strongest quantitative claim for LiteDenoiseNet is that distillation closes most of the quality gap between a very small student and a much larger teacher. Without distillation, the 16-filter student reaches only $37.58$8 dB, leaving a $37.58$9 dB gap to the teacher’s $0.9098$0 dB. After distillation, the student rises to $0.9098$1 dB in the challenge headline numbers, reducing the gap to only $0.9098$2 dB. The abstract characterizes this as recovering $0.9098$3 of teacher quality. In a more detailed validation-set analysis, the teacher obtains $0.9098$4 dB and the distilled student $0.9098$5 dB on the 50-image validation set, with mean paired gap $0.9098$6 dB and 95% CI $0.9098$7.

The staged ablation sequence clarifies how the final design was selected. A 0.34M-parameter attention-augmented lightweight model reached only 31.68 dB and failed to compile for deployment. The 41.6M-parameter teacher reached 37.71 dB but failed at high-resolution NPU inference due to out-of-memory. An ultra-light 12-filter baseline had 0.35M parameters, 34.86 dB PSNR, and valid 26.4 ms latency, but oversmoothed textures. The undistilled 16-filter baseline had 1.96M parameters, 36.08 dB PSNR, and 46.1 ms latency. The final distilled student retained the same 1.96M parameters and the same 46.1 ms latency while improving to 37.66 dB. Distillation therefore adds 1.58 dB with no runtime cost.

The paper also limits several common misreadings of the benchmark. First, the teacher can be converted to TFLite, but it still cannot run at 8MP on the target NPU because it exceeds SRAM or memory-tiling limits and produces out-of-memory failure. Second, the official runtime protocol is Full HD rather than true 8MP latency, so reported timing numbers should be interpreted as challenge-compliant measurements rather than literal end-to-end smartphone camera latency. Third, the student’s advantage is not just low arithmetic cost; it is low arithmetic cost combined with operator compatibility and memory locality.

6. Position within lightweight denoising research

LiteDenoiseNet should be distinguished from the broader category of “lightweight denoisers.” Earlier work includes parameter-light architectures whose lightweightness is primarily architectural or statistical rather than hardware-native. LIDIA, for example, is a lightweight learned image denoiser with instance adaptation that uses 61.6K parameters and separable transforms on non-local patch groups, but its inference cost remains substantial because it still extracts overlapping patches, performs nearest-neighbor search, and processes grouped patches, with computation described as similar to DnCNN’s (Vaksman et al., 2019).

Mobile-oriented denoising had also already appeared in raw-image restoration. “Practical Deep Raw Image Denoising on Mobile Devices” describes a light-weight, efficient raw Bayer denoiser for smartphones that runs at 70.70 ms per megapixel on a Qualcomm Snapdragon 855 GPU and uses a sensor-specific Poisson-Gaussian noise model together with the analytically derived k-Sigma Transform to normalize ISO variation. That work is directly mobile-practical, but it does not introduce LiteDenoiseNet as a formal model name and does not frame the problem around NPU-native operator co-design (Wang et al., 2020).

Thunder represents another distinct branch of lightweight denoising. It reformulates real-image denoising around an RGB thumbnail bottleneck, Haar wavelet decomposition, and subspace-projection refinement, reaching 39.47 dB / 0.957 on SIDD with 2.68M parameters and 18.81 GFlops. Its central strategy is to reconstruct a compact thumbnail first and then restore high-frequency signal details. This suggests an alternative path to compact denoising: lightweightness can arise from constraining the latent representation itself rather than from distillation or mobile operator selection (Zhou et al., 2022).

Lightweight Transformer studies further broaden the context. A comparative study of seven lightweight Transformer denoisers around a $0.9098$8M-parameter regime reports that local spatial self-attention is more effective than channel self-attention in this setting and shows that denoising comparisons are highly sensitive to the exact random crop regions used in training. A plausible implication is that lightweight denoising research has progressively shifted from parameter counting alone toward a combination of architectural inductive bias, training protocol control, and deployment realism (Choi et al., 2023).

Within that landscape, LiteDenoiseNet is specifically notable because the name refers to a concrete 2026 student model rather than a generic label. Its distinctive contribution is the coupling of three elements that earlier lightweight denoisers usually treated separately: high-fidelity supervision from a 41.6M-parameter teacher, a student architecture restricted to NPU-native primitives, and explicit accommodation of tiled-memory mobile execution. The paper’s release statement further notes that the lightweight student model and its training statistics are provided in the NN Dataset repository (Kayani et al., 5 May 2026).