Datasets:
Add EnvShip-Voyage: long-term ship trajectory imputation dataset + full build pipeline + docs
b61a1c7 verified | """EnvShip-Voyage data loader. | |
| Loads Track-I / Track-P samples and, for imputation, applies a named mask from the frozen mask bank. | |
| Sequences are returned in time order as float arrays with NaN at held-out / missing steps. | |
| Typical use: | |
| dl = VoyageLoader(build_dir) | |
| for s in dl.iter_track_i(split="test", mask_name="cont_6h"): | |
| # s.obs (input, NaN where held out), s.target (ground truth), s.eval_mask (where to score) | |
| ... | |
| """ | |
| from __future__ import annotations | |
| import glob | |
| from dataclasses import dataclass | |
| from pathlib import Path | |
| import numpy as np | |
| import pandas as pd | |
| SEQ_COLS = ["lat", "lon", "x_m", "y_m", "sog_kn", "cog_sin", "cog_cos", | |
| "head_sin", "head_cos", "observed_mask", "position_available", "interp_provenance"] | |
| class ImputationSample: | |
| sample_id: str | |
| lat: np.ndarray | |
| lon: np.ndarray | |
| observed_mask: np.ndarray # 1 = real observation present | |
| mask: np.ndarray # 1 = held out for imputation | |
| eval_mask: np.ndarray # 1 = scored (held out AND ground-truth exists) | |
| feats: dict # remaining per-step features (NaN where held out) | |
| meta: dict | |
| def _to_arr(x): | |
| return np.array([np.nan if v is None else v for v in x], dtype=float) | |
| class VoyageLoader: | |
| def __init__(self, build_dir: str | Path): | |
| self.build = Path(build_dir) | |
| self.index = pd.read_parquet(self.build / "s11" / "sample_index_split.parquet") \ | |
| if (self.build / "s11" / "sample_index_split.parquet").exists() \ | |
| else pd.read_parquet(self.build / "s9" / "sample_index.parquet") | |
| self._mask_cache: dict[str, dict] = {} | |
| # ---- mask bank access ---- | |
| def _load_mask_partition(self, pidx: str) -> dict: | |
| if pidx not in self._mask_cache: | |
| npz = np.load(self.build / "s10" / "masks" / f"part-{pidx}.npz") | |
| self._mask_cache[pidx] = {k: npz[k] for k in npz.files if "|" in k} | |
| return self._mask_cache[pidx] | |
| def get_mask(self, sample_id: str, mask_name: str, n_steps: int, pidx: str | None = None) -> np.ndarray: | |
| # Mask npz partitions correspond 1:1 to the S9 track_i parquet partitions, so when the caller | |
| # already knows the partition (iter_track_i does) we look it up directly — no scan. Only a | |
| # stand-alone get_mask() with no pidx pays the one-time full scan to build sid->partition. | |
| if pidx is None: | |
| if not hasattr(self, "_sid2part"): | |
| self._sid2part = {} | |
| for f in glob.glob(str(self.build / "s10" / "masks" / "part-*.npz")): | |
| p = Path(f).stem.split("-")[1] | |
| npz = np.load(f) | |
| for k in npz.files: | |
| if "|" in k: | |
| self._sid2part[k.split("|")[0]] = p | |
| pidx = self._sid2part.get(sample_id) | |
| if pidx is None: | |
| return np.zeros(n_steps, dtype=np.uint8) | |
| arr = self._load_mask_partition(pidx).get(f"{sample_id}|{mask_name}") | |
| if arr is None: | |
| return np.zeros(n_steps, dtype=np.uint8) | |
| return np.unpackbits(arr)[:n_steps] | |
| # ---- iteration ---- | |
| def iter_track_i(self, split: str | None = None, mask_name: str = "cont_6h", | |
| window_len_h: int | None = None): | |
| keep = self.index | |
| if "kept" in keep.columns: | |
| keep = keep[keep["kept"]] | |
| if split: | |
| keep = keep[keep["split"] == split] | |
| if window_len_h: | |
| keep = keep[keep["window_len_h"] == window_len_h] | |
| wanted = set(keep["sample_id"]) | |
| for f in sorted(glob.glob(str(self.build / "s9" / "samples" / "track_i" / "part-*.parquet"))): | |
| pidx = Path(f).stem.split("-")[1] # this partition's mask npz is part-<pidx>.npz | |
| df = pd.read_parquet(f) | |
| df = df[df["sample_id"].isin(wanted)] | |
| for _, row in df.iterrows(): | |
| yield self._make_imputation_sample(row, mask_name, pidx) | |
| def _make_imputation_sample(self, row, mask_name: str, pidx: str | None = None) -> ImputationSample: | |
| n = int(row["n_steps"]) | |
| observed = np.asarray(row["observed_mask"], dtype=np.uint8) | |
| mask = self.get_mask(row["sample_id"], mask_name, n, pidx=pidx) | |
| eval_mask = ((mask == 1) & (observed == 1)).astype(np.uint8) | |
| feats = {c: _to_arr(row[c]) for c in SEQ_COLS if c in row} | |
| return ImputationSample( | |
| sample_id=row["sample_id"], lat=_to_arr(row["lat"]), lon=_to_arr(row["lon"]), | |
| observed_mask=observed, mask=mask, eval_mask=eval_mask, feats=feats, | |
| meta={"window_len_h": int(row["window_len_h"]), "view_min": int(row["view_min"])}, | |
| ) | |