Datasets:
Download examples/openet_readout.py from ZiyunPOLYU/ted-downstream-eo: direct link, hf CLI and curl.
- Browser
- Download file 8.66 kB
-
https://huggingface.co/datasets/ZiyunPOLYU/ted-downstream-eo/resolve/main/examples/openet_readout.py
- Command line
-
hf download hf://datasets/ZiyunPOLYU/ted-downstream-eo/examples/openet_readout.py
-
curl -L -o openet_readout.py https://huggingface.co/datasets/ZiyunPOLYU/ted-downstream-eo/resolve/main/examples/openet_readout.py
8.66 kB
| #!/usr/bin/env python3 | |
| """OpenET downstream readout on the files in this dataset. | |
| The readout is the AlphaEarth OpenET trial, which TESSERA v2 also uses: | |
| * official split, 3,000 train and 32,683 test | |
| * 10 ET bins, column ``partition`` in ``regression/openet/sample_index.parquet`` | |
| * draws per bin: 1 point x 1000 repeats, 10 x 500, 300 x 1 | |
| * ordinary least squares with an intercept, no penalty and no feature scaling | |
| * kNN regression at k=1 and k=3, uniform average of the neighbours | |
| * the suite score is the best of those three readouts | |
| * random seed 42 | |
| Two inputs are wired up: | |
| * ``alphaearth``: annual 64-d embedding, ``regression/openet/alphaearth_annual_v1.npz``. | |
| This is the public annual product. It is not the paper's time-conditioned | |
| embedding. On the full 300-per-bin train split its linear R^2 is about -0.13. | |
| * ``hls_year_mean``: mean of Blue..NDVI over the calendar-year 3-day cube, | |
| ``ready_3day/openet_fullband_3day.nc`` | |
| That cube is the label's calendar year, 122 steps. It is not the paper's | |
| 365.25-day support window ending at the target month, and it is not the | |
| target month alone. Those two windows are the masks ``official_support_mask`` | |
| and ``valid_month_mask`` inside ``regression/openet/hls_l30.tar`` and | |
| ``hls_s30.tar``. The month window is where TESSERA v2 reports its 0.69. | |
| python openet_readout.py --features alphaearth --shots 300 | |
| python openet_readout.py --features hls_year_mean --shots 300 | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| from pathlib import Path | |
| import numpy as np | |
| import pandas as pd | |
| REPO = "ZiyunPOLYU/ted-downstream-eo" | |
| AEF_REPO = "regression/openet/alphaearth_annual_v1.npz" | |
| INDEX_REPO = "regression/openet/sample_index.parquet" | |
| CUBE_REPO = "ready_3day/openet_fullband_3day.nc" | |
| COMMON = ("Blue", "Green", "Red", "NIR", "SWIR1", "SWIR2", "NDVI") | |
| def _local(path: str | None, repo_path: str) -> Path: | |
| if path: | |
| return Path(path) | |
| from huggingface_hub import hf_hub_download | |
| return Path(hf_hub_download(REPO, repo_path, repo_type="dataset")) | |
| def _table(index_path: Path) -> pd.DataFrame: | |
| frame = pd.read_parquet( | |
| index_path, | |
| columns=["sample_id", "source_idx", "label", "split", "partition", "year"], | |
| ) | |
| frame = frame.sort_values("source_idx").reset_index(drop=True) | |
| if len(frame) != 35683: | |
| raise RuntimeError(f"Expected 35683 OpenET rows, got {len(frame)}") | |
| if set(frame.split.astype(str)) != {"train", "test"}: | |
| raise RuntimeError(f"Unexpected splits: {sorted(frame.split.unique())}") | |
| return frame | |
| def _align(sample_id: np.ndarray, frame: pd.DataFrame) -> np.ndarray: | |
| order = pd.Series(np.arange(len(sample_id)), index=sample_id.astype(str)) | |
| return order.loc[frame.sample_id.astype(str)].to_numpy() | |
| def load_alphaearth(path: Path, frame: pd.DataFrame) -> np.ndarray: | |
| with np.load(path, allow_pickle=False) as payload: | |
| take = _align(payload["sample_id"], frame) | |
| embedding = np.asarray(payload["embedding"], dtype=np.float32)[take] | |
| valid = np.asarray(payload["valid"], dtype=bool)[take] | |
| embedding = embedding.copy() | |
| embedding[~valid] = np.nan | |
| return embedding | |
| def load_hls_year_mean(path: Path, frame: pd.DataFrame) -> np.ndarray: | |
| import netCDF4 | |
| with netCDF4.Dataset(path) as ds: | |
| names = [str(item) for item in ds.variables["band"][:]] | |
| columns = [names.index(name) for name in COMMON] | |
| take = _align(np.asarray(ds.variables["sample_id"][:]).astype(str), frame) | |
| cube = np.asarray(ds.variables["data"][:, columns, take], dtype=np.float32) | |
| with np.errstate(all="ignore"): | |
| return np.nanmean(cube, axis=0).T | |
| def _metrics(y_true: np.ndarray, y_pred: np.ndarray) -> dict: | |
| residual = y_pred - y_true | |
| ss_res = float(np.sum(residual ** 2)) | |
| ss_tot = float(np.sum((y_true - float(y_true.mean())) ** 2)) | |
| r2 = float("nan") if ss_tot == 0 else 1.0 - ss_res / ss_tot | |
| return { | |
| "r2": r2, | |
| "r2_chance_adjusted": max(0.0, r2) if np.isfinite(r2) else float("nan"), | |
| "mae": float(np.mean(np.abs(residual))), | |
| "rmse": float(np.sqrt(np.mean(residual ** 2))), | |
| } | |
| def _fit_predict(x_train, y_train, x_test, kind: str) -> np.ndarray: | |
| if kind == "linear": | |
| design = np.concatenate([x_train, np.ones((len(x_train), 1), dtype=np.float32)], axis=1) | |
| coef, *_ = np.linalg.lstsq(design, y_train.astype(np.float64), rcond=None) | |
| test = np.concatenate([x_test, np.ones((len(x_test), 1), dtype=np.float32)], axis=1) | |
| return test.astype(np.float64) @ coef | |
| k = 1 if kind == "knn1" else 3 | |
| train = np.ascontiguousarray(x_train, dtype=np.float32) | |
| test = np.ascontiguousarray(x_test, dtype=np.float32) | |
| train_sq = np.sum(train * train, axis=1, dtype=np.float32) | |
| test_sq = np.sum(test * test, axis=1, dtype=np.float32) | |
| pred = np.empty(len(test), dtype=np.float64) | |
| for start in range(0, len(test), 4096): | |
| stop = min(len(test), start + 4096) | |
| distance = test_sq[start:stop, None] + train_sq[None, :] - 2.0 * (test[start:stop] @ train.T) | |
| chosen = np.argpartition(distance, kth=k - 1, axis=1)[:, :k] | |
| pred[start:stop] = y_train[chosen].mean(axis=1) | |
| return pred | |
| def _subsample(train_at: np.ndarray, partition: np.ndarray, samples_n: int, rng: np.random.Generator) -> np.ndarray: | |
| chosen = [] | |
| for part in range(10): | |
| pool = train_at[partition[train_at] == part] | |
| take = samples_n if pool.size >= samples_n else int(pool.size) | |
| if take == 0 or (take != samples_n and samples_n != 300): | |
| raise RuntimeError(f"Partition {part} has {pool.size} train rows, need {samples_n}") | |
| pick = pool if take == pool.size else rng.choice(pool, size=take, replace=False) | |
| chosen.append(np.sort(pick)) | |
| return np.concatenate(chosen) | |
| def score(name: str, embedding: np.ndarray, frame: pd.DataFrame, shots: list[int]) -> pd.DataFrame: | |
| finite = np.isfinite(embedding).all(axis=1) | |
| split = frame.split.astype(str).to_numpy() | |
| label = frame.label.to_numpy(dtype=np.float64) | |
| partition = frame.partition.to_numpy(dtype=np.int64) | |
| train_at = np.flatnonzero((split == "train") & finite) | |
| test_at = np.flatnonzero((split == "test") & finite) | |
| rows = [] | |
| repeats = {1: 1000, 10: 500, 300: 1} | |
| small = np.random.default_rng(42) | |
| for samples_n in shots: | |
| if samples_n == 300: | |
| draws = [_subsample(train_at, partition, 300, np.random.default_rng(42))] | |
| else: | |
| draws = [_subsample(train_at, partition, samples_n, small) for _ in range(repeats[samples_n])] | |
| for kind in ("linear", "knn1", "knn3"): | |
| store = [] | |
| for subset in draws: | |
| pred = _fit_predict(embedding[subset], label[subset], embedding[test_at], kind) | |
| store.append(_metrics(label[test_at], pred)) | |
| summary = {key: float(np.mean([item[key] for item in store])) for key in store[0]} | |
| summary["r2_std"] = float(np.std([item["r2"] for item in store], ddof=1)) if len(store) > 1 else 0.0 | |
| rows.append({ | |
| "model": name, | |
| "readout": kind, | |
| "samples_per_bin": samples_n, | |
| "repeats": repeats[samples_n], | |
| "n_train": int(len(draws[-1])), | |
| "n_test": int(test_at.size), | |
| **summary, | |
| }) | |
| print( | |
| f"{name} {kind} n={len(draws[-1])} R2={summary['r2']:.4f} MAE={summary['mae']:.2f}", | |
| flush=True, | |
| ) | |
| return pd.DataFrame(rows) | |
| def main() -> None: | |
| parser = argparse.ArgumentParser() | |
| parser.add_argument("--features", choices=("alphaearth", "hls_year_mean"), default="alphaearth") | |
| parser.add_argument("--shots", default="300") | |
| parser.add_argument("--index", default="") | |
| parser.add_argument("--alphaearth", default="") | |
| parser.add_argument("--cube", default="") | |
| parser.add_argument("--out", default="") | |
| args = parser.parse_args() | |
| frame = _table(_local(args.index or None, INDEX_REPO)) | |
| if args.features == "alphaearth": | |
| embedding = load_alphaearth(_local(args.alphaearth or None, AEF_REPO), frame) | |
| else: | |
| embedding = load_hls_year_mean(_local(args.cube or None, CUBE_REPO), frame) | |
| shots = [int(item) for item in args.shots.split(",") if item] | |
| table = score(args.features, embedding, frame, shots) | |
| if args.out: | |
| destination = Path(args.out) | |
| destination.parent.mkdir(parents=True, exist_ok=True) | |
| table.to_csv(destination, index=False) | |
| print(destination) | |
| if __name__ == "__main__": | |
| main() | |