🤖 AI

SRGAN-CKAN: Expressive Super-Resolution with Nonlinear Functional Operators under Minimal Resources

This paper proposes SRGAN-CKAN, a resource-efficient super-resolution framework that integrates Convolutional Kolmogorov-Arnold Networks into an adversarial setting to replace linear convolutions with expressive nonlinear functional operators, achieving a superior balance between perceptual quality and reconstruction fidelity under constrained computational resources.

Original authors: Roberto Isai Navaro-Aviña, Eduardo Said Merin-Martinez, Andres Mendez-Vazquez, Eduardo Rodriguez-Tello

Published 2026-05-06

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Roberto Isai Navaro-Aviña, Eduardo Said Merin-Martinez, Andres Mendez-Vazquez, Eduardo Rodriguez-Tello

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 blurry, low-quality photo of a forest. You want to make it look sharp and detailed, like a high-definition picture, but you only have the blurry version to start with. This is the problem of Super-Resolution: trying to guess and recreate the missing details (like the texture of leaves or the bark on a tree) that got lost when the photo was shrunk down.

Usually, computers try to solve this by using massive, complex systems that act like giant, heavy-duty factories. They are powerful but require expensive, high-end computers to run.

This paper introduces a new, lighter approach called SRGAN-CKAN. Here is how it works, explained simply:

1. The Old Way vs. The New Way

The Old Way (Standard Convolution): Imagine a stamp that presses a pattern onto a piece of paper. In traditional computer vision, this "stamp" is a linear tool. It's like a cookie cutter that only cuts straight lines. It's good at smoothing things out, but it struggles to recreate complex, wiggly details like fur or grass because it can only do simple math (multiplication and addition) on small patches of the image.
The New Way (CKAN): The authors replaced that simple cookie cutter with a smart, flexible sculptor. They used a mathematical concept called a Kolmogorov-Arnold Network (KAN). Instead of just pressing a flat pattern, this new tool uses splines (think of them as flexible, bendable rulers). It can bend and twist to fit the exact shape of the details it sees. It looks at a tiny patch of the image and says, "This isn't just a straight line; it's a curve, a bump, and a swirl," and it molds the pixels to match that complexity.

2. The "Artist and the Critic" (Adversarial Training)

The paper uses a technique called GAN (Generative Adversarial Network), which is like a game between two people:

The Artist (Generator): Tries to draw a super-sharp picture from the blurry one.
The Critic (Discinator): Tries to spot if the picture is real or a fake drawing.

They play this game over and over. The Artist gets better at fooling the Critic, and the Critic gets better at spotting fakes. Eventually, the Artist learns to create images that look so real, even the Critic can't tell the difference.

3. The Magic Ingredient: "Minimal Resources"

Usually, making an Artist that creates such realistic art requires a supercomputer (like a massive GPU). However, the authors built their "Artist" using the new CKAN tool.

Because the CKAN tool is so efficient at modeling complex shapes, the whole system doesn't need to be huge or deep. It's like building a house with a few very clever, multi-purpose tools instead of a warehouse full of single-use hammers.

The Result: They ran this entire system on a standard, mid-range laptop graphics card (an NVIDIA RTX 4060). They didn't need a supercomputer. They managed to create high-quality, realistic images using very little memory and computing power.

4. The Trade-Off: Sharpness vs. Accuracy

There is a known problem in this field:

If you try to be perfectly accurate (matching every pixel exactly), the image looks smooth but boring (like a painting that looks like plastic).
If you try to be visually realistic (adding sharp textures), the image might look great but lose some mathematical accuracy.

The paper claims that SRGAN-CKAN found a "sweet spot." It managed to make the image look very realistic and sharp (great for human eyes) without losing too much of the original structure. It did this better than older methods that tried to do the same thing but required much more computing power.

Summary

The authors took a difficult problem (fixing blurry photos), replaced the standard "linear" math tools with "flexible, bending" math tools (CKAN), and proved that you can get high-quality, realistic results without needing a supercomputer. It's a way to get the "art" back into the photo using a lighter, more efficient engine.

Technical Summary: SRGAN-CKAN

Problem Statement

Single-Image Super-Resolution (SISR) is an ill-posed inverse problem aimed at reconstructing a High-Resolution (HR) image from a single Low-Resolution (LR) observation. The challenge lies in recovering high-frequency details that are severely degraded during acquisition or transmission. While recent advances using transformer-based architectures and diffusion models have improved global context modeling and perceptual quality, they often incur significant computational complexity. Conversely, traditional Convolutional Neural Networks (CNNs) rely on linear local mappings followed by pointwise nonlinearities, which limits their expressive capacity for modeling complex local structures and high-frequency textures without increasing model depth or width.

Methodology

The paper proposes SRGAN-CKAN, a hybrid super-resolution framework that integrates Convolutional Kolmogorov–Arnold Networks (CKAN) into the adversarial learning setting of SRGAN. The core innovation is the reformulation of the standard convolutional operator as a nonlinear, patch-based transformation.

The CKAN Operator

Instead of treating convolution as a linear projection of local patches ( $y_{i,j} = w^\top p_\ell$ ), the CKAN operator processes each local patch vector $p_\ell$ through a learnable nonlinear mapping $g(\cdot)$ implemented via a Kolmogorov–Arnold Network (KAN).

Mechanism: The input feature map is unfolded into overlapping local patches. Each patch vector is processed by a KAN layer consisting of two components:
1. A factorized linear transformation using learnable coefficients and fixed basis matrices.
2. A spline-based nonlinear transformation where each input dimension is approximated using learnable spline basis functions ( $\phi(x) = \sum \alpha_m B_m(x)$ ).
Integration: These components are aggregated, normalized, and reshaped back into the spatial feature map. This allows the model to capture richer local dependencies and complex, context-dependent relationships between neighboring pixels without significantly increasing architectural complexity.

Architecture and Training

The SRGAN-CKAN architecture retains the standard SRGAN structure:

Generator: Transforms LR inputs into HR estimates using residual blocks where standard convolutions are replaced by CKAN operators. It includes initial feature extraction, a residual trunk, and upsampling stages.
Discriminator: Evaluates the perceptual realism of generated images against real HR targets using hierarchical texture analysis.
Training Protocol: The model follows a two-stage training process under constrained resources (NVIDIA RTX 4060, 8GB VRAM, batch size 1):
1. Supervised Pretraining (SRResNet phase): Optimized using content loss to ensure structural consistency.
2. Adversarial Fine-tuning (SRGAN phase): Jointly optimizes the generator and discriminator using a combination of content, pixel, and adversarial losses to enhance perceptual quality.

Key Contributions

Reformulation of Convolution: The authors introduce a patch-wise functional representation of local image transformations within the SRGAN framework using a Kolmogorov–Arnold-inspired projection mechanism (CKAN).
Implementation of a Complete Pipeline: The work designs and implements a full training pipeline, including supervised pretraining and adversarial fine-tuning, specifically optimized for minimal hardware resources.
Controlled Experimental Analysis: The study provides a controlled comparison demonstrating that the proposed model improves perceptual quality while preserving reconstruction fidelity, achieving a favorable trade-off between distortion-based (PSNR, MS-SSIM) and perceptual (LPIPS) metrics.

Experimental Results

The model was evaluated on the DIV2K dataset (subset of 1600 images) with a $\times4$ upscaling factor.

Fidelity vs. Perception: Transitioning from the pretraining stage (SRResNet-CKAN) to the adversarial stage (SRGAN-CKAN) resulted in a minimal degradation in PSNR (decrease of 0.055 dB) and MS-SSIM (decrease of 0.0022), while significantly improving LPIPS (from 0.2124 to 0.1947).
Comparison with Baselines: Compared to a conventional convolutional SRGAN baseline, SRGAN-CKAN achieved higher PSNR (24.90 dB vs. 20.07 dB) and MS-SSIM, alongside a substantial reduction in LPIPS (0.1947 vs. 0.3226).
Resource Efficiency: These results were achieved under constrained computational settings (single GPU, limited batch size), contrasting with state-of-the-art methods that often require high-end hardware and extensive training iterations.

Significance and Claims

The paper claims that SRGAN-CKAN introduces a complementary direction to existing approaches by enhancing the representational power of local transformations rather than relying on globally intensive architectures. By replacing linear local mappings with spline-based functional representations, the method enables expressive modeling of complex local structures and high-frequency textures using minimal hardware resources.

The authors emphasize that this approach provides an efficient and scalable alternative to transformer-based or diffusion models, successfully balancing the inherent trade-off between reconstruction fidelity and perceptual realism in adversarial super-resolution. The work highlights the potential of integrating functional representations (specifically KANs) into deep learning architectures for image restoration tasks.