gorkha 0.0.1__tar.gz

gorkha-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Angshuman Deb
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gorkha-0.0.1/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: gorkha
+Version: 0.0.1
+Summary: GORKHA: Graph-based Operational Reconnaissance Kit for Human-in-the-loop Assessment. Post-earthquake damage estimation and survey planning from sparse field surveys.
+Author-email: Angshuman Deb <angshuman311@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/angshuman311/gorkha
+Project-URL: Issues, https://github.com/angshuman311/gorkha/issues
+Keywords: earthquake,damage assessment,graph neural network,kriging,survey planning,Nepal
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: GIS
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: geopandas
+Requires-Dist: shapely
+Requires-Dist: pyogrio
+Requires-Dist: rasterio
+Requires-Dist: rasterstats
+Requires-Dist: pandas
+Requires-Dist: pyarrow
+Requires-Dist: numpy
+Requires-Dist: scikit-learn
+Requires-Dist: scipy
+Requires-Dist: pykrige
+Requires-Dist: libpysal
+Requires-Dist: esda
+Requires-Dist: matplotlib
+Requires-Dist: requests
+Requires-Dist: rapidfuzz
+Requires-Dist: joblib
+Provides-Extra: deep
+Requires-Dist: torch; extra == "deep"
+Requires-Dist: torch_geometric; extra == "deep"
+Requires-Dist: torchgeo; extra == "deep"
+Provides-Extra: sar
+Requires-Dist: asf_search; extra == "sar"
+Requires-Dist: hyp3_sdk; extra == "sar"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# GORKHA
+
+**Graph-based Operational Reconnaissance Kit for Human-in-the-loop Assessment**
+
+GORKHA estimates building damage in all wards of an earthquake region from a small number
+of field surveys, and tells the survey teams where to go next. It uses a graph of the wards,
+the early data that are available without a visit (ShakeMap, terrain, satellite images), and
+the road network with its blockages.
+
+The test case is the 2015 Gorkha earthquake sequence in Nepal (945 wards, 11 districts).
+
+Status: research code for a CS230 course project. The interfaces change without notice.
+
+## Install
+
+```bash
+pip install gorkha
+```
+
+For the deep learning parts: `pip install "gorkha[deep]"`. For the Sentinel-1 processing at
+the Alaska Satellite Facility: `pip install "gorkha[sar]"`.
+
+## Data
+
+The scripts download public data: the Nepal damage survey (NPC and Kathmandu Living Labs),
+OpenStreetMap boundaries and roads (ODbL), USGS ShakeMaps, the NASA ARIA Damage Proxy Map,
+the USGS landslide inventory, the Copernicus DEM, Sentinel-1 and Sentinel-2 images. The
+Sentinel-1 coherence needs a free NASA Earthdata account.
+
+## License
+
+MIT. See LICENSE. The data sets have their own licenses (see the data section).

gorkha-0.0.1/README.md

@@ -0,0 +1,32 @@
+# GORKHA
+
+**Graph-based Operational Reconnaissance Kit for Human-in-the-loop Assessment**
+
+GORKHA estimates building damage in all wards of an earthquake region from a small number
+of field surveys, and tells the survey teams where to go next. It uses a graph of the wards,
+the early data that are available without a visit (ShakeMap, terrain, satellite images), and
+the road network with its blockages.
+
+The test case is the 2015 Gorkha earthquake sequence in Nepal (945 wards, 11 districts).
+
+Status: research code for a CS230 course project. The interfaces change without notice.
+
+## Install
+
+```bash
+pip install gorkha
+```
+
+For the deep learning parts: `pip install "gorkha[deep]"`. For the Sentinel-1 processing at
+the Alaska Satellite Facility: `pip install "gorkha[sar]"`.
+
+## Data
+
+The scripts download public data: the Nepal damage survey (NPC and Kathmandu Living Labs),
+OpenStreetMap boundaries and roads (ODbL), USGS ShakeMaps, the NASA ARIA Damage Proxy Map,
+the USGS landslide inventory, the Copernicus DEM, Sentinel-1 and Sentinel-2 images. The
+Sentinel-1 coherence needs a free NASA Earthdata account.
+
+## License
+
+MIT. See LICENSE. The data sets have their own licenses (see the data section).

gorkha-0.0.1/pyproject.toml

@@ -0,0 +1,54 @@
+[project]
+name = "gorkha"
+version = "0.0.1"
+description = "GORKHA: Graph-based Operational Reconnaissance Kit for Human-in-the-loop Assessment. Post-earthquake damage estimation and survey planning from sparse field surveys."
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "Angshuman Deb", email = "angshuman311@gmail.com" }]
+keywords = ["earthquake", "damage assessment", "graph neural network", "kriging", "survey planning", "Nepal"]
+license = "MIT"
+license-files = ["LICENSE"]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: GIS",
+]
+dependencies = [
+    "geopandas",
+    "shapely",
+    "pyogrio",
+    "rasterio",
+    "rasterstats",
+    "pandas",
+    "pyarrow",
+    "numpy",
+    "scikit-learn",
+    "scipy",
+    "pykrige",
+    "libpysal",
+    "esda",
+    "matplotlib",
+    "requests",
+    "rapidfuzz",
+    "joblib",
+]
+
+[project.optional-dependencies]
+deep = ["torch", "torch_geometric", "torchgeo"]
+sar = ["asf_search", "hyp3_sdk"]
+test = ["pytest"]
+
+[project.urls]
+Homepage = "https://github.com/angshuman311/gorkha"
+Issues = "https://github.com/angshuman311/gorkha/issues"
+
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

gorkha-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

gorkha-0.0.1/src/gorkha/baselines.py

@@ -0,0 +1,154 @@
+"""Baseline models. Each model sees only the labels of the surveyed wards (protocol A)."""
+
+import warnings
+
+import numpy as np
+from pykrige.ok import OrdinaryKriging
+from scipy.optimize import least_squares
+from scipy.spatial.distance import pdist
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.linear_model import Ridge, RidgeCV
+from sklearn.neural_network import MLPRegressor
+
+MODELS = ["mean", "ok", "ridge", "mlp", "forest", "rk", "rk_loo", "rk_gdif"]
+MODEL_LABELS = {
+    "mean": "Mean of the surveyed wards",
+    "ok": "Ordinary kriging (no features)",
+    "ridge": "Ridge regression",
+    "mlp": "MLP",
+    "forest": "Random forest",
+    "rk": "Regression kriging, all features",
+    "rk_loo": "Regression kriging, all features, leave-one-out residuals",
+    "rk_gdif": "Regression kriging, G-DIF covariates",
+}
+RIDGE_ALPHAS = np.logspace(-2, 3, 16)
+
+# Trend covariates of the G-DIF code (GDIF_nb.Rmd): shaking intensity, elevation, and the
+# Damage Proxy Map. The engineering forecast of G-DIF is not available here.
+GDIF_FEATURES = ["mmi", "mmi_after", "elev_mean", "dpm_cover", "dpm_p90"]
+
+# Variogram fit, with the defaults of the R package gstat (the G-DIF code uses gstat):
+# cutoff at one third of the diagonal of the data, 15 lags, fit weights N / h^2.
+N_LAGS = 15
+CUTOFF_SHARE = 1.0 / 3.0
+# A small survey has too few ward pairs in the cutoff. Then the fit uses all pairs.
+MIN_PAIRS = 40
+PAIRS_PER_LAG = 20
+
+
+def exponential(h, nugget, psill, range_):
+    """Exponential variogram in the pykrige convention (practical range)."""
+    return nugget + psill * (1.0 - np.exp(-3.0 * h / range_))
+
+
+def experimental_variogram(xy: np.ndarray, z: np.ndarray) -> tuple:
+    """Lag distance, semivariance, and pair count for each lag that has a pair."""
+    d = pdist(xy)
+    g = 0.5 * pdist(z[:, None], "sqeuclidean")
+    cutoff = float(np.hypot(*np.ptp(xy, axis=0)) * CUTOFF_SHARE)
+    if (d <= cutoff).sum() < MIN_PAIRS:
+        cutoff = float(d.max())
+    inside = d <= cutoff
+    n_lags = int(np.clip(inside.sum() // PAIRS_PER_LAG, 4, N_LAGS))
+    lag = np.minimum((d[inside] / cutoff * n_lags).astype(int), n_lags - 1)
+    count = np.bincount(lag, minlength=n_lags)
+    has = count > 0
+    h = np.bincount(lag, weights=d[inside], minlength=n_lags)[has] / count[has]
+    gamma = np.bincount(lag, weights=g[inside], minlength=n_lags)[has] / count[has]
+    return h, gamma, count[has], cutoff
+
+
+def fit_variogram(xy: np.ndarray, z: np.ndarray) -> dict:
+    """Weighted least squares fit of an exponential variogram with a nugget."""
+    h, gamma, count, cutoff = experimental_variogram(xy, z)
+    var = float(np.var(z, ddof=1))
+    if len(h) < 3:
+        return {"psill": 0.0, "range": cutoff, "nugget": var}
+    weight = np.sqrt(count) / h
+    top = max(float(gamma.max()), var)
+    fit = least_squares(
+        lambda p: weight * (exponential(h, *p) - gamma),
+        x0=[0.25 * var, 0.75 * var, 0.5 * cutoff],
+        bounds=([0.0, 0.0, 0.5 * h.min()], [1.5 * top, 3.0 * top, 3.0 * cutoff]),
+    )
+    nugget, psill, range_ = fit.x
+    return {"psill": float(psill), "range": float(range_), "nugget": float(nugget)}
+
+
+def krige(xy_s: np.ndarray, z_s: np.ndarray, xy_u: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    """Ordinary kriging with a variogram fitted on the surveyed wards.
+
+    Return the prediction and the kriging variance at `xy_u`.
+    """
+    if np.ptp(z_s) < 1e-9:
+        return np.full(len(xy_u), z_s.mean()), np.zeros(len(xy_u))
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        model = OrdinaryKriging(xy_s[:, 0], xy_s[:, 1], z_s, variogram_model="exponential",
+                                variogram_parameters=fit_variogram(xy_s, z_s),
+                                enable_plotting=False, verbose=False)
+        z, ss = model.execute("points", xy_u[:, 0], xy_u[:, 1], backend="vectorized")
+    return np.asarray(z, dtype=float), np.maximum(np.asarray(ss, dtype=float), 0.0)
+
+
+def ridge_loo_residuals(xs: np.ndarray, ys: np.ndarray, alpha: float) -> np.ndarray:
+    """Leave-one-out residuals of a ridge regression with an intercept (closed form)."""
+    n = len(ys)
+    xc = xs - xs.mean(axis=0)
+    u, sv, _ = np.linalg.svd(xc, full_matrices=False)
+    shrink = sv ** 2 / (sv ** 2 + alpha)
+    leverage = np.einsum("ij,j,ij->i", u, shrink, u) + 1.0 / n
+    fitted = u @ (shrink * (u.T @ (ys - ys.mean()))) + ys.mean()
+    return (ys - fitted) / np.maximum(1.0 - leverage, 1e-6)
+
+
+def predict_all(x: np.ndarray, xy: np.ndarray, y: np.ndarray, surveyed: np.ndarray,
+                seed: int = 0, gdif_columns: list | None = None,
+                limits: tuple = (0.0, 1.0)) -> dict:
+    """Fit each baseline on the surveyed wards and predict all wards.
+
+    `x` is the standardized design matrix of all wards. The scaler uses the features of
+    all wards, which are known before a survey. It uses no label.
+    `gdif_columns` gives the columns of `x` for the G-DIF covariates.
+    `limits` gives the permitted range of the target (a fraction, or a damage grade).
+    Return {model: (prediction, standard deviation or None)}.
+    """
+    s, n = surveyed, len(y)
+    ys = y[s]
+    out = {}
+
+    out["mean"] = (np.full(n, ys.mean()), np.full(n, ys.std(ddof=1)))
+
+    z, var = krige(xy[s], ys, xy)
+    out["ok"] = (z, np.sqrt(var))
+
+    alpha = RidgeCV(alphas=RIDGE_ALPHAS).fit(x[s], ys).alpha_
+    trend = Ridge(alpha=alpha).fit(x[s], ys).predict(x)
+    out["ridge"] = (trend, None)
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        mlp = MLPRegressor(hidden_layer_sizes=(16,), alpha=1.0, solver="lbfgs", max_iter=500,
+                           random_state=seed).fit(x[s], ys)
+    out["mlp"] = (mlp.predict(x), None)
+
+    forest = RandomForestRegressor(n_estimators=100, min_samples_leaf=2, max_features=0.5,
+                                   random_state=seed, n_jobs=1).fit(x[s], ys)
+    out["forest"] = (forest.predict(x), None)
+
+    # Regression kriging: the ridge trend plus ordinary kriging of the trend residuals.
+    r, var = krige(xy[s], ys - trend[s], xy)
+    out["rk"] = (trend + r, np.sqrt(var))
+
+    # Variant: the residual of a surveyed ward comes from a trend fitted without that ward.
+    # An in-sample residual is too small when the survey has few wards.
+    r, var = krige(xy[s], ridge_loo_residuals(x[s], ys, alpha), xy)
+    out["rk_loo"] = (trend + r, np.sqrt(var))
+
+    if gdif_columns is not None:
+        xg = x[:, gdif_columns]
+        trend_g = RidgeCV(alphas=RIDGE_ALPHAS).fit(xg[s], ys).predict(xg)
+        r, var = krige(xy[s], ys - trend_g[s], xy)
+        out["rk_gdif"] = (trend_g + r, np.sqrt(var))
+
+    return {k: (np.clip(p, *limits), sd) for k, (p, sd) in out.items()}

gorkha-0.0.1/src/gorkha/campaign.py

@@ -0,0 +1,263 @@
+"""Simulated survey campaigns: where do the teams go next, and what does it cost?
+
+A campaign has rounds. In each round, a method selects one ward for each team. The teams
+travel on the open roads (shortest travel time), survey the wards, and the labels become
+visible. The cost of a round is the travel time plus a fixed survey time for each ward.
+A ward that no open road reaches costs a helicopter trip.
+
+Three methods (decision of 2026-10-07):
+- "random": regression kriging estimate (survey and feature table), random wards.
+- "kriging": regression kriging estimate, wards with the largest kriging variance. The
+  roads matter only for the route to the selected wards.
+- "sherpa": GNN estimate with uncertainty. A second network gives a visit score for each
+  ward. It sees the road state and learns from damage maps that the model draws from its
+  own uncertainty.
+"""
+
+import numpy as np
+import torch
+from sklearn.linear_model import Ridge, RidgeCV
+from torch import nn
+from torch_geometric.nn import GATv2Conv
+
+from . import baselines, gnn
+from .roads import HELICOPTER_HOURS, SURVEY_HOURS
+
+# ---------------------------------------------------------------- kriging
+
+
+def kriging_variance(xy_s: np.ndarray, xy_all: np.ndarray, p: dict) -> np.ndarray:
+    """Ordinary kriging variance at all wards for surveyed positions and a fixed variogram."""
+    def gamma(h):
+        return np.where(h > 0, p["nugget"] + p["psill"] * (1 - np.exp(-3 * h / p["range"])), 0.0)
+    m = len(xy_s)
+    a = np.ones((m + 1, m + 1))
+    a[:m, :m] = gamma(np.linalg.norm(xy_s[:, None] - xy_s[None], axis=2))
+    a[m, m] = 0.0
+    b = np.ones((m + 1, len(xy_all)))
+    b[:m] = gamma(np.linalg.norm(xy_s[:, None] - xy_all[None], axis=2))
+    w = np.linalg.solve(a + 1e-10 * np.eye(m + 1), b)
+    return np.maximum((w * b).sum(axis=0), 0.0)
+
+
+def regression_kriging(x, xy, y, surveyed):
+    """Ridge trend on the features and kriging of the leave-one-out residuals.
+
+    Return the estimate, the standard deviation, and the residuals at the surveyed wards.
+    """
+    alpha = RidgeCV(alphas=baselines.RIDGE_ALPHAS).fit(x[surveyed], y[surveyed]).alpha_
+    trend = Ridge(alpha=alpha).fit(x[surveyed], y[surveyed]).predict(x)
+    resid = baselines.ridge_loo_residuals(x[surveyed], y[surveyed], alpha)
+    r, var = baselines.krige(xy[surveyed], resid, xy)
+    return np.clip(trend + r, 0, 1), np.sqrt(var), resid
+
+
+def select_kriging(xy, resid, surveyed, n_pick: int) -> list:
+    """Wards with the largest kriging variance of the residuals, one after the other.
+
+    After each selection, the variance is calculated again as if that ward were surveyed.
+    """
+    p = baselines.fit_variogram(xy[surveyed], resid)
+    if p["psill"] <= 1e-9:
+        p = {"psill": max(np.var(resid), 1e-4), "range": 30.0, "nugget": 0.0}
+    have = surveyed.copy()
+    picks = []
+    for _ in range(n_pick):
+        var = kriging_variance(xy[have], xy, p)
+        var[have] = -1.0
+        i = int(np.argmax(var))
+        picks.append(i)
+        have[i] = True
+    return picks
+
+
+# ---------------------------------------------------------------- travel and cost
+
+
+def nearest_team_hours(travel: np.ndarray, teams: list) -> np.ndarray:
+    """Cost in hours for the nearest team to reach and survey each ward."""
+    t = travel[teams].min(axis=0)
+    return np.where(np.isfinite(t), t, HELICOPTER_HOURS) + SURVEY_HOURS
+
+
+def assign_and_move(picks: list, teams: list, travel: np.ndarray) -> tuple[float, list, int]:
+    """Give each selected ward to a team (shortest travel first). Return cost, positions, flights."""
+    teams, left, cost, flights = list(teams), list(picks), 0.0, 0
+    free = list(range(len(teams)))
+    while left and free:
+        t = travel[np.ix_([teams[k] for k in free], left)]
+        t = np.where(np.isfinite(t), t, HELICOPTER_HOURS + 1e3)   # a flight only if no road
+        a, b = np.unravel_index(np.argmin(t), t.shape)
+        hours = t[a, b]
+        if hours >= 1e3:
+            hours, flights = HELICOPTER_HOURS, flights + 1
+        cost += hours + SURVEY_HOURS
+        teams[free[a]] = left[b]
+        free.pop(a)
+        left.pop(b)
+    return cost, teams, flights
+
+
+# ---------------------------------------------------------------- SHERPA visit score
+
+
+class VisitScorer(nn.Module):
+    """Network for the visit score (output 3). Edges carry the distance and the road time."""
+
+    def __init__(self, n_in: int = 6, hidden: int = 32):
+        super().__init__()
+        self.inp = nn.Linear(n_in, hidden)
+        self.convs = nn.ModuleList(GATv2Conv(hidden, hidden // 4, heads=4, edge_dim=3) for _ in range(3))
+        self.out = nn.Linear(hidden, 1)
+
+    def forward(self, x, edge_index, edge_attr):
+        h = torch.relu(self.inp(x))
+        for conv in self.convs:
+            h = h + torch.relu(conv(h, edge_index, edge_attr))
+        return self.out(h).squeeze(-1)
+
+
+def kernel_matrix(xy: np.ndarray, range_km: float) -> np.ndarray:
+    d = np.linalg.norm(xy[:, None] - xy[None], axis=2)
+    return np.exp(-3 * d / range_km)
+
+
+def imagined_benefit(sd, kern, cost, travel, surveyed, rng, n_maps: int = 24, lookahead: float = 0.5,
+                     chol=None):
+    """Benefit for each hour of a visit to each ward, on damage maps drawn from the model.
+
+    A map is the model estimate plus an error with the model standard deviation and a
+    spatial correlation. A visit to ward i shows its error r_i. The estimate of ward j then
+    moves by kern_ij * r_i. The benefit is the decrease of the absolute error over all
+    wards. The second term is the best benefit for each hour that is reachable after i.
+    """
+    n = len(sd)
+    if chol is None:
+        chol = np.linalg.cholesky(kern + 1e-6 * np.eye(n))
+    benefit = np.zeros(n)
+    for _ in range(n_maps):
+        r = sd * (chol @ rng.standard_normal(n))
+        after = np.abs(r[None, :] - kern * r[:, None])          # row i: errors after a visit to i
+        gain = (np.abs(r)[None, :] - after)
+        gain[:, surveyed] = 0.0
+        benefit += gain.sum(axis=1)
+    benefit /= n_maps
+    benefit[surveyed] = 0.0
+    rate = benefit / cost
+    step = np.where(np.isfinite(travel), travel, HELICOPTER_HOURS) + SURVEY_HOURS
+    follow = (benefit[None, :] / step)
+    np.fill_diagonal(follow, 0.0)
+    return rate + lookahead * follow.max(axis=1) * (benefit > 0)
+
+
+def learned_scores(sd, mean, surveyed, xy, pairs, travel, teams, range_km, seed) -> np.ndarray:
+    """Train the visit scorer on imagined maps and return its score for each ward."""
+    rng = np.random.default_rng([11, seed])
+    torch.manual_seed(seed)
+    kern = kernel_matrix(xy, range_km)
+    chol = np.linalg.cholesky(kern + 1e-6 * np.eye(len(sd)))
+    cost = nearest_team_hours(travel, teams)
+    reach = np.isfinite(travel[teams].min(axis=0)).astype(float)
+    x = np.column_stack([sd / sd.mean(), mean, surveyed.astype(float), np.log(cost), reach,
+                         np.log1p(np.isfinite(travel).sum(axis=1))])
+    t_edge = travel[pairs[:, 0], pairs[:, 1]]
+    open_edge = np.isfinite(t_edge)
+    attr = np.column_stack([np.linalg.norm(xy[pairs[:, 0]] - xy[pairs[:, 1]], axis=1) / 10,
+                            np.where(open_edge, np.log1p(t_edge), 0.0), open_edge.astype(float)])
+    dev = gnn.DEVICE
+    to = lambda a, t=torch.float32: torch.as_tensor(np.ascontiguousarray(a), dtype=t, device=dev)
+    xt = to(x)
+    edges = to(np.concatenate([pairs, pairs[:, ::-1]]).T, torch.long)
+    attr_t = to(np.concatenate([attr, attr]))
+    free = torch.as_tensor(~surveyed, device=dev)
+    model = VisitScorer(x.shape[1]).to(dev)
+    opt = torch.optim.Adam(model.parameters(), lr=5e-3, weight_decay=1e-4)
+    for _ in range(120):
+        target = imagined_benefit(sd, kern, cost, travel, surveyed, rng, n_maps=4, chol=chol)
+        target = to(target / (target[~surveyed].mean() + 1e-9))
+        loss = ((model(xt, edges, attr_t) - target)[free] ** 2).mean()
+        opt.zero_grad()
+        loss.backward()
+        opt.step()
+    with torch.no_grad():
+        score = model(xt, edges, attr_t).cpu().numpy()
+    score[surveyed] = -np.inf
+    return score
+
+
+def select_sherpa(sd, mean, surveyed, xy, pairs, travel, teams, n_pick, range_km, seed,
+                  learned: bool = True) -> list:
+    """Select wards one after the other. After each selection, the team moves there in the
+    plan, and the uncertainty near the selected ward decreases."""
+    sd, teams, have = sd.copy(), list(teams), surveyed.copy()
+    kern = kernel_matrix(xy, range_km)
+    rng = np.random.default_rng([13, seed])
+    picks = []
+    for k in range(n_pick):
+        if learned and k == 0:
+            base = learned_scores(sd, mean, have, xy, pairs, travel, teams, range_km, seed)
+            base_cost = nearest_team_hours(travel, teams)
+        if learned:
+            # The score is a benefit for each hour. Update it for the moved teams and for the
+            # decreased uncertainty without a new training in the same round.
+            cost = nearest_team_hours(travel, teams)
+            score = base * (base_cost / cost) * (sd / sd0 if k else 1.0)
+        else:
+            cost = nearest_team_hours(travel, teams)
+            score = imagined_benefit(sd, kern, cost, travel, have, rng)
+        score = np.where(have, -np.inf, score)
+        i = int(np.argmax(score))
+        picks.append(i)
+        if k == 0:
+            sd0 = sd.copy()
+        t = travel[teams, i]
+        teams[int(np.argmin(np.where(np.isfinite(t), t, 1e6)))] = i
+        have[i] = True
+        sd = sd * (1 - kern[i])
+        sd0 = np.maximum(sd0, 1e-9)
+    return picks
+
+
+# ---------------------------------------------------------------- campaign
+
+
+def run(method: str, x, xy, y, pairs, edges, travel, start_wards: list, rounds: int, seed: int = 0,
+        members: int = 3, learned: bool = True, x_sherpa=None) -> list:
+    """Run one campaign. Return one record for each round (round 0 is the start).
+
+    `x` is the feature table (input 3) for the kriging cases. `x_sherpa` is the input of
+    SHERPA: the feature table with the image vectors (inputs 3 and 4). If it is None,
+    SHERPA uses `x`.
+    """
+    x_sherpa = x if x_sherpa is None else x_sherpa
+    n = len(y)
+    rng = np.random.default_rng([17, seed])
+    surveyed = np.zeros(n, dtype=bool)
+    surveyed[start_wards] = True
+    teams, cost, flights, records = list(start_wards), 0.0, 0, []
+    for rnd in range(rounds + 1):
+        if method == "sherpa":
+            mean, sd, _ = gnn.fit_predict(x_sherpa, xy, y, surveyed, edges, seed=seed * 100 + rnd,
+                                          members=members)
+        else:
+            mean, sd, resid = regression_kriging(x, xy, y, surveyed)
+        err = np.abs(mean - y)[~surveyed]
+        records.append({"method": method, "seed": seed, "round": rnd, "n_surveyed": int(surveyed.sum()),
+                        "cost_hours": cost, "flights": flights, "mae": float(err.mean()),
+                        "coverage_90": float((err <= 1.6449 * sd[~surveyed]).mean())})
+        if rnd == rounds:
+            break
+        if method == "random":
+            picks = list(rng.choice(np.flatnonzero(~surveyed), size=len(teams), replace=False))
+        elif method == "kriging":
+            picks = select_kriging(xy, resid, surveyed, len(teams))
+        else:
+            p = baselines.fit_variogram(xy[surveyed], y[surveyed] - mean[surveyed])
+            range_km = float(np.clip(p["range"], 10.0, 80.0))
+            picks = select_sherpa(sd, mean, surveyed, xy, pairs, travel, teams, len(teams), range_km,
+                                  seed * 100 + rnd, learned=learned)
+        step_cost, teams, f = assign_and_move(picks, teams, travel)
+        cost += step_cost
+        flights += f
+        surveyed[picks] = True
+    return records