GB-LSR: Local Spectral Decoding with a Learned Global Bandwidth for Arbitrary-Scale Super-Resolution

arXiv:2606.19617 · cs.CV, cs.GR, cs.LG · Submitted 2026-06-17 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: AI Radio. Generated commentary on the latest Artificial Intelligence papers.

Tom: I'm Tom, and with me are Jane, Lu, senior AI researcher at Tsinghua, Meng, lead engineer at a mysterious AI startup and Lalam, the in-house Large Language Model.

Jane: Today's paper: "GB-LSR: Local Spectral Decoding with a Learned Global Bandwidth for Arbitrary-Scale Super-Resolution".

Tom: GB-LSR presents a fixed-grid local spectral representation that utilizes a single trainable global scalar bandwidth to achieve continuous image reconstruction.

Jane: First, who's behind it and why it matters.

Title and authors: Tom: So, we're diving into this new research today with the paper titled "GB-LSR: Local Spectral Decoding with a Learned Global Bandwidth for Arbitrary-Scale Super-Resolution." We’ve been hearing some exciting things about how this method handles both reconstruction and upscaling.

Jane: It sounds like it's tackling two major hurdles in image processing simultaneously, Tom. The title suggests they've found a way to do continuous image reconstruction while also making super-resolution tasks much more efficient.

Lu: What’s really interesting about this paper is the structure itself; they use a fixed-grid local spectral representation, which means they partition the image into square patches and each patch uses coefficients from a truncated Fourier basis. This is quite clever for capturing both local detail and global frequency information at once <ref:2606.19617#pg1>.

Meng: From an engineering standpoint, the "fixed-grid" part sounds promising because it suggests a predictable computational cost per query, which is something we really need for real-time systems. How does this structure compare to what we usually see in other local implicit representations?

Lalam: I think the core idea is powerful because it balances expressiveness and speed, which is exactly what we need as models get bigger and more complex <ref:2606.19617#pg2>. The authors focus on how to achieve this trade-off effectively.

Tom: Exactly, Lalam, they’ve shown that you can get good reconstruction quality while keeping the cost per query independent of image size, which is a huge win for scalability. Jane, can you explain what the paper actually proposes as its main method?

Jane: Well, the central idea of GB-LSR is using a single trainable global scalar bandwidth that is shared across every patch and every image to control the spectral resolution. This single parameter dictates how much frequency content each patch captures <ref:2606.19617#pg0>.

Lu: And they really tested three ways to handle this bandwidth parameter, which is where the real methodological depth comes in. They looked at a trainable global scalar, a fixed global scalar, and even a per-patch bandwidth field where the field itself is predicted by an adaptivity head <ref:2606.19617#pg0>.

Meng: That level of exploration into the bandwidth handling variants suggests they’re trying to find the most robust way to tune that spectral control mechanism, which is often a tricky part in these types of models. Does that mean one variant is definitely superior?

Lalam: The paper points out that empirical tests showed that the main variant, GB-LSR-Scalar, actually performs better on native reconstruction benchmarks like Kodak and Set14 by two point eight to three point six dB PSNR <ref:2606.19617#pg0>.

Title and authors: Tom: That performance gain is significant when you factor in the efficiency, because they manage to do this while running at roughly one-quarter of the slowest baseline’s inference cost <ref:2606.19617#pg0>. That’s a really solid trade-off for anyone looking at deployment.

Jane: It means we get better reconstruction quality without having to pay a massive computational price for every single query coordinate, which is what continuous image representation demands <ref:2606.19617#pg1>.

Lu: And the paper also explored arbitrary-scale extensions, showing that this local spectral approach works well for super-resolution tasks too, achieving results competitive with established methods under a canonical SR protocol <ref:2606.19617#pg0>.

Meng: I’m looking at the cost analysis here; they state the local spectral decoder has a fixed per-query cost of O(p squared max), which is independent of image size, and under the matched-budget protocol, GB-LSR-Scalar runs at zero point two four seven times the slowest baseline on every dataset <ref:2606.19617#pg0>. That’s what we need for our hardware constraints.

Lalam: And when they extended it for arbitrary-scale super-resolution, the base GB-LSR-Scalar runs one point four four times faster than LIIF-RDN and three point two five times faster than LTE-SwinIR at a factor of four <ref:2606.19617#pg0>. That speedup is substantial for upscaling pipelines.

Tom: It’s clear that the efficiency metrics are where this work really shines compared to some of the other complex baselines we’ve seen recently. Jane, how do we know they settled on the single global scalar instead of letting each patch adapt its own bandwidth?

Jane: They justified that choice through two specific tests. First, a closed-form locality diagnostic showed that the learned per-patch bandwidth field collapses to a near-constant value within each image, with a median within-image Coefficient of Variation around zero point zero one three <ref:2606.19617#pg0>.

Lu: That test result is quite compelling because it empirically supports the idea that a single global scalar parameter is sufficient to capture the necessary frequency content across the entire image context <ref:2606.19617#pg0>.

Meng: It’s interesting to hear that they found evidence for this collapse, but I wonder about the limitations of their approach. Does it mean we can’t use a per-patch field if we needed extremely fine-grained control over different image regions?

Tom: The paper also showed that testing the per-patch log-space bandwidth field variant failed to meet their required locality thresholds for proving spatial locality, which is an important caveat <ref:2606.19617#pg0>.

Lalam: So, the implication is that for most practical purposes, using a single global scalar provides a very high quality result while keeping the model architecture simpler and the training process less complicated <ref:2606.19617#pg0>.

Title and authors: Jane: And when we look at future work mentioned in the paper, they suggest exploring temporal modeling by applying this patch grid structure across time to create a continuous representation for video processing <ref:2606.19617#pg5>.

Lu: That’s where the wild possibilities come in; imagine using this fixed-grid structure to model how an image evolves over time, which could lead to incredibly efficient temporal modeling of image sequences <ref:2606.19617#pg5>.

Meng: From a practical standpoint, if we can apply this patch grid logic to video frames, it means we could potentially process sequences much faster than frame-by-frame methods currently allow. That’s a big deal for real-time video analysis.

Tom: It really shows how foundational this local spectral representation is; it’s not just about one image reconstruction, but a versatile tool for continuous representation <ref:2606.19617#pg1>.

Jane: So, to wrap up on the core findings of GB-LSR: it's a fixed-grid local spectral method controlled by a single trainable global scalar that achieves strong reconstruction quality while maintaining efficient, image-size independent inference costs <ref:2606.19617#pg0>.

Lu: And the arbitrary-scale extensions demonstrate its utility across different tasks like native reconstruction and super-resolution, proving its versatility in handling various scale requirements <ref:2606.19617#pg0>.

Meng: The practical implication is that we have a solid foundation for building highly efficient, scalable image processing modules that can be deployed in constrained environments <ref:2606.19617#pg0>.

Lalam: And from my perspective as the model, this advance in continuous representation could fundamentally improve how we generate and understand complex visual data across different scales and contexts <ref:2606.19617#pg5>.

Tom: So, to summarize our discussion on GB-LSR: we’ve seen a method that cleverly uses a single global bandwidth parameter within a fixed-grid local spectral representation to achieve better performance than matched-budget baselines while significantly cutting inference costs <ref:2606.19617#pg0>.

Jane: It’s all about finding that sweet spot between how much detail we capture and how fast we can query it, which this paper seems to nail quite well <ref:2606.19617#pg1>.

Lu: The way they handle the bandwidth parameter, testing fixed versus adaptive ones, gives us a clear roadmap for future spectral representation designs in this area <ref:2606.19617#pg0>.

Meng: For us at the startup level, focusing on that fixed-grid cost independence is what makes this immediately relevant for deploying scalable AI solutions <ref:2606.19617#pg0>.

Lalam: And ultimately, this work suggests that simpler, globally controlled mechanisms can lead to highly effective and efficient models for continuous image representation <ref:2606.19617#pg5>.

The paper's summary: Tom: So, to quickly recap, we’ve been looking at how GB-LSR uses a fixed grid and a single global scalar to handle both image reconstruction and super-resolution tasks with efficiency that beats many established methods.

Jane: Right, Tom; essentially they’ve found a way to make the AI model smarter about its frequency control without making it computationally heavy for every query coordinate.

Lu: What really gets me is the flexibility they built in by testing different ways to handle that bandwidth parameter, from a single global scalar to per-patch fields, and seeing which one actually worked best.

Meng: From an engineering standpoint, the fact that this structure keeps the per-query cost fixed regardless of how big or small the image is is what makes me interested; that’s a huge win for deployment on constrained hardware.

Lalam: I think the core advancement here lies in simplifying the architecture; they showed that a single global scalar parameter often provides enough control to get excellent results, which means less complexity to manage during training and inference.

Tom: Exactly, Lalam, and Jane is right that this simplification leads to better overall performance metrics on native images compared to baselines that have more complex per-patch tuning <ref:2606.19617#pg0>.

Jane: And when we look at the super-resolution extension they built, it shows this method isn't just for reconstruction; it’s genuinely useful for upscaling images to completely different sizes while keeping performance competitive <ref:2606.19617#pg0>.

Lu: The arbitrary-scale extension is where I see the most creative potential; thinking about using this local spectral framework not just for static images but for modeling how a scene might look at different distances or resolutions, it opens up entirely new avenues <ref:2606.19617#pg5>.

Meng: It’s cool, Lu, but I have to ground this in reality; the speedup they report in the extension is impressive for a method that handles continuous image representation, so we need to make sure that efficiency translates into real-world latency reductions on our production systems <ref:2606.19617#pg0>.

Lalam: I feel like this advance in continuous representation could fundamentally improve how we generate and understand complex visual data across different scales and contexts, which is a major step forward for any generative culture <ref:2606.19617#pg5>.

Tom: It really sounds like they’ve built a versatile tool that bridges the gap between high-quality detail capture and practical computational speed, moving us closer to models that can handle massive amounts of visual data efficiently.

Jane: And the way they handled the comparisons against those established baselines shows just how much better this approach is when you factor in both quality and inference speed simultaneously <ref:2606.19617#pg0>.

Lu: It’s fascinating to see how they managed to isolate the locality issue by showing that a single global scalar actually works, which gives us a solid theoretical underpinning for why we might simplify our future architectures <ref:2606.19617#pg0>.

Meng: So, if we take this efficiency and combine it with the temporal modeling ideas they touched on in their future work, we could potentially build real-time video analysis tools that are way more practical than what we have today <ref:2606.19617#pg5>.

Lalam: I think the most impactful vision here is how this foundational representation allows us to create more nuanced and efficient methods for understanding complex visual data, which is going to make AI systems much more insightful <ref:2606.19617#pg5>.

The paper's improvements: Tom: So, we’ve been talking about how GB-LSR works, and now Jane is going to break down all the specific improvements they propose for this method and what that means for us <ref:2606.19617#pg3>.

Jane: Absolutely, Tom; the paper suggests a few ways we can refine this architecture, focusing on simplifying the tuning mechanism and expanding its use cases across different imaging tasks <ref:two thousand six hundred six point one nine six one seven#pg3.

Lu: What’s really striking is their suggestion to move toward a fixed global bandwidth rather than letting every single patch decide its own spectral resolution, which they argue makes the optimization much cleaner and more stable <ref:two thousand six hundred six point one nine six one seven#pg0.

Meng: That stability is great because it means we spend less time debugging complex, highly adaptive systems; having a single global control parameter makes the entire model's behavior much easier to predict and deploy reliably <ref:two thousand six hundred six point one nine six one seven#pg3.

Tom: Right, and they also pointed out that for super-resolution, we can integrate it into a standalone extension that works across different scales without needing a whole new model from scratch <ref:two thousand six hundred six point one nine six one seven#pg0.

Jane: That’s significant because it means one core representation can handle both high-quality reconstruction and diverse upscaling needs, which really broadens its practical application <ref:two thousand six hundred six point one nine six one seven#pg3.

Lalam: I see the potential for this in terms of culture; if we can build systems that are this versatile and efficient across different scales, it means AI tools become accessible and powerful for a much wider variety of creative and technical endeavors <ref:two thousand six hundred six point one nine six one seven#pg5.

Lu: And looking ahead, the idea to apply this patch grid structure across time dimensions for video processing is a wild thought; imagine modeling how an image evolves over sequence using this spectral partitioning instead of just treating frames independently <ref:two thousand six hundred six point one nine six one seven#pg5.

Meng: If that temporal modeling can be done efficiently, it could lead to real-time video analysis tools that are much more practical than what we have today, which is a huge goal for our startup <ref:two thousand six hundred six point one nine six one seven#pg5.

Tom: It really sounds like they’ve laid out a clear roadmap for taking this representation from a powerful reconstruction tool to something that handles continuous, multi-scale data efficiently, and I'm genuinely hyped about that direction <ref:two thousand six hundred six point one nine six one seven#pg3.

Jane: Exactly; the paper shows us how to build something fundamentally robust by focusing on simplifying the control mechanism while simultaneously opening up new capabilities for complex tasks like video understanding <ref:two thousand six hundred six point one nine six one seven#pg3.

Conclusion: Tom: So, we've covered how GB-LSR uses its fixed-grid local spectral representation and a single global scalar bandwidth to achieve great results in both image reconstruction and super-resolution tasks <ref:2606.19617#pg0>.

Jane: It’s clear that this work provides a solid foundation for building image processing modules that are both high-quality and computationally efficient across various scales <ref:2606.19617#pg3>.

Lu: The core idea of using a single, globally trained scalar to control the spectral bandwidth is really elegant because it simplifies the complexity we usually see in these local representations <ref:2606.19617#pg0>.

Meng: From an engineering standpoint, this level of efficiency means we can deploy AI solutions in environments where computational resources are limited without sacrificing visual fidelity <ref:two thousand six hundred six point one nine six one seven#pg3.

Lalam: This approach to continuous image representation has the potential to fundamentally improve how we generate and understand complex visual data across different scales and contexts, which is a major step forward for any generative culture <ref:2606.19617#pg5>.

Tom: It really shows that you don't need overly complicated per-patch tuning if you can find a globally effective control mechanism, which is something many of us have been chasing <ref:two thousand six hundred six point one nine six one seven#pg0.

Jane: Precisely, Tom; the paper demonstrates that balancing expressiveness and speed is achievable with this fixed-grid local spectral representation <ref:2606.19617#pg3>.

Lu: I think the next big step is exploring how this same patch grid structure can be applied to temporal data, which could unlock incredibly efficient methods for video analysis <ref:two thousand six hundred six point one nine six one seven#pg5.

Meng: If that temporal modeling can be done without a massive increase in computational load, it opens up new practical applications for real-time video processing pipelines <ref:two thousand six hundred six point one nine six one seven#pg5.

Lalam: And I see this as a way to make powerful visual understanding tools more accessible and capable for everyone, not just those with massive compute resources <ref:two thousand six hundred six point one nine six one seven#pg5.

Tom: Alright, so we’ve seen how GB-LSR uses a fixed-grid local spectral representation and a single global scalar bandwidth to achieve great results in both image reconstruction and super-resolution tasks <ref:two thousand six hundred six point one nine six one seven#pg0.

Jane: It’s clear that this work provides a solid foundation for building image processing modules that are both high-quality and computationally efficient across various scales <ref:2606.19617#pg3>.

Lu: The core idea of using a single, globally trained scalar to control the spectral bandwidth is really elegant because it simplifies the complexity we usually see in these local representations <ref:two thousand six hundred six point one nine six one seven#pg0.

Meng: From an engineering standpoint, this level of efficiency means we can deploy AI solutions in environments where computational resources are limited without sacrificing visual fidelity <ref:two thousand six hundred six point one nine six one seven#pg3.

Lalam: This approach to continuous image representation has the potential to fundamentally improve how we generate and understand complex visual data across different scales and contexts, which is a major step forward for any generative culture <ref:two thousand six hundred six point one nine six one seven#pg5.

Tom: It really shows that you don't need overly complicated per-patch tuning if you can find a globally effective control mechanism, which is something many of us have been chasing <ref:two thousand six hundred six point one nine six one seven#pg0.

Jane: Precisely, Tom; the paper demonstrates that balancing expressiveness and speed is achievable with this fixed-grid local spectral representation <ref:2606.19617#pg3>.

Lu: I think the next big step is exploring how this same patch grid structure can be applied to temporal data, which could unlock incredibly efficient methods for video analysis <ref:two thousand six hundred six point one nine six one seven#pg5.

Meng: If that temporal modeling can be done without a massive increase in computational load, it opens up new practical applications for real-time video processing pipelines <ref:two thousand six hundred six point one nine six one seven#pg5.

Lalam: And I see this as a way to make powerful visual understanding tools more accessible and capable for everyone, not just those with massive compute resources <ref:two thousand six hundred six point one nine six one seven#pg5.

Naeem Khoshnevis, Max Shad

Kempner Institute for the Study of Natural and Artificial Intelligence · Harvard University

cs.CV, cs.GR, cs.LG

Submitted: 2026-06-17

Updated: 2026-10-02

Comments: 28 pages, 11 figures, 16 tables; v2: substantially revised and retitled; the main evaluation is now arbitrary-scale super-resolution against released checkpoints, and the native-reconstruction experiments are a design study of GB-LSR variants

Code: https://github.com/KempnerInstitute/gblsr

Project page: https://www.robots.ox.ac.uk/~vgg/data/dtd

License: http://creativecommons.org/licenses/by-nc-nd/4.0/

Importance score: 90/100

The gist: GB-LSR presents a fixed-grid local spectral representation that utilizes a single trainable global scalar bandwidth to achieve continuous image reconstruction.

Key concepts

Fixed-Grid Local Spectral Representation
The image is divided into non-overlapping square patches. Each patch stores coefficients from a truncated Fourier basis derived from shared encoder features. This structure allows continuous reconstruction by combining local patch coefficients based on their spatial overlap, regardless of the original image size.
Global Scalar Bandwidth
GB-LSR uses one single, trainable scalar value applied uniformly across all patches and the entire image. This parameter controls the spectral cutoff order for each patch's Fourier basis. It is learned during training to optimize reconstruction quality across different scales.
Arbitrary-Scale Super-Resolution (ASR)
This extension allows GB-LSR to perform super-resolution tasks on images of any size, not just the original input size. The method maintains efficiency, achieving competitive performance and speedups over traditional methods like LIIF and LTE when applied to these variable resolutions.

Terminology

Summary

GB-LSR presents a fixed-grid local spectral representation that utilizes a single trainable global scalar bandwidth to achieve continuous image reconstruction. This method matters because it demonstrates superior performance over existing matched-budget amortized baselines while significantly reducing inference cost, establishing a strong trade-off between expressiveness and computational efficiency for both native reconstruction and arbitrary-scale super-resolution tasks.

The Core Representation

GB-LSR is a fixed-grid local spectral representation where the image domain is partitioned into non-overlapping square patches. Each patch carries coefficients for a truncated Fourier basis, predicted from shared convolutional encoder features by a single linear projection. The continuous reconstruction at any query coordinate is defined by Equation (1), which involves a bounded local combination of the coefficient tensors of the patches whose local supports contain the query point, scaled by the spectral basis evaluated at that point. This structure ensures that a query at u touches a constant-size neighborhood of patches, independent of image size.

Bandwidth Handling Variants

The paper investigates three variants for handling the bandwidth parameter 's' in Equation (1):

  1. GB-LSR-Scalar (main): A single trainable global scalar bandwidth applied identically to every patch and image, mapped through a log-space sigmoid bounded by [0.25, 2.0].

  2. GB-LSR-Fixed: A fixed global scalar bandwidth (s0 = 1.125) and a fixed effective cutoff order at pmax, isolating the local spectral basis with no trainable spectral hyperparameters.

  3. GB-LSR-Full: A per-patch log-space bandwidth field se = exp(θe), where θe is predicted by a linear adaptivity head on spatial encoder features, replacing the global scalar 's'. This variant also predicts a per-patch effective cutoff order.

Performance on Native Reconstruction

On the standardized 256×256 native-reconstruction benchmark across Kodak, Set14, and Urban100 datasets, the main variant GB-LSR-Scalar outperforms matched-budget amortized LIIF / LTE / WIRE baselines by 2.8–3.6 dB PSNR and 0.11–0.15 LPIPS. Furthermore, GB-LSR-Scalar runs at roughly one-quarter of the slowest baseline’s inference cost. The comparison is strictly scoped to the matched-budget amortized protocol, where baselines are trained in a single amortized pass.

Inference Cost Analysis

The local spectral decoder has a fixed per-query cost of O(p squared max) multiply-adds, which is independent of image size. Under the matched-budget protocol, GB-LSR-Scalar runs at 0.247× the slowest baseline on every dataset. In an arbitrary-scale super-resolution (ASR) extension, the base GB-LSR-Scalar runs 1.44× faster than LIIF-RDN and 3.25× faster than LTE-SwinIR at ×4. Further optimizations in the ASR extension, such as disabling 4-corner local ensemble averaging (noLE variant), yield a 1.77× speedup with 35% lower peak memory.

Locality and Ablation Justification

The paper empirically justifies the single global scalar choice through two tests: a closed-form locality diagnostic and a per-patch log-space adaptive-bandwidth ablation. The locality diagnostic shows that the learned per-patch bandwidth field collapses to a near-constant value within each image, with the within-image CoV median being approximately 0.013, supporting the conclusion that a single global scalar suffices empirically. The per-patch log-space ablation fails to meet its criteria for proving spatial locality, showing that neither per-patch bandwidth field (GB-LSR-Bandwidth or GB-LSR-Full) meets the required locality thresholds (0/4).

Arbitrary-Scale Super-Resolution Extension

The GB-LSRScalarASR extension is evaluated against canonical LIIF / LTE / LTE-SwinIR baselines under a separate canonical SR protocol. The method achieves competitive PSNR-Y under a canonical-style SR protocol and demonstrates strong efficiency, running at 1.44× faster than LIIF-RDN and 3.25× faster than LTE-SwinIR at ×4 timing cells. The extension's variants show that the noLE variant provides a 1.77× arithmetic-mean speedup with negligible PSNR change, while widening the RDN encoder to 96 channels yields a small positive PSNR shift with a 1.58× speedup and 31% lower peak memory.

Improvements for AI systems

Based on the GB-LSR (Global-Bandwidth Local Spectral Representation) paper, here are specific, actionable improvements for AI systems and what those improved systems can achieve:

Improvement 1: Implement a Fixed-Grid Local Spectral Representation Decoder with a Single Global Trainable Bandwidth.

The core improvement is replacing standard neural field decoders (like MLPs or local implicit functions) with the GB-LSR architecture. This system partitions the image into non-overlapping square patches, and each patch stores coefficients for a truncated Fourier basis. A single global scalar bandwidth parameter dictates the spectral resolution across all patches.

The improved AI system can:

  1. Maintain a fixed, small computational cost per query coordinate, independent of the total image size (a significant inference speedup).

  2. Achieve state-of-the-art performance on native image reconstruction benchmarks (Kodak, Set14, Urban100), outperforming matched-budget baselines by 2.8–3.6 dB PSNR and 0.11–0.15 LPIPS under the same parameter budget.

  3. Be highly efficient for continuous image representation tasks where querying any coordinate at any density is required, as the decoder cost is bounded per pixel query, unlike traditional MLP decoders whose cost scales with image size or complexity of the learned field.

Improvement 2: Utilize a Single Global Trainable Scalar Bandwidth for Optimal Spectral Tuning.

Instead of allowing each patch to independently adapt its spectral resolution (as in GB-LSR-Full), the system should use a single, globally trained scalar bandwidth parameter. Empirical evidence suggests this single global control suffices because the learned bandwidth field collapses to a near-constant value within each image.

The improved AI system can:

  1. Reduce model complexity and training overhead by eliminating per-patch spectral hyperparameters (like the effective cutoff order).

  2. Maintain high quality (PSNR) while significantly simplifying the optimization landscape, as the single global scalar is sufficient for capturing necessary frequency content across the entire image context.

Improvement 3: Integrate an Arbitrary-Scale Super-Resolution Extension for General Image Upscaling.

Extend the GB-LSR model into a standalone arbitrary-scale SR module (GB-LSR-Scalar-ASR) that operates on a shared Residual Dense Network (RDN) encoder and maintains its local spectral decoder structure.

The improved AI system can:

  1. Perform high-quality upscaling across various scales (e.g., ×2 to ×8), handling both in-distribution and out-of-distribution image resolutions effectively without requiring a new model architecture for every scale.

  2. Achieve competitive PSNR scores against canonical SR methods (like LIIF-RDN and LTE-SwinIR) while running significantly faster (1.44× to 3.25× speedup) under fixed GPU latency protocols compared to complex, canonical-style implementations.

Improvement 4: Optimize Inference Cost for Real-Time Applications via Architectural Sparsity Variants.

Implement inference optimization strategies derived from the GB-LSR family, specifically by disabling redundant mechanisms like 4-corner local ensemble averaging (GB-LSR-Scalar-ASR) or widening the RDN encoder channels to 96.

The improved AI system can:

  1. Achieve substantial speedups (up to 1.77× arithmetic mean speedup) and memory reductions while maintaining negligible PSNR degradation in high-resolution tasks, making it suitable for deployment on edge devices or real-time applications where low latency is critical.

Improvement 5: Develop a Robust Continuous Image Representation Framework for Video Processing.

Leverage the fixed-grid local spectral representation to create a temporal model by applying this patch grid structure across the time dimension (i.e., sharing local spectral coefficients across frames).

The improved AI system can:

  1. Enable video reconstruction tasks where the per-pixel decodercost bound is preserved, allowing for efficient temporal modeling of image sequences by operating on the spatial patch grid of coefficient blocks rather than processing pixels directly in a frame-by-frame manner.

Abstract

We present GB-LSR (Global-Bandwidth Local Spectral Representation), a fixed-grid local spectral representation for continuous image decoding. The image domain is partitioned into non-overlapping square patches. Each patch carries coefficients for a truncated Fourier basis, predicted by a single linear projection from shared convolutional-encoder features, and one trainable scalar bandwidth is shared across every patch and every image. As in earlier local spectral decoders, decoding at a continuous coordinate is a fixed-size basis contraction whose cost is set by the spectral cutoff; GB-LSR learns the bandwidth of that basis instead of fixing it. We evaluate an arbitrary-scale super-resolution extension, GB-LSR-Scalar-ASR, against the authors' released LIIF, LTE, and SRNO checkpoints on the same RDN encoder, with every method scored under one protocol and timed in one session per scale, each on one GPU. It runs 1.25x faster than LIIF-RDN at x4 and as fast as SRNO-RDN, whose released code uses 15 times as much peak memory on Urban100. It trails the three encoder-matched baselines by 0.07 to 0.79 dB PSNR-Y in distribution, SRNO-RDN by 0.35 dB on average. Removing the local ensemble raises the speedup to 2.41x over LIIF-RDN and 1.95x over SRNO-RDN at x4, and to 3.00x and 2.41x at x8, without changing PSNR-Y beyond seed variation, at the cost of value jumps at cell boundaries of 0.22 gray levels (of 255) on average at x4. Against the EDSR-baseline checkpoints of five recent methods at x4, GB-LSR-Scalar-ASR scores above or within 0.17 dB on PSNR-Y of LMF, SRNO-EDSR, and OPE-SR-EDSR (1.39 to 6.43 million parameters against 22.02) and 0.14 to 0.57 dB below GSASR and Thera (20.44 and 5.85 million), and has a higher mean LPIPS at x4 than every baseline.

Related papers