File size: 9,121 Bytes
49f3de8 | 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 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 | """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()
|