CrossRefine: A Microservice for Cross-Domain Spatial Super-Resolution

1 Introduction

High-resolution spatial fields are required by many downstream applications (hydrology, urban planning, precision agriculture), yet common operational and research pipelines produce outputs at coarse grids because increasing physicalmodel resolution is computationally expensive. For example, global reanalyses and operational forecasts are often supplied at resolutions on the order of 0.25◦ - 1◦ [Hersbach et al., 2020], which limits the representation of orography, coastlines, and urban structure. In practice, users either run costly regional dynamical nests or accept interpolated coarse fields; both options have clear trade-offs in cost, latency, or fidelity.

We formulate the problem as multi-channel spatial superresolution [Wang et al., 2020]. Let XLR ∈ RC×n×m denote a stack of coarse channels (temperature, winds, pressure, precipitation, etc.) and XHR ∈ RC×N×M the desired highresolution product with N = k · n,M = k · m. The goal is to learn a parametric mapping fθ : XLR ↦→ XHR that (i) reconstructs fine spatial structure, (ii) preserves large-scale consistency, and (iii) is robust across geographic domains. Key practical constraints include limited HR training data in many regions, the need to avoid creating physically implausible artifacts, and the requirement that the module be lightweight and deployable as a post-processing service.

Prior work in computer vision (SRCNN [Dong et al., 2015], UNet [Ronneberger et al., 2015]) and generative modeling (SRGAN [Ledig et al., 2017]) provides building blocks for this task; however, three domain-specific gaps remain for operational use: (1) single-region models overfit local statistics and do not generalize across heterogeneous terrains, (2) pointwise losses (MAE/MSE) produce overly smooth fields that miss localized extremes, and (3) many proposals ignore integration and latency requirements for real-time pipelines. Global products such as ERA5 [Hersbach et al., 2020] and operational forecasts (GFS [NOAA NCEP, 2024]) are attractive training sources but exhibit region-dependent error characteristics that a practical model must accommodate.

In this work we adopt a systems-oriented approach: treat enhancement as a modular, deployable microservice and design the learning objective and architecture to satisfy crossregion generalization and operational constraints. Concretely, we (i) train a unified topography-conditioned UNet generator across diverse regions, (ii) introduce an adversarial loss to recover high-frequency structure while retaining a channelweighted regression term for numerical fidelity, and (iii) optimize for inference efficiency and streaming deployment on commodity hardware. The demonstration uses public reanalysis/forecast products (e.g., from NOAA) to illustrate generalization, latency/throughput trade-offs, and qualitative gains over interpolation and non-adversarial baselines.

2 SystemArchitecture

2.1 Processing Pipeline

Ingestion: tiled NetCDF/zarr [Ambatipudi and Byna, 2023] inputs (or streamed tiles) are converted to GPU tensors by a scalable loader. Training uses public reanalysis/forecast sources (e.g., ERA5 and GFS) for geographic diversity.

Preprocessing: per-channel geo-aware normalization, alignment to a static topo channel, and LR simulation via controlled avg-pooling (×2, ×4). Tile sizes are chosen to fit GPU memory (e.g., 200×200 HR).

Model family: interchangeable generators (residual SRCNN [Jha et al., 2025], topography-conditioned UNet [Vandal et al., 2017; Sha et al., 2020; Chiang et al., 2024], adversarial UNet [Sch¨onfeld et al., 2021]) accept C×H×W tensors and output residual HR corrections. Loss is channel-weighted regression plus optional adversarial/perceptual term; simple physics checks (e.g., non-negative precipitation) are applied.

Training & generalization: multi-region sharded batches, data augmentation, and channel weighting to avoid dominance by large-magnitude fields; held-out regions verify cross-domain generalization.

Inference & deployment: packaged as a microservice with batched GPU queues and container manifests for batch or edge deployment. Seam-aware stitching and reprojection utilities assemble tiles into mosaics.

Performance & safety: tunable knobs (batch size, tile size, precision) and per-tile diagnostics (latency, baseline RMSE, physics flags). A conservative confidence mask can suppress adversarial detail where reliability is low.

2.2 Frontend Interface

Live demo UI: side-by-side panels (LR input, bicubic, UNet, SRGAN, reference when available), tile selector, and toggles for scale factor and adversarial weight.

Operational controls: upload tile or point to Zarr, trigger batch jobs, view per-tile latency/throughput, and inspect diagnostics and confidence maps.

Integration hooks: example client snippets (REST API / xpublish), and short instructions to embed the microservice into existing pipelines or cloud workflows for on-site demos.

3 Technical Implementation

The implementation is engineered for reproducible experiments and real-time demoability while retaining fidelity to operational constraints.

Data & preprocessing. Training uses public reanalysis and operational forecast archives: ERA5 (2018-2021) for train/validation and GFS (2022) as a held-out test. Input tiles contain five dynamic channels (T2m, U10, V10, MSLP, TP) plus a static topography channel; files are stored as NetCDF/zarr and loaded via xarray into PyTorch tensors. We cut global fields into HR tiles (typical 200×200), simulate LR inputs using controlled avg-pooling (×2, ×4), and apply geo-aware per-channel normalization together with rotations, small translations, and seasonal stratification to improve cross-region robustness. Tile metadata (geo bounds, time) is preserved to enable reprojection and seam-aware stitching at inference.

Model implementations. All models share C×H×W I/O schema and are implemented in PyTorch. WeatherSRCNN is a compact, residual SRCNN variant adapted for multichannel inputs with early concatenation of topo information.

WeatherUNet is a three-level encoder-decoder with DoubleConv blocks and skip connections; it predicts a residual correction added to bilinear upsampling to preserve large-scale structure. WeatherSRGAN pairs the UNet generator with a purpose-built discriminator (8 conv blocks with progressive downsampling and two FC layers) so the generator learns to recover high-frequency textures while keeping numerical consistency.

Losses & optimization. We optimize a hybrid objective: a channel-weighted regression term (MAE) ensures numerical fidelity-T2m and TP receive higher weights to avoid domination by large-magnitude fields such as pressure, and a small adversarial term (λ = 0.005) plus optional perceptual loss recovers structural realism. The discriminator uses binary cross-entropy; training employs Adam with standard learning-rate scheduling, gradient clipping, and alternating update steps to stabilize GAN training. Simple physics checks (e.g., non-negative precipitation) are computed during training and can be turned into soft penalty terms for conservative deployments.

Training & generalization. To produce a single multiregion model we mix tiles from different geographic shards and years within minibatches, use augmentation and seasonal sampling, and validate on held-out regions to detect overfitting to local climatologies. GAN stability is managed by limiting adversarial weight, using occasional discriminator freezes, and monitoring RMSE/MAE alongside perceptual metrics; typical training runs span ∼30 epochs per data shard with early stopping based on cross-region validation.

Inference, deployment & performance. The model is packaged as a Docker microservice exposing REST/gRPC endpoints for tiled inference and optional S3/zarr triggers. Inference supports mixed-precision (FP16) and an int8 quantization path for edge/booth hardware; tunable parameters include tile size, batch size, and precision to trade throughput vs. latency. Outputs include HR tiles, optional per-pixel confidence maps, and per-tile diagnostics (latency, baseline RMSE, physics flags); seam-aware stitching and reprojection utilities produce mosaics suitable for visualization or downstream ingestion.

Tools & reproducibility. Python, xarray, and PyTorch; the release bundle ships training recipes, prebuilt containers, a small test dataset, and Kubernetes manifests for single-GPU or small-cluster reproduction.

4 Demonstration &Evaluation

The performance of WeatherSRCNN, WeatherUNet, and WeatherSRGAN was evaluated using ERA5 reanalysis data and the GFS025 forecast dataset. For both sources, two input degradation scenarios were considered: spatial downscaling by a factor of ×2 and ×4, followed by reconstruction to the original 0.25◦ × 0.25◦ grid.

RMSE was used as evaluation metric for each of the five variables (T2M, U10, MSLP, TP), as well as aggregated values across all channels. The ERA5 dataset (2018-2021) was used for training and validation, while GFS025 (2022) served as an external test set to assess the generalization capability of the models.

4.1 Quantitative Evaluation

The comparison results on ERA5 are presented in Table 1, and those on GFS025 are shown in Table 2. In all scenarios, the deep learning models substantially outperform bicubic interpolation.

It is important to note that on the external GFS025 test set, the differences between UNet and SRGAN remain consistent, indicating good generalization capability of the proposed adversarial architecture.

4.2 Qualitative Demonstration

To illustrate the differences between the methods, we present reconstruction maps of the surface temperature field (T2M) over Europe and the zonal wind component (U10) over the northern part of South America.

As shown in Figure 1, bicubic interpolation results in smoothing of temperature gradients, particularly in regions of strong advection. WeatherSRCNN partially restores spatial structure; however, a noticeable loss of high-frequency components remains. WeatherSRGAN provides sharper reconstruction of frontal boundaries and localized anomalies, while the corresponding error map exhibits lower amplitude and more spatially organized residual patterns.

A similar pattern is observed for zonal wind speed (Figure 2). In areas with complex coastlines and orography, WeatherSRGAN more effectively reproduces fine-scale circulation structures, whereas interpolation-based methods tend to smooth them out. This is particularly important for local forecasting tasks and the assessment of extreme events.

5 Conclusion

This paper presents a deployable, topography-conditioned module that performs multi-channel spatial super-resolution across heterogeneous regions. Trained on reanalysis archives (e.g., ERA5) and evaluated on operational forecasts (e.g., GFS), the system demonstrates consistent numerical improvements over interpolation and non-adversarial baselines while recovering sharper local structure. The implementation is production-oriented: a Dockerized microservice with mixed-precision and quantization paths, tile stitching, and per-tile diagnostics for latency, error, and confidence. Future work will emphasize rigorous uncertainty quantification, stronger physics-aware constraints, and broader domain transfer; we also stress careful presentation of generated detail (confidence masks and physics checks) to avoid misinterpretation of synthesized high-frequency features.

Acknowledgements

The work was supported by a grant, provided by the Ministry of Economic Development of the Russian Federation (agreement dated June 20, 2025 No. 139-15-2025-011, identifier 000000C313925P4G0002).