File size: 4,701 Bytes
52e5c4f c11b2ea 52e5c4f fc7ad5f 52e5c4f fc7ad5f 52e5c4f fc7ad5f 52e5c4f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 | ---
license: cc-by-nc-4.0
tags:
- super-resolution
- arbitrary-scale-super-resolution
- image-restoration
- implicit-neural-representation
- gblsr
pipeline_tag: image-to-image
metrics:
- psnr
- ssim
- lpips
---
# GB-LSR: Global-Bandwidth Local Spectral Representation
[](https://arxiv.org/abs/2606.19617) [](https://doi.org/10.48550/arXiv.2606.19617)
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](https://arxiv.org/abs/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:
```bash
pip install git+https://github.com/KempnerInstitute/gblsr
```
**Native reconstruction (GB-LSR-Scalar):**
```python
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):**
```python
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
```bibtex
@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}
}
```
|