SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2605.16163 · 2026

SwAIther-Precip: Lead-Time-Aware Bias Correction Enables Kilometer-Scale Downscaling of Global AI Precipitation Forecasts over Switzerland

Tom Beucler, Thibaut Loiseau, Dan Assouline, Erwan Koch, Federico Amato, Filippo Quarenghi, Daniele Nerini, Kyle Van De Langemheen

arXiv · PDF · Open in the Atlas

Code that ran

7 of 11 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 1 violated it and 1 has no contract verdict; 5 failures of our instrument; 4 no recorded run), measured 2026-11-22; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2605.16163.json · badge: /api/ran/2605.16163.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
danassou/swaither-precip canonical (classifier label)
classifier basis: census
7 ran · 4 no recorded run
FunctionStatusWhere it lives
build_baseline_spatiotemporal_from_dataset Ran
ran on a synthesized input
danassou/swaither-precip/swaither/models/baselines_bias_correction.py
code served (permissive licence) · get_code("252555d743d5b7df")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned dict. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

class StandInDataset:
    """Minimal dataset that returns (img_clean, img_lr, lead, time)"""
    
    def __init__(self, num_samples=10):
        self.num_samples = num_samples
        self._H = 4
        self._W = 3
        self._C_in = 2
        self._C_out = 1
    
    def image_shape(self):
        return (self._H, self._W)
    
    def input_channels(self):
        return list(range(self._C_in))
    
    def output_channels(self):
        return list(range(self._C_out))
    
    def __len__(self):
        return self.num_samples
    
    def __getitem__(self, idx):
        # img_clean: (C_out, H, W)
        img_clean = torch.randn(self._C_out, self._H, self._W, dtype=torch.float32)
        # img_lr: (C_in, H, W)
        img_lr = torch.randn(self._C_in, self._H, self._W, dtype=torch.float32)
        # lead: scalar tensor
        lead = torch.tensor([idx % 3], dtype=torch.float32)  # 3 different lead values
        # time: scalar tensor
        time = torch.tensor([idx // 3], dtype=torch.float32)  # multiple time steps
        
        return (img_clean, img_lr, lead, time)

base_dataset = StandInDataset(num_samples=12)
train_idx = [0, 1, 2, 3, 4, 5]
val_idx = [6, 7, 8, 9, 10, 11]

ARGS = {
    'base_dataset': base_dataset,
    'train_idx': train_idx,
    'val_idx': val_idx,
    'precip_out_channel': 0,
    'dtype': np.float32,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
denorm_and_delog Ran
ran; our contract draft was wrong, not the code
danassou/swaither-precip/swaither/helpers/bc_inference.py
code served (permissive licence) · get_code("6a24c09798af23e4")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 4, dtype family float, shape (2, 4, 3, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

class MockDataset:
    def __init__(self):
        self.output_min = [0.1, 0.2, 0.3, 0.4]
        self.output_max = [1.0, 2.0, 3.0, 4.0]

dataset = MockDataset()

y_norm = torch.randn(2, 4, 3, 5)

ARGS = {
    "dataset": dataset,
    "y_norm": y_norm,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float, shape (2, 4, 3, 5) — shape (2, 4, 3, 5) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
flatten_spatiotemporal Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
danassou/swaither-precip/swaither/models/baselines_bias_correction.py
code served (permissive licence) · get_code("84c4315e059ba4d6")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

np.random.seed(0)

# Create test data with shapes (T, L, H, W, C) for feats and (T, L, H, W) for target
T, L, H, W, C = 2, 3, 4, 5, 6

# Create features array: (T=2, L=3, H=4, W=5, C=6)
feats = np.random.randn(T, L, H, W, C).astype(np.float32)

# Create target array: (T=2, L=3, H=4, W=5)
target = np.random.randint(0, 2, size=(T, L, H, W)).astype(np.int32)

# Create optional mask_valid array: (T=2, L=3, H=4, W=5)
# Set most values to True, a few to False to test masking
mask_valid = np.random.rand(T, L, H, W) > 0.1

ARGS = {
    "feats": feats,
    "target": target,
    "mask_valid": mask_valid,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
plot_fss_by_lead Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
danassou/swaither-precip/swaither/helpers/bc_plots.py
code served (permissive licence) · get_code("35029967a378cf74")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import matplotlib.pyplot as plt

# Create baseline data: dict of model names -> list of dicts (one per lead time)
baselines = {
    'Baseline1': [
        {'FSS_1': 0.65, 'FSS_5': 0.72, 'FSS_17': 0.85},
        {'FSS_1': 0.63, 'FSS_5': 0.70, 'FSS_17': 0.83},
        {'FSS_1': 0.61, 'FSS_5': 0.68, 'FSS_17': 0.81},
        {'FSS_1': 0.59, 'FSS_5': 0.66, 'FSS_17': 0.79},
        {'FSS_1': 0.57, 'FSS_5': 0.64, 'FSS_17': 0.77},
        {'FSS_1': 0.55, 'FSS_5': 0.62, 'FSS_17': 0.75},
    ],
    'Baseline2': [
        {'FSS_1': 0.68, 'FSS_5': 0.74, 'FSS_17': 0.87},
        {'FSS_1': 0.66, 'FSS_5': 0.72, 'FSS_17': 0.85},
        {'FSS_1': 0.64, 'FSS_5': 0.70, 'FSS_17': 0.83},
        {'FSS_1': 0.62, 'FSS_5': 0.68, 'FSS_17': 0.81},
        {'FSS_1': 0.60, 'FSS_5': 0.66, 'FSS_17': 0.79},
        {'FSS_1': 0.58, 'FSS_5': 0.64, 'FSS_17': 0.77},
    ],
}

# Create multi-lead model data: dict of model names -> {split -> {per_lead -> list of dicts}}
multi_lead_models = {
    'Model1': {
        'val': {
            'per_lead': [
                {'FSS_1': 0.72, 'FSS_5': 0.78, 'FSS_17': 0.89},
                {'FSS_1': 0.70, 'FSS_5': 0.76, 'FSS_17': 0.87},
                {'FSS_1': 0.68, 'FSS_5': 0.74, 'FSS_17': 0.85},
                {'FSS_1': 0.66, 'FSS_5': 0.72, 'FSS_17': 0.83},
                {'FSS_1': 0.64, 'FSS_5': 0.70, 'FSS_17': 0.81},
                {'FSS_1': 0.62, 'FSS_5': 0.68, 'FSS_17': 0.79},
            ]
        }
    },
    'Model2': {
        'val': {
            'per_lead': [
                {'FSS_1': 0.75, 'FSS_5': 0.80, 'FSS_17': 0.91},
                {'FSS_1': 0.73, 'FSS_5': 0.78, 'FSS_17': 0.89},
                {'FSS_1': 0.71, 'FSS_5': 0.76, 'FSS_17': 0.87},
                {'FSS_1': 0.69, 'FSS_5': 0.74, 'FSS_17': 0.85},
                {'FSS_1': 0.67, 'FSS_5': 0.72, 'FSS_17': 0.83},
                {'FSS_1': 0.65, 'FSS_5': 0.70, 'FSS_17': 0.81},
            ]
        }
    },
}

# Create single-lead model data: dict of model names -> (lead_idx, {split -> {global -> dict}})
single_lead_models = {
    'SingleLead1': (
        1,  # lead_idx
        {
            'val': {
                'global': {'FSS_1': 0.70, 'FSS_5': 0.77, 'FSS_17': 0.88}
            }
        }
    ),
    'SingleLead2': (
        3,  # lead_idx
        {
            'val': {
                'global': {'FSS_1': 0.68, 'FSS_5': 0.75, 'FSS_17': 0.86}
            }
        }
    ),
}

ARGS = {
    'baselines': baselines,
    'multi_lead_models': multi_lead_models,
    'single_lead_models': single_lead_models,
    'split': 'val',
    'n_leads': 6,
    'lead_time_hours': 6,
    'neighborhoods': [1, 5, 17],
    'figsize': (16, 5),
    'save_path': None,
    'suptitle': 'FSS by Lead Time',
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
matplotlib, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
plot_metric_comparison Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
danassou/swaither-precip/swaither/helpers/bc_plots.py
code served (permissive licence) · get_code("dc2db38abba95d35")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import matplotlib.pyplot as plt

# Construct valid arguments for plot_metric_comparison

# Create baseline data: dict of {name: per_lead_dict}
# Each per_lead_dict maps lead index to metric values
baselines = {
    'Baseline_Persistence': {
        i: {'MSE_all': 0.01 + i * 0.002, 'MAE_all': 0.05 + i * 0.001}
        for i in range(24)
    },
    'Baseline_Climatology': {
        i: {'MSE_all': 0.015 + i * 0.0015, 'MAE_all': 0.06 + i * 0.0008}
        for i in range(24)
    }
}

# Create multi-lead model data: dict of {name: results_dict}
# results_dict has structure: {split: {per_lead: [{metric: value}, ...]}}
multi_lead_models = {
    'Model_LSTM': {
        'val': {
            'per_lead': [
                {'MSE_all': 0.008 + i * 0.0012, 'MAE_all': 0.04 + i * 0.0006}
                for i in range(24)
            ]
        },
        'train': {
            'per_lead': [
                {'MSE_all': 0.005 + i * 0.0008, 'MAE_all': 0.03 + i * 0.0004}
                for i in range(24)
            ]
        }
    },
    'Model_Transformer': {
        'val': {
            'per_lead': [
                {'MSE_all': 0.007 + i * 0.0011, 'MAE_all': 0.038 + i * 0.0005}
                for i in range(24)
            ]
        },
        'train': {
            'per_lead': [
                {'MSE_all': 0.004 + i * 0.0007, 'MAE_all': 0.028 + i * 0.0003}
                for i in range(24)
            ]
        }
    }
}

# Create single-lead model data: dict of {name: (lead_idx, results_dict)}
# results_dict has structure: {split: {global: {metric: value}}}
single_lead_models = {
    'SingleLead_Lead6h': (
        0,  # lead_idx = 0 (6 hours ahead)
        {
            'val': {'global': {'MSE_all': 0.006, 'MAE_all': 0.035}},
            'train': {'global': {'MSE_all': 0.003, 'MAE_all': 0.025}}
        }
    ),
    'SingleLead_Lead12h': (
        1,  # lead_idx = 1 (12 hours ahead)
        {
            'val': {'global': {'MSE_all': 0.0065, 'MAE_all': 0.036}},
            'train': {'global': {'MSE_all': 0.0032, 'MAE_all': 0.026}}
        }
    ),
    'SingleLead_Lead24h': (
        3,  # lead_idx = 3 (24 hours ahead)
        {
            'val': {'global': {'MSE_all': 0.0078, 'MAE_all': 0.041}},
            'train': {'global': {'MSE_all': 0.004, 'MAE_all': 0.031}}
        }
    )
}

ARGS = {
    'baselines': baselines,
    'multi_lead_models': multi_lead_models,
    'single_lead_models': single_lead_models,
    'metric': 'MSE_all',
    'split': 'val',
    'n_leads': 24,
    'lead_time_hours': 6,
    'figsize': (14, 8),
    'ylim': (0, 0.06),
    'save_path': None,
    'title': None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
matplotlib, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
plot_metric_comparison_grouped_legend Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
danassou/swaither-precip/swaither/helpers/bc_plots.py
code served (permissive licence) · get_code("1da97e94d1e73b2c")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import matplotlib.pyplot as plt

# Create baseline data structure
# Each baseline has per-lead data with metric values
baselines = {
    'Baseline_A': [
        {'MSE_all': 0.02 + 0.001 * i} for i in range(24)
    ],
    'Baseline_B': [
        {'MSE_all': 0.025 + 0.0015 * i} for i in range(24)
    ],
}

# Create multi-lead models data structure
# Each model has split data with per_lead metrics
multi_lead_models = {
    'MultiLead_Model_1': {
        'val': {
            'per_lead': [
                {'MSE_all': 0.015 + 0.0008 * i} for i in range(24)
            ]
        }
    },
    'MultiLead_Model_2': {
        'val': {
            'per_lead': [
                {'MSE_all': 0.018 + 0.0009 * i} for i in range(24)
            ]
        }
    },
}

# Create single-lead models data structure
# Each model is a tuple of (lead_idx, results_dict)
single_lead_models = {
    'SingleLead_Model_1': (
        5,  # lead_idx = 5
        {
            'val': {
                'global': {'MSE_all': 0.022}
            }
        }
    ),
    'SingleLead_Model_2': (
        10,  # lead_idx = 10
        {
            'val': {
                'global': {'MSE_all': 0.028}
            }
        }
    ),
    'SingleLead_Model_3': (
        15,  # lead_idx = 15
        {
            'val': {
                'global': {'MSE_all': 0.035}
            }
        }
    ),
}

ARGS = {
    'baselines': baselines,
    'multi_lead_models': multi_lead_models,
    'single_lead_models': single_lead_models,
    'metric': 'MSE_all',
    'split': 'val',
    'n_leads': 24,
    'lead_time_hours': 6,
    'figsize': (15, 8),
    'ylim': (0, 0.06),
    'save_path': None,
    'title': 'Metric Comparison Test',
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
matplotlib, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
unflatten_to_grid Ran
ran, violated the contract we drafted
danassou/swaither-precip/swaither/models/baselines_bias_correction.py
code served (permissive licence) · get_code("5ee12d951a24ff34")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 4, dtype family float, shape (2, 3, 4, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create a template array with shape (T, L, H, W)
# Using distinct sizes: T=2, L=3, H=4, W=5
T, L, H, W = 2, 3, 4, 5
template = np.zeros((T, L, H, W), dtype=np.float32)

# Create y_pred_flat as a 1D array with the same total number of elements
total_elements = T * L * H * W
y_pred_flat = np.random.randn(total_elements).astype(np.float32)

ARGS = {
    "y_pred_flat": y_pred_flat,
    "template": template,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 4, dtype family float, shape (2, 3, 4, 5) — shape (2, 3, 4, 5) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
EvaluateModel Not yet run
unverified (harvested, no recorded run)
danassou/swaither-precip/swaither/helpers/bc_metrics.py
code served (permissive licence) · get_code("cebde37a3e5c1add")
How it ran

no invocation recorded.

evaluate Not yet run
unverified (harvested, no recorded run)
danassou/swaither-precip/swaither/helpers/bc_metrics.py
code served (permissive licence) · get_code("d6fea8d349063aa4")
How it ran

no invocation recorded.

evaluate_by_lead_time Not yet run
unverified (harvested, no recorded run)
danassou/swaither-precip/swaither/helpers/bc_metrics.py
code served (permissive licence) · get_code("7f606a6293b55324")
How it ran

no invocation recorded.

plot_metrics Not yet run
unverified (harvested, no recorded run)
danassou/swaither-precip/swaither/helpers/Extra_metrics_viz_helpers.py
code served (permissive licence) · get_code("321d5ff77a7ee142")
How it ran

no invocation recorded.

Also present in other papers' code

Of 11 samples lifted from this paper's linked repositories, 11 carry a function identity and 0 do not. Of the 11 distinct functions with an identity, 0 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 0 later) and 11 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

Skillful medium-range precipitation forecasting at kilometer scale remains challenging over complex terrain because precipitation arises from multiscale nonlinear processes that global models cannot explicitly resolve at affordable cost. Global AI weather models can produce skillful medium-range forecasts, but their native 0.25°resolution limits direct use for local hazard applications. Statistical downscaling can help bridge this gap, yet existing approaches often struggle with state-dependent, and especially lead-time-dependent, biases in global forecasts. We introduce SwAIther-Precip, a lead-time-aware downscaling framework that converts coarse-resolution AIFS forecasts into probabilistic km-scale precipitation fields over Switzerland. First, a U-Net conditioned on lead time via feature-wise linear modulation deterministically corrects systematic biases at coarse resolution. This targeted correction enables a cheaper super-resolution stage conditioned only on corrected precipitation, allowing direct training on observations rather than on the full atmospheric state. A diffusion-based model then generates fine-scale spatial variability independently of lead time. Using AIFS forecasts and CombiPrecip radar-gauge observations, SwAIther-Precip reduces CRPS by 48% relative to raw AIFS. The generated fields reproduce observed spatial variability with spectral fidelity above 0.85 at large scales and 0.88 at small scales, corresponding to an effective resolution of ≈4 km on a 1 km grid for lead times up to 5 days. Training across lead times further improves long-range performance, yielding a 13% CRPS reduction at 6 days relative to lead-time-specific models. These results show that explicitly correcting lead-time-dependent biases before generative super-resolution is key to efficient km-scale probabilistic downscaling of global AI precipitation forecasts. Code, training configurations, and instructions to reproduce results are publicly available at https://github.com/danassou/swaither-precip. can now make skillful global forecasts up to two weeks ahead, but they are still too coarse for local precipitation hazards in mountainous regions such as Switzerland, which is a stringent testbed because terrain strongly shapes precipitation and high-quality observations allow rigorous evaluation. We show that correcting forecast errors in a lead-time-aware way before adding fine-scale detail makes these models much more useful locally. Using forecasts from a public global artificial intelligence weather model and Swiss radar-rain gauge observations, our method produces kilometer-scale precipitation forecasts, cuts forecast error in two relative to the raw model, and preserves realistic spatial patterns out to 6 days.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("2605.16163")
get_code_for_paper("2605.16163")
have("2605.16163")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/2605.16163.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/2605.16163.svg)](https://syntology.ai/paper/2605.16163)

Connect an agent — have() is free.