KempnerInstituteAI/gblsr

GB-LSR: Global-Bandwidth Local Spectral Representation

Trained weights for GB-LSR, a fixed-grid local spectral image representation: the image is partitioned into non-overlapping patches, each carrying a small block of truncated-Fourier coefficients predicted from a shared convolutional encoder, with a single trainable scalar bandwidth shared globally across all patches. Reconstruction at any continuous coordinate is a fixed-size basis contraction whose cost is independent of image size.

Code: https://github.com/KempnerInstitute/gblsr · Paper: arXiv:2606.19617.

Models

Folder	Model	Params	Notes
gblsr-scalar	GB-LSR-Scalar (native reconstruction)	0.99M	main native-benchmark variant
gblsr-scalar-asr	GB-LSR-Scalar-ASR (base)	22.02M	arbitrary-scale SR, RDN encoder
gblsr-scalar-asr-noLE	ASR, no local ensemble	22.02M	faster; trained + eval'd without 4-corner LE
gblsr-scalar-asr-nf96-noLE	ASR, wider encoder + noLE	24.93M	small quality gain
gblsr-scalar-asr-nf48-noLE	ASR, narrower encoder + noLE	20.61M	aggressive-efficiency

One representative seed (seed 0) is released per model; per-seed variance is negligible (e.g. ASR PSNR-Y std about 0.004 dB).

Usage

Install the package (provides the architecture), then load the weights:

pip install git+https://github.com/KempnerInstitute/gblsr

Native reconstruction (GB-LSR-Scalar):

import torch
from safetensors.torch import load_file
from gblsr import build_model, ModelConfig, BasisConfig, EncoderConfig

model = build_model(
    ModelConfig(arm="local_spectral", image_size=256, patch_size=32,
                basis=BasisConfig(patch_size=32, p_max=16, s_e_range=(0.25, 2.0)),
                encoder=EncoderConfig()),
    bandwidth_mode="global_scalar", adapt_order=False).eval()
model.load_state_dict(load_file("gblsr-scalar/model.safetensors"))

out = model(torch.rand(1, 3, 256, 256))   # dict of outputs
recon = out["recon"]                       # (1, 3, 256, 256) reconstruction

Arbitrary-scale SR (any GB-LSR-Scalar-ASR variant):

import torch
from safetensors.torch import load_file
from gblsr import GBLSRScalarASR

# match encoder_cfg / decoder_cfg to the folder's config.json
model = GBLSRScalarASR(encoder_cfg={"num_features": 96},
                       decoder_cfg={"local_ensemble": False}).eval()   # nf96+noLE
model.load_state_dict(load_file("gblsr-scalar-asr-nf96-noLE/model.safetensors"))

lr = torch.rand(1, 3, 64, 64)
hr = model.predict_full(lr, H_q=256, W_q=256)   # (1, 3, 256, 256), any target size

Each model's exact build config is in its config.json.

Training

All variants trained on a DTD + DIV2K mixture (native) / DIV2K (ASR), three seeds, AdamW, pointwise MSE. The ASR models train for 1,000,000 steps. See the paper's appendix for the full protocol.

Evaluation (summary)

Under a fixed matched-budget protocol, GB-LSR-Scalar outperforms matched-budget amortized LIIF / LTE / WIRE re-implementations on the standardized 256x256 native-reconstruction benchmark while running at roughly one-quarter of the slowest baseline's inference cost. The arbitrary-scale base model runs 1.44x faster than LIIF-RDN and 3.25x faster than LTE-SwinIR at x4 with competitive PSNR-Y; the noLE / nf-variants trade quality for further speed and memory. Full tables, baselines, and the scope of the comparison are in the paper; these are not state-of-the-art claims over the broader SR literature.

License and attribution

Released under CC BY-NC 4.0 (non-commercial). The weights are derived from training on DIV2K ("for academic research purpose only") and DTD; downstream use must respect those source-dataset terms. The gblsr code is BSD-3-Clause; this non-commercial term applies to the trained weights here.

Citation

@article{shad2026gblsr,
  title   = {GB-LSR: A Fast Local Spectral Image Representation with a
             Single Global Bandwidth for Continuous Reconstruction and
             Super-Resolution},
  author  = {Shad, Max and Khoshnevis, Naeem},
  journal = {arXiv preprint arXiv:2606.19617},
  year    = {2026}
}