Upload nasar_dataset.py with huggingface_hub

nasar_dataset.py

@@ -0,0 +1,210 @@
+"""PyTorch datasets for the released NA-SAR tensor layout.
+
+The public API intentionally uses the dataset name, not the storage format:
+
+    from nasar_dataset import NASARRTCDataset, NASARInSARDataset
+
+RTC item:
+    patch_id, rtc_view_0, inc_angle_view_0, rtc_view_1, inc_angle_view_1
+
+InSAR item:
+    patch_id, ifg_view_0, coh_view_0, inc_angle_view_0,
+    ifg_view_1, coh_view_1, inc_angle_view_1
+"""
+
+from __future__ import annotations
+
+from io import BytesIO
+from pathlib import Path
+import tarfile
+
+import numpy as np
+import pandas as pd
+
+
+def _normalize_rtc(arr: np.ndarray, norm_stats: tuple[float, float]) -> np.ndarray:
+    """Clip to [p1, p99] and rescale to [0, 1]. Zeros stay zero."""
+    p1, p99 = norm_stats
+    valid = arr > 0
+    arr = np.where(valid, np.clip((arr - p1) / (p99 - p1), 0.0, 1.0), 0.0)
+    return arr.astype(np.float32)
+
+
+def _prepare_rtc(
+    arr: np.ndarray,
+    log_scale: bool,
+    alpha: float,
+    norm_stats: tuple[float, float] | None,
+) -> np.ndarray:
+    """Apply the same RTC preprocessing used during NASAR pretraining."""
+    arr = arr.astype(np.float32, copy=True)
+    arr = np.where(np.isfinite(arr) & (arr > 0.0), arr, 0.0)
+    if log_scale:
+        arr = np.log1p(alpha * arr)
+    if norm_stats is not None and log_scale:
+        arr = _normalize_rtc(arr, norm_stats)
+    return arr
+
+
+def _copy_array(arr: np.ndarray) -> np.ndarray:
+    """Detach an array from an opened np.load handle."""
+    return arr.astype(np.float32, copy=True)
+
+
+class _NASARBase:
+    """Shared metadata and tensor-path handling for NA-SAR datasets."""
+
+    def __init__(
+        self,
+        nasar_root: str = "/datasets/disk3/NA-SAR",
+        parquet_path: str | None = None,
+        years: list[int] | None = None,
+        min_quality_score: float | None = None,
+        shard_size: int = 10_000,
+    ) -> None:
+        self.root = Path(nasar_root)
+        self.parquet_path = Path(parquet_path) if parquet_path is not None else self.root / "metadata.parquet"
+        self.shard_size = shard_size
+
+        need_quality = min_quality_score is not None
+        cols = ["patch_id", "npz_path", "sample_key", "shard_path"]
+        if years is not None:
+            cols.append("prime_date_view_0")
+        if need_quality:
+            cols.append("quality_score")
+
+        try:
+            df = pd.read_parquet(self.parquet_path, columns=cols)
+        except Exception:
+            df = pd.read_parquet(self.parquet_path)
+
+        if years is not None:
+            year_set = set(years)
+            prime_years = pd.to_datetime(df["prime_date_view_0"], utc=True).dt.year
+            df = df[prime_years.isin(year_set)]
+
+        if need_quality:
+            if "quality_score" not in df.columns:
+                raise ValueError(
+                    "min_quality_score requested but 'quality_score' column not found in "
+                    f"{self.parquet_path}"
+                )
+            df = df[df["quality_score"] >= min_quality_score]
+
+        if "npz_path" not in df.columns and "shard_path" not in df.columns:
+            df = df.copy()
+            df["npz_path"] = [
+                str(Path("npz") / f"{i // self.shard_size:06d}" / f"{patch_id}.npz")
+                for i, patch_id in enumerate(df["patch_id"])
+            ]
+
+        self.patch_ids: list[str] = df["patch_id"].tolist()
+        self.use_shards = "shard_path" in df.columns
+        if self.use_shards:
+            self.sample_keys: list[str] = df["sample_key"].tolist()
+            self.shard_paths: list[Path] = [self._resolve_tensor_path(p) for p in df["shard_path"]]
+        else:
+            self.tensor_paths: list[Path] = [self._resolve_tensor_path(p) for p in df["npz_path"]]
+
+    def _resolve_tensor_path(self, path: str | Path) -> Path:
+        path = Path(path)
+        if path.is_absolute():
+            return path
+        return self.root / path
+
+    def __len__(self) -> int:
+        return len(self.patch_ids)
+
+    def _open_npz(self, idx: int):
+        if not self.use_shards:
+            return np.load(self.tensor_paths[idx])
+
+        member_name = f"{self.sample_keys[idx]}.npz"
+        with tarfile.open(self.shard_paths[idx], "r") as tar:
+            member = tar.extractfile(member_name)
+            if member is None:
+                raise FileNotFoundError(f"{member_name} not found in {self.shard_paths[idx]}")
+            data = member.read()
+        return np.load(BytesIO(data))
+
+
+class NASARRTCDataset(_NASARBase):
+    """Dataset for RTC contrastive learning.
+
+    RTC arrays are stored as raw linear backscatter. By default, this loader
+    applies log compression and normalization to match the NASAR pretraining
+    data path.
+    """
+
+    def __init__(
+        self,
+        nasar_root: str = "/datasets/disk3/NA-SAR",
+        parquet_path: str | None = None,
+        log_scale: bool = True,
+        alpha: float = 20.0,
+        years: list[int] | None = None,
+        random_temporal: bool = True,
+        min_quality_score: float | None = 0.53,
+        norm_stats: tuple[float, float] | None = (0.14, 2.38),
+        shard_size: int = 10_000,
+    ) -> None:
+        super().__init__(
+            nasar_root=nasar_root,
+            parquet_path=parquet_path,
+            years=years,
+            min_quality_score=min_quality_score,
+            shard_size=shard_size,
+        )
+        self.log_scale = log_scale
+        self.alpha = alpha
+        self.random_temporal = random_temporal
+        self.norm_stats = norm_stats
+
+    def __getitem__(self, idx: int) -> dict:
+        patch_id = self.patch_ids[idx]
+        prefix = "secondary_rtc" if self.random_temporal and bool(np.random.randint(2)) else "prime_rtc"
+        with self._open_npz(idx) as z:
+            return {
+                "patch_id": patch_id,
+                "rtc_view_0": _prepare_rtc(
+                    z[f"{prefix}_view_0"], self.log_scale, self.alpha, self.norm_stats
+                ),
+                "inc_angle_view_0": _copy_array(z["inc_angle_view_0"]),
+                "rtc_view_1": _prepare_rtc(
+                    z[f"{prefix}_view_1"], self.log_scale, self.alpha, self.norm_stats
+                ),
+                "inc_angle_view_1": _copy_array(z["inc_angle_view_1"]),
+            }
+
+
+class NASARInSARDataset(_NASARBase):
+    """Dataset for InSAR contrastive learning."""
+
+    def __init__(
+        self,
+        nasar_root: str = "/datasets/disk3/NA-SAR",
+        parquet_path: str | None = None,
+        years: list[int] | None = None,
+        min_quality_score: float | None = 0.53,
+        shard_size: int = 10_000,
+    ) -> None:
+        super().__init__(
+            nasar_root=nasar_root,
+            parquet_path=parquet_path,
+            years=years,
+            min_quality_score=min_quality_score,
+            shard_size=shard_size,
+        )
+
+    def __getitem__(self, idx: int) -> dict:
+        patch_id = self.patch_ids[idx]
+        with self._open_npz(idx) as z:
+            return {
+                "patch_id": patch_id,
+                "ifg_view_0": _copy_array(z["ifg_view_0"]),
+                "coh_view_0": _copy_array(z["coh_view_0"]),
+                "inc_angle_view_0": _copy_array(z["inc_angle_view_0"]),
+                "ifg_view_1": _copy_array(z["ifg_view_1"]),
+                "coh_view_1": _copy_array(z["coh_view_1"]),
+                "inc_angle_view_1": _copy_array(z["inc_angle_view_1"]),
+            }