Download code/eo_model.py from Tonic/protostar-climate-2026: direct link, hf CLI and curl.
- Browser
- Download file 9.12 kB
-
https://huggingface.co/datasets/Tonic/protostar-climate-2026/resolve/main/code/eo_model.py
- Command line
-
hf download hf://datasets/Tonic/protostar-climate-2026/code/eo_model.py
-
curl -L -o eo_model.py https://huggingface.co/datasets/Tonic/protostar-climate-2026/resolve/main/code/eo_model.py
9.12 kB
| """OlmoEarth-2018: OlmoEarth-architecture encoder, random init, <=2018 data only. | |
| Architecture follows the OlmoEarth pattern (patch tokenisation across space, | |
| time and modality band-sets; ViT encoder; pooled token embedding) at Nano | |
| scale (dim 128, depth 4), reimplemented in plain PyTorch so that no released | |
| weights -- and no code path that downloads them -- are involved. The random | |
| initialisation seed is logged; every learned parameter comes from Sentinel-2 | |
| scenes dated <= 2018-12-31 (see eo_fetch.py manifest) and challenge labels | |
| <= 2018. | |
| Task: multi-task regression of the four annual metrics for a city-year from | |
| its 4 quarterly Sentinel-2 timesteps. The pooled 128-d embedding is then used | |
| as a static city descriptor and put through the pre-registered gate | |
| (eo_gate.py) before it may touch any forecast. | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import json | |
| import sys | |
| from pathlib import Path | |
| import numpy as np | |
| import pandas as pd | |
| import torch | |
| import torch.nn as nn | |
| sys.path.insert(0, str(Path(__file__).parent)) | |
| from dataset import METRIC_COLUMNS, download, load_annual, add_validity, load_coverage | |
| SEED = 20181231 | |
| DIM, DEPTH, HEADS, PATCH = 128, 4, 4, 8 | |
| N_BANDS, N_TIMESTEPS, SIZE = 12, 4, 64 | |
| class OlmoEarthNanoScratch(nn.Module): | |
| """Patch tokens per timestep -> transformer -> pooled embedding + head.""" | |
| def __init__(self, n_targets: int = 4): | |
| super().__init__() | |
| self.patch_embed = nn.Conv2d(N_BANDS, DIM, kernel_size=PATCH, stride=PATCH) | |
| n_tokens = (SIZE // PATCH) ** 2 | |
| self.spatial_pos = nn.Parameter(torch.zeros(1, n_tokens, DIM)) | |
| self.time_embed = nn.Parameter(torch.zeros(1, N_TIMESTEPS, 1, DIM)) | |
| layer = nn.TransformerEncoderLayer( | |
| d_model=DIM, nhead=HEADS, dim_feedforward=DIM * 4, | |
| dropout=0.1, batch_first=True, norm_first=True) | |
| self.encoder = nn.TransformerEncoder(layer, num_layers=DEPTH) | |
| self.norm = nn.LayerNorm(DIM) | |
| self.head = nn.Sequential(nn.Linear(DIM, 64), nn.GELU(), nn.Linear(64, n_targets)) | |
| nn.init.trunc_normal_(self.spatial_pos, std=0.02) | |
| nn.init.trunc_normal_(self.time_embed, std=0.02) | |
| def embed(self, x: torch.Tensor) -> torch.Tensor: | |
| """x: (B,T,C,H,W) -> pooled embedding (B,DIM).""" | |
| b, t, c, h, w = x.shape | |
| tok = self.patch_embed(x.reshape(b * t, c, h, w)) # (B*T,D,8,8) | |
| tok = tok.flatten(2).transpose(1, 2).reshape(b, t, -1, tok.shape[1]) | |
| tok = tok + self.spatial_pos.unsqueeze(1) + self.time_embed | |
| tok = tok.reshape(b, t * tok.shape[2], -1) | |
| out = self.norm(self.encoder(tok)) | |
| return out.mean(dim=1) | |
| def forward(self, x: torch.Tensor) -> torch.Tensor: | |
| return self.head(self.embed(x)) | |
| def load_samples(eo_dir: Path, annual: pd.DataFrame, years: list[int]): | |
| samples = [] | |
| lookup = {(r.ID, int(r.Year)): r for r in annual.itertuples()} | |
| for path in sorted(eo_dir.glob("s2_*_*.npz")): | |
| city, year = path.stem[3:].rsplit("_", 1) | |
| year = int(year) | |
| if year not in years: | |
| continue | |
| row = lookup.get((city, year)) | |
| if row is None: | |
| continue | |
| targets, valid = [], True | |
| for metric, col in METRIC_COLUMNS.items(): | |
| v = getattr(row, col.replace(" ", "_")) if hasattr(row, col.replace(" ", "_")) else row._asdict().get(col) | |
| targets.append(np.nan if v is None else float(v)) | |
| data = np.load(path)["data"] # (T,C,H,W) | |
| if data.shape != (N_TIMESTEPS, N_BANDS, SIZE, SIZE): | |
| continue | |
| samples.append({"city_id": city, "year": year, | |
| "x": data, "y": np.array(targets, dtype=np.float32)}) | |
| return samples | |
| def main() -> None: | |
| ap = argparse.ArgumentParser() | |
| ap.add_argument("--eo-dir", default="data/eo") | |
| ap.add_argument("--epochs", type=int, default=60) | |
| ap.add_argument("--out", default="outputs/eo") | |
| args = ap.parse_args() | |
| torch.manual_seed(SEED) | |
| np.random.seed(SEED) | |
| root = Path(__file__).resolve().parent.parent | |
| eo_dir = root / args.eo_dir | |
| data_root = download(root / "data" / "_source") | |
| annual = add_validity(load_annual(data_root), load_coverage(data_root)) | |
| # Column names with spaces are awkward in itertuples; rename for lookup. | |
| annual = annual.rename(columns={"Avg Temp": "AvgTemp", "ToT Prcp": "ToTPrcp", | |
| "Max Tmax": "MaxTmax"}) | |
| col_map = {"annual_avg_temp": "AvgTemp", "total_precip_in": "ToTPrcp", | |
| "hottest_day_temp": "MaxTmax", "cdd": "cdd"} | |
| samples = [] | |
| for path in sorted(eo_dir.glob("s2_*_*.npz")): | |
| city, year_s = path.stem[3:].rsplit("_", 1) | |
| year = int(year_s) | |
| sel = annual[(annual["ID"] == city) & (annual["Year"] == year)] | |
| if sel.empty: | |
| continue | |
| r = sel.iloc[0] | |
| y = np.array([r[col_map[m]] for m in METRIC_COLUMNS], dtype=np.float32) | |
| if not np.isfinite(y).all(): | |
| continue | |
| samples.append({"city_id": city, "year": year, | |
| "x": np.load(path)["data"], "y": y}) | |
| print(f"samples: {len(samples)} city-years " | |
| f"({len(set(s['city_id'] for s in samples))} cities)") | |
| if len(samples) < 40: | |
| raise SystemExit("too few EO samples; run eo_fetch.py first") | |
| y_all = np.stack([s["y"] for s in samples]) | |
| y_mean, y_std = y_all.mean(0), y_all.std(0) + 1e-6 | |
| cities = sorted(set(s["city_id"] for s in samples)) | |
| rng = np.random.default_rng(SEED) | |
| rng.shuffle(cities) | |
| val_cities = set(cities[: max(5, len(cities) // 5)]) | |
| train = [s for s in samples if s["city_id"] not in val_cities] | |
| val = [s for s in samples if s["city_id"] in val_cities] | |
| print(f"train {len(train)} / val(city-held-out) {len(val)}") | |
| device = torch.device("cuda" if torch.cuda.is_available() else "cpu") | |
| model = OlmoEarthNanoScratch().to(device) | |
| init_hash = hash(tuple(model.patch_embed.weight.detach().cpu().numpy().ravel()[:8])) | |
| opt = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=0.05) | |
| sched = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=args.epochs) | |
| def batch(split): | |
| xs = torch.tensor(np.stack([s["x"] for s in split]), device=device) | |
| ys = torch.tensor((np.stack([s["y"] for s in split]) - y_mean) / y_std, | |
| device=device) | |
| return xs, ys | |
| vx, vy = batch(val) | |
| best = float("inf") | |
| out_dir = root / args.out | |
| out_dir.mkdir(parents=True, exist_ok=True) | |
| for epoch in range(args.epochs): | |
| model.train() | |
| order = rng.permutation(len(train)) | |
| losses = [] | |
| for i in range(0, len(order), 16): | |
| idx = order[i:i + 16] | |
| xs = torch.tensor(np.stack([train[j]["x"] for j in idx]), device=device) | |
| ys = torch.tensor((np.stack([train[j]["y"] for j in idx]) - y_mean) / y_std, | |
| device=device) | |
| if rng.random() < 0.5: | |
| xs = xs.flip(-1) | |
| if rng.random() < 0.5: | |
| xs = xs.flip(-2) | |
| opt.zero_grad() | |
| loss = nn.functional.smooth_l1_loss(model(xs), ys) | |
| loss.backward() | |
| opt.step() | |
| losses.append(float(loss)) | |
| sched.step() | |
| model.eval() | |
| with torch.no_grad(): | |
| vloss = float(nn.functional.smooth_l1_loss(model(vx), vy)) | |
| best = min(best, vloss) | |
| if epoch % 10 == 0 or epoch == args.epochs - 1: | |
| print(f"epoch {epoch}: train {np.mean(losses):.4f} val {vloss:.4f}") | |
| # Extract static city embeddings (mean over years) with the trained encoder. | |
| model.eval() | |
| emb_rows = [] | |
| with torch.no_grad(): | |
| for s in samples: | |
| x = torch.tensor(s["x"][None], device=device) | |
| emb_rows.append({"city_id": s["city_id"], "year": s["year"], | |
| **{f"emb_{i}": float(v) for i, v in | |
| enumerate(model.embed(x).cpu().numpy()[0])}}) | |
| emb = pd.DataFrame(emb_rows) | |
| emb.to_csv(out_dir / "embeddings_by_year.csv", index=False) | |
| static = emb.groupby("city_id").mean(numeric_only=True).reset_index() | |
| static = static.drop(columns=["year"]) | |
| static.to_csv(out_dir / "city_embeddings.csv", index=False) | |
| (out_dir / "train_log.json").write_text(json.dumps({ | |
| "seed": SEED, "init_weight_fingerprint": init_hash, | |
| "n_samples": len(samples), "n_cities": len(cities), | |
| "best_val_smoothl1_standardised": best, | |
| "y_mean": y_mean.tolist(), "y_std": y_std.tolist(), | |
| "device": str(device), | |
| "note": "random init; no released OlmoEarth weights used anywhere", | |
| }, indent=2)) | |
| torch.save(model.state_dict(), out_dir / "olmoearth2018_encoder.pt") | |
| print(f"wrote embeddings for {len(static)} cities; best val loss {best:.4f}") | |
| if __name__ == "__main__": | |
| main() | |