Add Pacific MUR SST ML subset

Publish Pacific (20-50N, 180-240E) 2018-2019 analysed_sst subset as a weekly-chunked Zarr tar, plus PyTorch loader and throughput benchmark.

.gitattributes

@@ -57,3 +57,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+pacific_sst.zarr/** filter=lfs diff=lfs merge=lfs -text
+pacific_sst.zarr.tar filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,87 @@
+# MUR SST (Pacific) — ML Benchmark Zarr
+
+This folder contains a **machine-learning friendly Zarr subset** of the NASA/JPL GHRSST **MUR SST** product.
+
+- **Upstream source (public, no auth)**: `s3://mur-sst/zarr`
+- **Subset**:
+  - **Region**: Pacific, lat \(20^\circ\text{N}\)–\(50^\circ\text{N}\), lon \(180^\circ\text{E}\)–\(240^\circ\text{E}\) (stored as 0–360)
+  - **Time**: 2018-01-01 → 2019-12-30 (729 daily frames)
+  - **Variable**: `analysed_sst` only (**float32, °C**)
+- **Chunking for ML**: `(time, lat, lon) = (7, 256, 256)` (weekly windows)
+
+Why `mur-sst/zarr-v1` during extraction?
+- `mur-sst/zarr` is chunked with the **entire time axis in one chunk**, making time subsetting extremely inefficient.
+- `mur-sst/zarr-v1` is time-chunked and enables practical extraction. The output dataset here is the requested ML rechunk.
+
+## Files in this dataset repo
+
+Because Hugging Face dataset repos + Git LFS handle a **single large file** much more reliably than tens of thousands of tiny chunk files, the Zarr store is published as:
+
+- `pacific_sst.zarr.tar` (a tar archive of the `pacific_sst.zarr/` directory)
+
+To use it locally:
+
+```bash
+tar -xf pacific_sst.zarr.tar
+```
+
+## SST forecasting task definition
+
+We define a next-week forecasting task:
+
+- **Input**: 7 daily SST frames \(X_t \in \mathbb{R}^{7 \times H \times W}\)
+- **Target**: next 7 daily SST frames \(Y_t \in \mathbb{R}^{7 \times H \times W}\)
+- **Goal**: learn \(f_\theta(X_t) \approx Y_t\)
+
+Windows are created from the `time` axis; you can use overlapping or non-overlapping windows (benchmark scripts default to non-overlapping).
+
+## Train/val/test splits
+
+Time-contiguous splits (no leakage):
+
+- **Train**: 2018-01-01 → 2018-12-30
+- **Val**: 2018-12-31 → 2019-06-30
+- **Test**: 2019-07-01 → 2019-12-30
+
+## Streaming code example
+
+Local:
+
+```python
+import xarray as xr
+ds = xr.open_zarr("pacific_sst.zarr", consolidated=True)
+print(ds)
+```
+
+Remote (Hugging Face, after download):
+
+```python
+import xarray as xr
+
+# 1) Download pacific_sst.zarr.tar from the Hub
+# 2) tar -xf pacific_sst.zarr.tar
+ds = xr.open_zarr("pacific_sst.zarr", consolidated=True)
+print(ds)
+```
+
+## Benchmark results
+
+Run:
+
+```bash
+tar -xf pacific_sst.zarr.tar
+tar -xf pacific_sst.zarr.tar
+tar -xf pacific_sst.zarr.tar
+tar -xf pacific_sst.zarr.tar
+tar -xf pacific_sst.zarr.tar
+tar -xf pacific_sst.zarr.tar
+python bench/throughput_benchmark.py --local pacific_sst.zarr
+```
+
+Then fill in the table below (the script prints a Markdown row you can paste here):
+
+| mode | samples/sec | MB/sec | first_batch_sec |
+|---|---:|---:|---:|
+| local | 0.270 | 259.374 | 6.392 |
+| streaming_hf | TODO | TODO | TODO |
+

bench/throughput_benchmark.py

@@ -0,0 +1,118 @@
+import argparse
+import time
+from dataclasses import dataclass
+
+import numpy as np
+import xarray as xr
+
+
+@dataclass(frozen=True)
+class BenchResult:
+    mode: str
+    samples_per_sec: float
+    mb_per_sec: float
+    first_batch_sec: float
+
+
+def benchmark_local(zarr_path: str, *, n_samples: int = 16, in_days: int = 7, out_days: int = 7, seed: int = 0) -> BenchResult:
+    ds = xr.open_zarr(zarr_path, consolidated=True)
+    var = ds['analysed_sst']
+
+    rng = np.random.RandomState(seed)
+    max_start = int(ds.sizes['time']) - (in_days + out_days)
+    idxs = rng.randint(0, max_start + 1, size=n_samples)
+
+    t0 = time.time()
+    i0 = int(idxs[0])
+    x0 = np.asarray(var.isel(time=slice(i0, i0 + in_days)).values)
+    y0 = np.asarray(var.isel(time=slice(i0 + in_days, i0 + in_days + out_days)).values)
+    _ = float(x0.mean() + y0.mean())
+    first = time.time() - t0
+
+    t1 = time.time()
+    bytes_read = 0
+    for i in idxs:
+        i = int(i)
+        x = np.asarray(var.isel(time=slice(i, i + in_days)).values)
+        y = np.asarray(var.isel(time=slice(i + in_days, i + in_days + out_days)).values)
+        bytes_read += x.nbytes + y.nbytes
+        _ = float(x.mean() + y.mean())
+
+    dt = time.time() - t1
+    samples_per_sec = float(len(idxs) / max(dt, 1e-9))
+    mb_per_sec = float((bytes_read / (1024 * 1024)) / max(dt, 1e-9))
+    return BenchResult('local', samples_per_sec, mb_per_sec, first)
+
+
+def benchmark_hf(repo_id: str, *, n_samples: int = 16, in_days: int = 7, out_days: int = 7, seed: int = 0) -> BenchResult:
+    """Benchmark streaming from HF using the hf:// fsspec protocol.
+
+    Note: requires a newer huggingface_hub/fsspec stack that provides hf://.
+    """
+    import fsspec
+
+    mapper = fsspec.get_mapper(f"hf://datasets/{repo_id}/pacific_sst.zarr")
+    ds = xr.open_zarr(mapper, consolidated=True)
+    var = ds['analysed_sst']
+
+    rng = np.random.RandomState(seed)
+    max_start = int(ds.sizes['time']) - (in_days + out_days)
+    idxs = rng.randint(0, max_start + 1, size=n_samples)
+
+    t0 = time.time()
+    i0 = int(idxs[0])
+    x0 = np.asarray(var.isel(time=slice(i0, i0 + in_days)).values)
+    y0 = np.asarray(var.isel(time=slice(i0 + in_days, i0 + in_days + out_days)).values)
+    _ = float(x0.mean() + y0.mean())
+    first = time.time() - t0
+
+    t1 = time.time()
+    bytes_read = 0
+    for i in idxs:
+        i = int(i)
+        x = np.asarray(var.isel(time=slice(i, i + in_days)).values)
+        y = np.asarray(var.isel(time=slice(i + in_days, i + in_days + out_days)).values)
+        bytes_read += x.nbytes + y.nbytes
+        _ = float(x.mean() + y.mean())
+
+    dt = time.time() - t1
+    samples_per_sec = float(len(idxs) / max(dt, 1e-9))
+    mb_per_sec = float((bytes_read / (1024 * 1024)) / max(dt, 1e-9))
+    return BenchResult('streaming_hf', samples_per_sec, mb_per_sec, first)
+
+
+def main() -> None:
+    p = argparse.ArgumentParser()
+    p.add_argument('--local', help='Path to pacific_sst.zarr')
+    p.add_argument('--hf', help='HF dataset repo_id, e.g. KokosDev/mur-sst-ml-benchmark')
+    p.add_argument('--n-samples', type=int, default=16)
+    p.add_argument('--seed', type=int, default=0)
+    args = p.parse_args()
+
+    results = []
+    if args.local:
+        results.append(benchmark_local(args.local, n_samples=args.n_samples, seed=args.seed))
+    if args.hf:
+        try:
+            results.append(benchmark_hf(args.hf, n_samples=args.n_samples, seed=args.seed))
+        except Exception as e:
+            print('HF streaming benchmark failed:', repr(e))
+            print('Tip: install newer huggingface_hub + fsspec with hf:// support')
+    if not results:
+        raise SystemExit('Provide --local and/or --hf')
+
+    print('## Throughput benchmark')
+    for r in results:
+        print(f'- mode: {r.mode}')
+        print(f'- samples/sec: {r.samples_per_sec:.3f}')
+        print(f'- MB/sec: {r.mb_per_sec:.3f}')
+        print(f'- first_batch_sec: {r.first_batch_sec:.3f}')
+    print('')
+    print('| mode | samples/sec | MB/sec | first_batch_sec |')
+    print('|---|---:|---:|---:|')
+    for r in results:
+        print(f'| {r.mode} | {r.samples_per_sec:.3f} | {r.mb_per_sec:.3f} | {r.first_batch_sec:.3f} |')
+
+
+if __name__ == '__main__':
+    main()

build_pacific_sst.py

@@ -0,0 +1,121 @@
+import argparse
+import os
+from typing import Dict
+
+import numpy as np
+import s3fs
+import xarray as xr
+import zarr
+
+
+def _open_mur_zarr(source_root: str) -> xr.Dataset:
+    fs = s3fs.S3FileSystem(anon=True)
+    store = s3fs.S3Map(root=source_root, s3=fs, check=False)
+    return xr.open_zarr(
+        store,
+        consolidated=True,
+        decode_cf=True,
+        mask_and_scale=True,
+        decode_times=True,
+        # Keep reading lazy (dask) using source chunking.
+        chunks={},
+    )
+
+
+def _lon_to_0_360(ds: xr.Dataset) -> xr.Dataset:
+    # Original lon is [-180, 180]. Convert to [0, 360) and reorder accordingly.
+    lon360 = (ds["lon"] % 360).astype("float32")
+    ds = ds.assign_coords(lon360=lon360).set_coords("lon360")
+    ds = ds.swap_dims({"lon": "lon360"}).sortby("lon360")
+    ds = ds.drop_vars("lon").rename({"lon360": "lon"})
+    ds["lon"].attrs.update({"units": "degrees_east", "standard_name": "longitude"})
+    return ds
+
+
+def build_pacific_subset(
+    source_root: str,
+    out_path: str,
+    *,
+    lat_min: float = 20.0,
+    lat_max: float = 50.0,
+    lon_min_360: float = 180.0,
+    lon_max_360: float = 240.0,
+    time_start: str = "2018-01-01",
+    time_end: str = "2019-12-31",
+    rechunk: Dict[str, int] = None,
+    compressor_level: int = 3,
+) -> None:
+    ds = _open_mur_zarr(source_root)
+    ds = _lon_to_0_360(ds)
+
+    # Keep only analysed_sst, then subset.
+    ds = ds[["analysed_sst"]]
+    ds = ds.sel(
+        lat=slice(lat_min, lat_max),
+        lon=slice(lon_min_360, lon_max_360),
+        time=slice(np.datetime64(time_start), np.datetime64(time_end)),
+    )
+    print(
+        "subset dims:",
+        {k: int(v) for k, v in ds.sizes.items()},
+        "time:",
+        str(ds["time"].values[0]),
+        "->",
+        str(ds["time"].values[-1]),
+        flush=True,
+    )
+
+    # Convert to Celsius for ML convenience (keep variable name analysed_sst).
+    ds["analysed_sst"] = (ds["analysed_sst"] - 273.15).astype("float32")
+    ds["analysed_sst"].attrs.update(
+        {
+            "units": "celsius",
+            "comment": "Converted from kelvin using analysed_sst - 273.15",
+        }
+    )
+
+    if rechunk is None:
+        rechunk = {"time": 7, "lat": 256, "lon": 256}
+    ds = ds.chunk(rechunk)
+    print("target chunks:", ds["analysed_sst"].data.chunksize, flush=True)
+
+    compressor = zarr.Blosc(cname="zstd", clevel=int(compressor_level), shuffle=2)
+    encoding = {"analysed_sst": {"compressor": compressor, "dtype": "float32"}}
+
+    if os.path.exists(out_path):
+        raise FileExistsError(f"Refusing to overwrite existing path: {out_path}")
+
+    print(f"writing zarr -> {out_path}", flush=True)
+    ds.to_zarr(out_path, mode="w", consolidated=True, encoding=encoding)
+    print("done", flush=True)
+
+
+def main() -> None:
+    p = argparse.ArgumentParser()
+    p.add_argument("--source-root", default="mur-sst/zarr-v1")
+    p.add_argument("--out", default="pacific_sst.zarr")
+    p.add_argument("--time-start", default="2018-01-01")
+    p.add_argument("--time-end", default="2019-12-31")
+    p.add_argument("--lat-min", type=float, default=20.0)
+    p.add_argument("--lat-max", type=float, default=50.0)
+    p.add_argument("--lon-min", type=float, default=180.0, help="Longitude min in 0..360")
+    p.add_argument("--lon-max", type=float, default=240.0, help="Longitude max in 0..360")
+    p.add_argument("--compressor-level", type=int, default=3)
+    args = p.parse_args()
+
+    build_pacific_subset(
+        args.source_root,
+        args.out,
+        lat_min=args.lat_min,
+        lat_max=args.lat_max,
+        lon_min_360=args.lon_min,
+        lon_max_360=args.lon_max,
+        time_start=args.time_start,
+        time_end=args.time_end,
+        compressor_level=args.compressor_level,
+    )
+
+
+if __name__ == "__main__":
+    main()
+

examples/pytorch_dataloader.py

@@ -0,0 +1,81 @@
+import argparse
+from dataclasses import dataclass
+from typing import Tuple
+
+import numpy as np
+import torch
+import xarray as xr
+from torch.utils.data import DataLoader, Dataset
+
+
+@dataclass(frozen=True)
+class WindowSpec:
+    in_days: int = 7
+    out_days: int = 7
+    stride_days: int = 7  # non-overlapping by default
+
+
+class PacificSSTForecastDataset(Dataset):
+    """Forecasting dataset over pacific_sst.zarr.
+
+    Returns:
+      x: (in_days, H, W) float32
+      y: (out_days, H, W) float32
+    """
+
+    def __init__(self, zarr_path: str, *, split: str, window: WindowSpec = WindowSpec()) -> None:
+        self.ds = xr.open_zarr(zarr_path, consolidated=True)
+        self.var = self.ds["analysed_sst"]
+        self.window = window
+
+        t = self.ds["time"].values
+        if t.dtype.kind != "M":
+            raise ValueError("Expected datetime64 time coordinate")
+
+        train_end = np.datetime64("2018-12-30T09:00:00")
+        val_end = np.datetime64("2019-06-30T09:00:00")
+
+        if split == "train":
+            t0 = 0
+            t1 = int(np.searchsorted(t, train_end, side="right")) - 1
+        elif split == "val":
+            t0 = int(np.searchsorted(t, train_end, side="right"))
+            t1 = int(np.searchsorted(t, val_end, side="right")) - 1
+        elif split == "test":
+            t0 = int(np.searchsorted(t, val_end, side="right"))
+            t1 = len(t) - 1
+        else:
+            raise ValueError("split must be one of: train, val, test")
+
+        n = window.in_days + window.out_days
+        self.start_indices = list(range(t0, t1 - n + 2, window.stride_days))
+
+    def __len__(self) -> int:
+        return len(self.start_indices)
+
+    def __getitem__(self, idx: int) -> Tuple[torch.Tensor, torch.Tensor]:
+        i = self.start_indices[idx]
+        x = self.var.isel(time=slice(i, i + self.window.in_days)).values.astype(np.float32)
+        y = self.var.isel(
+            time=slice(i + self.window.in_days, i + self.window.in_days + self.window.out_days)
+        ).values.astype(np.float32)
+        return torch.from_numpy(x), torch.from_numpy(y)
+
+
+def main() -> None:
+    p = argparse.ArgumentParser()
+    p.add_argument("--zarr", default="pacific_sst.zarr")
+    p.add_argument("--split", default="train", choices=["train", "val", "test"])
+    p.add_argument("--batch-size", type=int, default=1)
+    p.add_argument("--num-workers", type=int, default=0)
+    args = p.parse_args()
+
+    ds = PacificSSTForecastDataset(args.zarr, split=args.split)
+    dl = DataLoader(ds, batch_size=args.batch_size, shuffle=(args.split == "train"), num_workers=args.num_workers)
+
+    x, y = next(iter(dl))
+    print("x:", tuple(x.shape), x.dtype, "y:", tuple(y.shape), y.dtype)
+
+
+if __name__ == "__main__":
+    main()

pacific_sst.zarr.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8679230067e7e59a8efa156f0b1449e014360e5787de55edeb539f82bee65dfd
+size 20674529280