v8: rebalanced + sample_karst_score for per-pixel binary karst regression

Combines all 3 AOIs (Central/East/West), adds sample_karst_score field (0=other, 1=karst) for per-pixel binary regression, soft-balanced to max/min class ratio 9.9, pre-sharded into 5 longitude-coherent regions under Studio 10K-record cap. Passes 7/7 OE audit criteria. See v8/DATASET_CARD_ADDENDUM.md.

.gitattributes

@@ -67,3 +67,5 @@ annotations/annotation_features.geojson filter=lfs diff=lfs merge=lfs -text
 annotation_features.geojson filter=lfs diff=lfs merge=lfs -text
 studio/import.geojson filter=lfs diff=lfs merge=lfs -text
 studio/import.json filter=lfs diff=lfs merge=lfs -text
+v8/studio/import_full.geojson filter=lfs diff=lfs merge=lfs -text
+v8/studio/import_full.json filter=lfs diff=lfs merge=lfs -text

v8/DATASET_CARD_ADDENDUM.md

@@ -0,0 +1,102 @@
+---
+# This is an addendum to be merged into the existing README.md on HF
+# Dataset: BAIGroup/OlmoEarth-v1-FT-Karst-Groundwater-Base
+# Version: v8 (rebalanced + sample_karst_score)
+---
+
+# v8 Rebalanced Edition (2026-05-23)
+
+A new variant of the Karst fine-tuning dataset that:
+
+1. **Combines all 3 AOI regions** (Central, East, West) into one mixed training set
+2. **Adds `sample_karst_score`** — a binary regression target (0.0 = other / 1.0 = karst) that lets OlmoEarth Studio's per-pixel regression head actually learn karst vs non-karst, instead of regressing to the mean of `sample_number` (confidence)
+3. **Passes the 7-criterion OE quality audit** (max/min class ratio reduced from 13.0 to 9.9; spatial spread verified; negative class present)
+4. **Pre-sharded** into 5 longitude-sorted regions of ~8,200 features each, all under Studio's 10K-records / 1-hour upload cap (pitfall #7)
+
+## What's new in this version
+
+| Aspect | Original (v1) | v8 |
+|---|---|---|
+| Rows | 47,020 | **40,989** |
+| Class distribution | other 53%, depression 35%, sinkhole 8%, mine 4% | other 46%, depression 40%, sinkhole 9%, mine 5% |
+| Max/min class ratio | 13.0 (fails audit) | **9.9 (passes)** |
+| Binary karst balance (positive : negative) | 47 : 53 | **54 : 46** |
+| Per-AOI columns | implicit only | **explicit `task_name`** (pa_karst_central / east / west) |
+| Per-pixel regression target | `confidence` (0.6–0.9 for all classes — degenerate) | **`sample_karst_score` (0 or 1 — discriminative)** |
+| Studio shards | none — 47K records times out (pitfall #7) | **5 longitude-coherent shards, each ~8,200** |
+
+## New field: `sample_karst_score`
+
+A pre-computed binary regression target so per-pixel regression in Studio produces a real karst probability map instead of collapsing to the mean (the V6 failure).
+
+| `sample_category` (existing) | `sample_karst_score` (new) |
+|---|---|
+| `other` | **0.0** |
+| `sinkhole` | **1.0** |
+| `surface_depression` | **1.0** |
+| `surface_mine` | **1.0** |
+
+All other existing fields (`sample_category`, `sample_number`, `sample_true_false`, etc.) are preserved unchanged, so window-level classification and point detection workflows remain available.
+
+## New field: `task_name`
+
+Spatial AOI assignment (was implicit in v1, now an explicit column):
+
+| AOI | Longitude range | Row count |
+|---|---|---:|
+| `pa_karst_west` | lon < -78.5 | 557 |
+| `pa_karst_central` | -78.5 ≤ lon < -76.5 | 21,517 |
+| `pa_karst_east` | lon ≥ -76.5 | 18,915 |
+
+## Why three V6/V7 training runs produced unusable outputs
+
+| Run | What it did | Why it failed |
+|---|---|---|
+| **V6 run2** (per-pixel regression on `sample_number`) | Trained continuous regression on labeler confidence (0.6–0.9 across all classes) | Confidence carries no class signal — model regressed to mean ≈ 0.82 with std 0.02. Output raster looks flat. |
+| **V7 run2** (window-level classification on `sample_category`) | Studio output a single polygon covering the entire 13,000 km² AOI, labeled `other` | "Window-level" inference applied to a whole AOI = one prediction for the whole region = majority class |
+| **What V8 enables** (per-pixel regression on **`sample_karst_score`**) | Per-pixel regression with a binary 0/1 target | Each pixel gets a genuine `P(karst)` value. Map is interpretable, thresholdable, AUC-evaluatable. |
+
+## Studio import — recommended workflow
+
+The dataset includes pre-built Studio import files at both `.geojson` and `.json` extensions (Windows MIME pitfall #4):
+
+```
+studio/
+├── import_full.geojson + .json     # 40,989 features (over Studio's 10K cap — use shards)
+└── shards/
+    ├── region_00_lon-78.67_to_-77.74.{geojson,json}  # 8,198 features (W)
+    ├── region_01_lon-77.74_to_-77.15.{geojson,json}  # 8,198
+    ├── region_02_lon-77.15_to_-76.34.{geojson,json}  # 8,198
+    ├── region_03_lon-76.34_to_-75.70.{geojson,json}  # 8,198
+    └── region_04_lon-75.70_to_-74.97.{geojson,json}  # 8,197 (E)
+```
+
+Upload the 5 shards as 5 separate Studio "regions" — each fits under the 1-hour upload limit and is geographically coherent (longitude-sorted, not random).
+
+## Recommended Studio model config for V8
+
+| Wizard step | Choice | Rationale |
+|---|---|---|
+| Model type | **Per-pixel regression** | Continuous raster output, what V6 was trying to be |
+| Label field | **`sample_karst_score`** | The new binary target — must appear in the dropdown alongside `sample_number` |
+| Foundation model | OlmoEarth-v1 default | |
+| Temporal context | A period of time, 12 months, January start | Persistent geomorphic features |
+| Image sources | Sentinel-2 only (Sentinel-1 optional for run upgrade) | Backbone is S2-trained |
+| Patch size | 640 m × 640 m | Captures all 4 feature scales + lithology context |
+| Inference AOI | One Central tile from the 2×2 split (or all 4 sequentially) | Studio's 10,000 km² inference cap |
+
+Expected output: a single-band 10 m float raster with values in `[0, 1]` interpretable as `P(karst)`.
+
+## Audit results
+
+Ran with `scripts/audit.py` from the `olmoearth-data-prep` skill:
+
+```
+[PASS] Volume:               40989 samples
+[PASS] Schema:               studio_import (properties.sample_category) on all 40989
+[PASS] Class distribution:   4 classes, max/min ratio = 9.9
+[PASS] Per-class volume:     all classes >= 30 samples
+[PASS] Negative class:       'other' present
+[PASS] Spatial distribution: largest of 4 k-means clusters holds 32% of points
+[PASS] Polygon cleanliness:  n/a (point dataset)
+```

v8/HF_UPLOAD_INSTRUCTIONS.md

@@ -0,0 +1,94 @@
+# HuggingFace upload instructions — Karst v8
+
+The local rebuild is at `C:\Users\Frank\Downloads\karst_rebuild\`. To push to HF as a new dataset version on `BAIGroup/OlmoEarth-v1-FT-Karst-Groundwater-Base`:
+
+## One-time setup (if not done)
+
+```powershell
+pip install huggingface_hub
+huggingface-cli login   # paste your HF write token (must have write access to BAIGroup org)
+```
+
+## Upload commands
+
+```powershell
+cd C:\Users\Frank\Downloads\karst_rebuild
+
+# 1. Upload the new parquet (replaces or sits alongside the existing one)
+huggingface-cli upload BAIGroup/OlmoEarth-v1-FT-Karst-Groundwater-Base `
+  balanced_karst_v8.parquet `
+  v8/balanced_karst_v8.parquet `
+  --repo-type dataset
+
+# 2. Upload the studio/ folder (import_full + 5 shards, .geojson + .json each)
+huggingface-cli upload BAIGroup/OlmoEarth-v1-FT-Karst-Groundwater-Base `
+  studio `
+  v8/studio `
+  --repo-type dataset
+
+# 3. Upload the addendum so the dataset card documents the v8 changes
+huggingface-cli upload BAIGroup/OlmoEarth-v1-FT-Karst-Groundwater-Base `
+  DATASET_CARD_ADDENDUM.md `
+  v8/DATASET_CARD_ADDENDUM.md `
+  --repo-type dataset
+
+# 4. Upload rebuild summary
+huggingface-cli upload BAIGroup/OlmoEarth-v1-FT-Karst-Groundwater-Base `
+  rebuild_summary.csv `
+  v8/rebuild_summary.csv `
+  --repo-type dataset
+
+# 5. Upload the build script for reproducibility
+huggingface-cli upload BAIGroup/OlmoEarth-v1-FT-Karst-Groundwater-Base `
+  build_balanced_karst_dataset.py `
+  v8/build_balanced_karst_dataset.py `
+  --repo-type dataset
+```
+
+## Alternative: single-shot via Python
+
+```python
+from huggingface_hub import HfApi
+api = HfApi()
+api.upload_folder(
+    folder_path=r"C:\Users\Frank\Downloads\karst_rebuild",
+    repo_id="BAIGroup/OlmoEarth-v1-FT-Karst-Groundwater-Base",
+    repo_type="dataset",
+    path_in_repo="v8",
+    commit_message="v8: rebalanced + sample_karst_score for per-pixel binary karst regression",
+)
+```
+
+## Merging the dataset card
+
+The existing README.md on HF stays as-is. The new `DATASET_CARD_ADDENDUM.md` documents v8 specifically. Option to keep them separate or merge into README later.
+
+If you want to merge into README.md, just append the contents of `DATASET_CARD_ADDENDUM.md` to the existing README before pushing. The YAML frontmatter at the top of the addendum should be stripped if merging into a file that already has frontmatter.
+
+## After upload — verify on HF
+
+1. Visit https://huggingface.co/datasets/BAIGroup/OlmoEarth-v1-FT-Karst-Groundwater-Base/tree/main/v8
+2. Confirm files: `balanced_karst_v8.parquet`, `studio/import_full.geojson`, `studio/shards/region_00..04`
+3. Click the parquet to check schema includes the new columns: `task_name`, `sample_karst_score`
+
+## Studio import — what to upload
+
+You have two options for the V8 run:
+
+### Option A: Single combined upload (preferred if Studio accepts ~16 MB file)
+Upload `studio/import_full.geojson` (or `.json` if Windows MIME blocks the .geojson).
+
+### Option B: 5-shard upload (if Studio chokes on 40K records)
+Upload each of `studio/shards/region_NN.geojson` as a separate region in Studio. They're pre-sorted W-to-E so each shard is geographically coherent.
+
+## V8 model wizard reminder
+
+| Step | Choose |
+|---|---|
+| Model type | **Per-pixel regression** |
+| Label field | **`sample_karst_score`** (should now appear alongside `sample_number`) |
+| Period | 12 months annual, January start |
+| Imagery | Sentinel-2 |
+| Patch | 640 m × 640 m |
+| Training AOI | Central (or Central + East for surface_mine count) |
+| Inference AOI | Central 2×2 tile split (each ≤ 3,200 km², well under Studio's 10,000 km² cap) |

v8/balanced_karst_v8.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:49e6125a0dfcc1085e4e3bec616a49959450fa24ff7f917d25339facd2b349e4
+size 908984

v8/build_balanced_karst_dataset.py

@@ -0,0 +1,225 @@
+"""Rebuild Karst dataset for OlmoEarth Studio with proper balance + sample_karst_score.
+
+Steps:
+  1. Pull parquet from BAIGroup/OlmoEarth-v1-FT-Karst-Groundwater-Base
+  2. Assign AOI (east / central / west) by longitude
+  3. Soft-balance: keep all 22,021 positives + sample 22,021 "other" → 44k features 1:1 karst binary
+  4. Add sample_karst_score (0/1) while keeping sample_number (confidence) untouched
+  5. Emit Studio-import-ready geojson (schema #1: sample_category + sample_*) with dual .geojson/.json
+  6. Auto-shard at 10K (sorted by longitude per pitfall #6) — Studio 1-hour upload cap
+  7. Also emit parquet for HF upload
+  8. Emit dataset_card_addendum.md documenting the new field
+"""
+import json
+import shutil
+from pathlib import Path
+import numpy as np
+import pandas as pd
+
+OUT = Path(r"C:\Users\Frank\Downloads\karst_rebuild")
+OUT.mkdir(exist_ok=True, parents=True)
+PARQUET_URL = "https://huggingface.co/datasets/BAIGroup/OlmoEarth-v1-FT-Karst-Groundwater-Base/resolve/refs%2Fconvert%2Fparquet/default/train/0000.parquet"
+
+# Longitude thresholds for PA AOI assignment (verified against run2 raster bounds)
+LON_WEST_MAX = -78.5      # west:    lon < -78.5
+LON_CENTRAL_MAX = -76.5   # central: -78.5 <= lon < -76.5
+                          # east:    lon >= -76.5
+
+# Studio 1-hour upload cap per shard
+MAX_PER_SHARD = 10000
+
+# RNG seed for reproducibility
+RNG = np.random.default_rng(42)
+
+
+def assign_aoi(lon: float) -> str:
+    if lon < LON_WEST_MAX:
+        return "pa_karst_west"
+    if lon < LON_CENTRAL_MAX:
+        return "pa_karst_central"
+    return "pa_karst_east"
+
+
+def main():
+    print("=" * 72)
+    print("Karst dataset rebuild — balanced + sample_karst_score")
+    print("=" * 72)
+
+    # ---- 1. Pull parquet ----
+    print(f"\n[1] Fetching parquet from HF...")
+    df = pd.read_parquet(PARQUET_URL)
+    print(f"    loaded {len(df):,} rows  /  columns: {list(df.columns)}")
+
+    # ---- 2. AOI assignment ----
+    print(f"\n[2] Assigning AOIs by longitude (W<{LON_WEST_MAX}, C<{LON_CENTRAL_MAX}, E>=)...")
+    df["task_name"] = df["lon"].apply(assign_aoi)
+    print("\n    AOI distribution:")
+    print(df["task_name"].value_counts().to_string())
+
+    # ---- 3. Soft balance: all positives + sampled negatives 1:1 ----
+    print(f"\n[3] Soft balance — keep all positives, subsample 'other' to 1:1 binary ratio")
+    print("\n    Original class distribution:")
+    print(df["tag"].value_counts().to_string())
+
+    positives = df[df["tag"] != "other"].copy()
+    negatives = df[df["tag"] == "other"].copy()
+    n_pos = len(positives)
+    # Cap "other" at 9.9x the smallest class to satisfy audit pitfall #5 (max/min ratio < 10)
+    min_class_count = positives["tag"].value_counts().min()  # surface_mine = 1,916
+    n_neg_target = min(n_pos, int(min_class_count * 9.9))    # = 18,968 — passes audit
+    print(f"    smallest class count: {min_class_count:,} (surface_mine)")
+    print(f"    capping 'other' at 9.9x = {n_neg_target:,} to keep max/min ratio < 10")
+
+    # Stratified sample of negatives by AOI to preserve regional proportion
+    print(f"\n    positives total: {n_pos:,}  /  target negatives: {n_neg_target:,}")
+    neg_per_aoi = negatives["task_name"].value_counts()
+    print(f"    negatives per AOI before sampling:")
+    print(neg_per_aoi.to_string())
+
+    # Proportional allocation across AOIs
+    sampled_neg = []
+    for aoi, total_in_aoi in neg_per_aoi.items():
+        # match each AOI's negative share to its share of original negatives
+        share = total_in_aoi / negatives.shape[0]
+        n_take = int(round(n_neg_target * share))
+        n_take = min(n_take, total_in_aoi)
+        aoi_negs = negatives[negatives["task_name"] == aoi]
+        sampled_neg.append(aoi_negs.sample(n=n_take, random_state=42))
+        print(f"      {aoi}: sampling {n_take:,} of {total_in_aoi:,} negatives ({share*100:.1f}% share)")
+    neg_sampled = pd.concat(sampled_neg, ignore_index=True)
+
+    combined = pd.concat([positives, neg_sampled], ignore_index=True)
+    combined = combined.sample(frac=1, random_state=42).reset_index(drop=True)  # shuffle
+    print(f"\n    combined dataset: {len(combined):,} rows")
+    print(f"    final class distribution:")
+    print(combined["tag"].value_counts().to_string())
+    print(f"    final AOI distribution:")
+    print(combined["task_name"].value_counts().to_string())
+
+    # ---- 4. Add sample_karst_score (the whole point) ----
+    print(f"\n[4] Adding sample_karst_score field (0.0=other, 1.0=karst)")
+    combined["sample_karst_score"] = np.where(combined["tag"] == "other", 0.0, 1.0)
+    print("    sample_karst_score distribution:")
+    print(combined["sample_karst_score"].value_counts().to_string())
+
+    # Sanity check: class ratio for audit (pitfall #5)
+    ratio = combined["tag"].value_counts().max() / combined["tag"].value_counts().min()
+    print(f"\n    max/min class ratio: {ratio:.1f}  (audit warn threshold = 10)")
+
+    # ---- 5. Build Studio import features (schema #1) ----
+    print(f"\n[5] Building Studio import features (schema #1: properties.sample_category)")
+    features = []
+    for _, row in combined.iterrows():
+        # observation_time: use start of label window
+        obs_time = str(row["oe_start_time"]).split("+")[0].replace(" ", "T") + "Z"
+        feat = {
+            "type": "Feature",
+            "geometry": {
+                "type": "Point",
+                "coordinates": [float(row["lon"]), float(row["lat"])],
+            },
+            "properties": {
+                # Studio framework fields (no sample_ prefix)
+                "task_name": str(row["task_name"]),
+                "observation_time": obs_time,
+                # Studio recognized class label
+                "sample_category": str(row["tag"]),
+                # Original confidence preserved as sample_number (Studio's recognized numeric field)
+                "sample_number": float(row["confidence"]),
+                # NEW: binary karst regression target
+                "sample_karst_score": float(row["sample_karst_score"]),
+                # auto_generated flag (matches original Studio mapping)
+                "sample_true_false": bool(row["auto_generated"]),
+                # Extra audit fields (Studio ignores, useful for downstream)
+                "sample_quality_flags": str(row["quality_flags"]) if pd.notna(row["quality_flags"]) else "",
+                "sample_merged_from_cave": bool(row["merged_from_cave"]),
+            },
+        }
+        features.append(feat)
+    print(f"    built {len(features):,} features")
+
+    # ---- 6. Spatial sort + shard at MAX_PER_SHARD ----
+    print(f"\n[6] Spatial-sort by longitude + shard at {MAX_PER_SHARD:,}/shard (pitfalls #6, #7)")
+    features.sort(key=lambda f: f["geometry"]["coordinates"][0])  # sort by lon
+    n_shards = (len(features) + MAX_PER_SHARD - 1) // MAX_PER_SHARD
+    shard_size = (len(features) + n_shards - 1) // n_shards
+    shards = [features[i : i + shard_size] for i in range(0, len(features), shard_size)]
+    print(f"    -> {len(shards)} shards of ~{shard_size:,} each (sorted W-to-E)")
+
+    # ---- 7. Write outputs ----
+    print(f"\n[7] Writing outputs to {OUT}")
+
+    # Full combined file (one big import.geojson + .json, before sharding — for reference)
+    fc_full = {"type": "FeatureCollection", "features": features}
+    full_gj = OUT / "studio" / "import_full.geojson"
+    full_gj.parent.mkdir(exist_ok=True, parents=True)
+    full_gj.write_text(json.dumps(fc_full))
+    shutil.copy2(full_gj, OUT / "studio" / "import_full.json")
+    print(f"    wrote studio/import_full.geojson + .json  ({len(features):,} features)")
+
+    # Sharded files (Studio uploads — these are what user uses)
+    shards_dir = OUT / "studio" / "shards"
+    shards_dir.mkdir(exist_ok=True)
+    for i, shard in enumerate(shards):
+        # Determine geographic descriptor for shard
+        lons = [f["geometry"]["coordinates"][0] for f in shard]
+        lon_range = f"{min(lons):.2f}_to_{max(lons):.2f}"
+        name = f"region_{i:02d}_lon{lon_range}"
+        gj_path = shards_dir / f"{name}.geojson"
+        json_path = shards_dir / f"{name}.json"
+        gj_path.write_text(json.dumps({"type": "FeatureCollection", "features": shard}))
+        shutil.copy2(gj_path, json_path)
+        print(f"    wrote shards/{name}.{{geojson,json}}  ({len(shard):,} features)")
+
+    # Parquet (HF dataset payload)
+    parquet_path = OUT / "balanced_karst_v8.parquet"
+    # Add task_name + sample_karst_score columns to parquet
+    parquet_df = combined[[
+        "category", "tag", "lon", "lat", "oe_start_time", "oe_end_time",
+        "oe_annotations_task_id", "confidence", "quality_flags",
+        "auto_generated", "merged_from_cave",
+        # NEW columns
+        "task_name", "sample_karst_score",
+    ]].copy()
+    parquet_df.to_parquet(parquet_path, index=False)
+    print(f"    wrote {parquet_path.name}  ({len(parquet_df):,} rows, {len(parquet_df.columns)} cols)")
+
+    # Summary CSV for the user's records
+    summary = pd.DataFrame({
+        "metric": [
+            "total_features",
+            "n_positives (karst)",
+            "n_negatives (other)",
+            "n_west",
+            "n_central",
+            "n_east",
+            "max_min_class_ratio",
+            "sample_karst_score_mean",
+            "n_shards",
+            "shard_size_target",
+        ],
+        "value": [
+            len(combined),
+            int((combined["sample_karst_score"] == 1.0).sum()),
+            int((combined["sample_karst_score"] == 0.0).sum()),
+            int((combined["task_name"] == "pa_karst_west").sum()),
+            int((combined["task_name"] == "pa_karst_central").sum()),
+            int((combined["task_name"] == "pa_karst_east").sum()),
+            round(ratio, 2),
+            round(combined["sample_karst_score"].mean(), 3),
+            len(shards),
+            shard_size,
+        ],
+    })
+    summary_path = OUT / "rebuild_summary.csv"
+    summary.to_csv(summary_path, index=False)
+    print(f"    wrote {summary_path.name}")
+
+    print(f"\n{'=' * 72}")
+    print("DONE. Run audit next:")
+    print(f"  python {Path(r'C:/Users/Frank/.claude/skills/olmoearth-data-prep/scripts/audit.py')}  {full_gj}")
+    print(f"{'=' * 72}")
+
+
+if __name__ == "__main__":
+    main()

v8/evaluate_v8_vs_v6.py

@@ -0,0 +1,321 @@
+"""evaluate_v8_vs_v6.py
+
+V8 vs V6 evaluation harness for the Karst per-pixel regression task.
+
+What it does:
+  1. Samples V8 (and V6) raster values at every labeled point in the v8 parquet
+  2. Computes AUC of sample_karst_score against model predictions:
+       - in-sample (all labels)
+       - held-out-by-shard (longitude-banded, mimics spatial CV)
+  3. Plots per-class score distributions, ROC curves, and spatial diff maps
+  4. Reports the value-distribution fingerprint (was V6's mean=0.82 std=0.02 fixed?)
+  5. Writes everything to <out_dir>/
+
+Usage:
+  python evaluate_v8_vs_v6.py ^
+    --v8-rasters "C:\\Users\\Frank\\Downloads\\PA_KARST_Central_V8_run*\\*.tif" ^
+    --v6-rasters "C:\\Users\\Frank\\Downloads\\PA_KARST_Central_V6_run2\\*.tif" ^
+    --labels    "C:\\Users\\Frank\\Downloads\\karst_rebuild\\balanced_karst_v8.parquet" ^
+    --out       "C:\\Users\\Frank\\Downloads\\v8_vs_v6_eval"
+
+Dependencies: rasterio, numpy, pandas, matplotlib, scikit-learn
+"""
+from __future__ import annotations
+import argparse
+import glob
+import json
+from pathlib import Path
+import sys
+
+import numpy as np
+import pandas as pd
+import rasterio
+from rasterio.warp import transform as warp_transform
+import matplotlib.pyplot as plt
+from sklearn.metrics import roc_auc_score, roc_curve, average_precision_score
+
+
+def expand_rasters(patterns: list[str]) -> list[Path]:
+    """Resolve glob patterns to a flat list of raster paths."""
+    out = []
+    for p in patterns:
+        matches = sorted(glob.glob(p))
+        if not matches:
+            print(f"  WARN: no rasters match '{p}'")
+        out.extend(Path(m) for m in matches)
+    return out
+
+
+def sample_raster_at_points(raster: Path, lons: np.ndarray, lats: np.ndarray) -> np.ndarray:
+    """Sample raster value at each (lon, lat). Returns NaN for points outside raster."""
+    with rasterio.open(raster) as ds:
+        # Transform WGS84 points to raster CRS
+        xs, ys = warp_transform("EPSG:4326", ds.crs, lons.tolist(), lats.tolist())
+        xs = np.array(xs)
+        ys = np.array(ys)
+
+        # Convert to row/col indices
+        # rasterio's index() takes (x, y) one at a time; vectorize via Affine inverse
+        inv = ~ds.transform
+        cols_f, rows_f = inv * (xs, ys)
+        cols = np.round(cols_f).astype(int)
+        rows = np.round(rows_f).astype(int)
+
+        # Mask out-of-bounds
+        h, w = ds.shape
+        valid = (rows >= 0) & (rows < h) & (cols >= 0) & (cols < w)
+
+        # Read raster (small enough — 1 band)
+        arr = ds.read(1)
+        nd = ds.nodata
+
+        out = np.full(len(lons), np.nan)
+        out[valid] = arr[rows[valid], cols[valid]]
+        if nd is not None:
+            out[out == nd] = np.nan
+    return out
+
+
+def sample_multi_raster(rasters: list[Path], lons: np.ndarray, lats: np.ndarray) -> np.ndarray:
+    """Sample across multiple rasters; for each point use first raster that contains it."""
+    if not rasters:
+        return np.full(len(lons), np.nan)
+    out = np.full(len(lons), np.nan)
+    for r in rasters:
+        vals = sample_raster_at_points(r, lons, lats)
+        mask = np.isnan(out) & ~np.isnan(vals)
+        out[mask] = vals[mask]
+    return out
+
+
+def value_fingerprint(name: str, vals: np.ndarray) -> dict:
+    v = vals[~np.isnan(vals)]
+    if len(v) == 0:
+        return {"name": name, "n": 0}
+    return {
+        "name": name,
+        "n": int(len(v)),
+        "min": float(v.min()),
+        "p1": float(np.percentile(v, 1)),
+        "p25": float(np.percentile(v, 25)),
+        "mean": float(v.mean()),
+        "median": float(np.median(v)),
+        "p75": float(np.percentile(v, 75)),
+        "p99": float(np.percentile(v, 99)),
+        "max": float(v.max()),
+        "std": float(v.std()),
+    }
+
+
+def compute_aucs(y: np.ndarray, scores: np.ndarray, label: str) -> dict:
+    """ROC-AUC + PR-AUC + summary. Returns NaN entries if data is missing."""
+    mask = ~np.isnan(scores) & ~np.isnan(y)
+    if mask.sum() < 20 or len(np.unique(y[mask])) < 2:
+        return {"label": label, "n": int(mask.sum()), "roc_auc": float("nan"), "pr_auc": float("nan")}
+    return {
+        "label": label,
+        "n": int(mask.sum()),
+        "roc_auc": float(roc_auc_score(y[mask], scores[mask])),
+        "pr_auc": float(average_precision_score(y[mask], scores[mask])),
+        "positive_rate": float(y[mask].mean()),
+    }
+
+
+def plot_score_histograms(df: pd.DataFrame, score_col: str, model_name: str, out_path: Path):
+    fig, ax = plt.subplots(1, 1, figsize=(8, 5))
+    valid = df.dropna(subset=[score_col])
+    for cat, color in zip(
+        ["other", "surface_depression", "sinkhole", "surface_mine"],
+        ["#888", "#d62728", "#2ca02c", "#1f77b4"],
+    ):
+        sub = valid[valid["sample_category"] == cat]
+        if len(sub):
+            ax.hist(
+                sub[score_col], bins=50, alpha=0.5, label=f"{cat} (n={len(sub):,})",
+                color=color, density=True,
+            )
+    ax.set_xlabel(f"{model_name} predicted score at label point")
+    ax.set_ylabel("density")
+    ax.set_title(f"{model_name} score distribution by true class")
+    ax.legend()
+    ax.grid(alpha=0.3)
+    fig.tight_layout()
+    fig.savefig(out_path, dpi=120)
+    plt.close(fig)
+
+
+def plot_roc(y: np.ndarray, scores: dict[str, np.ndarray], out_path: Path):
+    fig, ax = plt.subplots(1, 1, figsize=(6, 6))
+    for name, s in scores.items():
+        mask = ~np.isnan(s) & ~np.isnan(y)
+        if mask.sum() < 20 or len(np.unique(y[mask])) < 2:
+            continue
+        fpr, tpr, _ = roc_curve(y[mask], s[mask])
+        auc = roc_auc_score(y[mask], s[mask])
+        ax.plot(fpr, tpr, lw=2, label=f"{name}  AUC={auc:.3f}")
+    ax.plot([0, 1], [0, 1], color="gray", lw=1, linestyle="--", label="random")
+    ax.set_xlabel("FPR"); ax.set_ylabel("TPR")
+    ax.set_title("ROC — V6 (regression on confidence) vs V8 (regression on sample_karst_score)")
+    ax.legend(loc="lower right")
+    ax.grid(alpha=0.3)
+    fig.tight_layout()
+    fig.savefig(out_path, dpi=120)
+    plt.close(fig)
+
+
+def plot_v8_v6_scatter(df: pd.DataFrame, out_path: Path):
+    """Scatter V8 score vs V6 score, colored by true class."""
+    fig, ax = plt.subplots(1, 1, figsize=(7, 7))
+    valid = df.dropna(subset=["v8_score", "v6_score"])
+    for cat, color in zip(
+        ["other", "surface_depression", "sinkhole", "surface_mine"],
+        ["#888", "#d62728", "#2ca02c", "#1f77b4"],
+    ):
+        sub = valid[valid["sample_category"] == cat]
+        if len(sub):
+            ax.scatter(sub["v6_score"], sub["v8_score"], s=2, alpha=0.3, color=color, label=f"{cat} (n={len(sub):,})")
+    ax.set_xlabel("V6 score (regression on confidence)")
+    ax.set_ylabel("V8 score (regression on sample_karst_score)")
+    ax.set_title("V8 vs V6 — point-wise comparison\n(want V8 to spread; V6 was stuck near 0.82)")
+    ax.legend(markerscale=4, loc="upper left")
+    ax.grid(alpha=0.3)
+    fig.tight_layout()
+    fig.savefig(out_path, dpi=120)
+    plt.close(fig)
+
+
+def spatial_holdout(df: pd.DataFrame, k: int = 5) -> pd.Series:
+    """Assign each point to a longitude-banded fold (0..k-1). Mimics how we sharded."""
+    sorted_idx = df["lon"].sort_values().index
+    fold = pd.Series(0, index=df.index, dtype=int)
+    band_size = len(df) // k
+    for i in range(k):
+        start = i * band_size
+        end = (i + 1) * band_size if i < k - 1 else len(df)
+        fold.loc[sorted_idx[start:end]] = i
+    return fold
+
+
+def main():
+    ap = argparse.ArgumentParser(description="V8 vs V6 evaluation")
+    ap.add_argument("--v8-rasters", nargs="+", required=True,
+                    help="V8 prediction raster path(s) — supports globs (use quotes)")
+    ap.add_argument("--v6-rasters", nargs="*", default=[],
+                    help="V6 raster path(s) for comparison. Optional but recommended.")
+    ap.add_argument("--labels", required=True,
+                    help="balanced_karst_v8.parquet path")
+    ap.add_argument("--out", required=True, help="Output directory")
+    ap.add_argument("--holdout-fold", type=int, default=2,
+                    help="Which longitude band (0..4) to treat as held-out for spatial-CV AUC (default 2 = middle)")
+    args = ap.parse_args()
+
+    out = Path(args.out)
+    out.mkdir(parents=True, exist_ok=True)
+
+    print(f"[1] Loading labels from {args.labels}")
+    df = pd.read_parquet(args.labels)
+    print(f"    {len(df):,} rows  /  classes: {df['sample_category'].value_counts().to_dict() if 'sample_category' in df.columns else df['tag'].value_counts().to_dict()}")
+    # Column compat: parquet has 'tag' and 'sample_karst_score' from build script
+    if "sample_category" not in df.columns and "tag" in df.columns:
+        df["sample_category"] = df["tag"]
+
+    y = df["sample_karst_score"].values
+    lons = df["lon"].values.astype(float)
+    lats = df["lat"].values.astype(float)
+
+    print(f"\n[2] Resolving V8 rasters...")
+    v8_paths = expand_rasters(args.v8_rasters)
+    print(f"    found {len(v8_paths)} V8 raster(s):")
+    for p in v8_paths:
+        print(f"      {p}")
+
+    v6_paths = expand_rasters(args.v6_rasters) if args.v6_rasters else []
+    if v6_paths:
+        print(f"\n[3] Resolving V6 rasters...")
+        print(f"    found {len(v6_paths)} V6 raster(s):")
+        for p in v6_paths:
+            print(f"      {p}")
+
+    if not v8_paths:
+        print("ERROR: no V8 rasters found — pass --v8-rasters with valid paths/globs")
+        sys.exit(2)
+
+    print(f"\n[4] Sampling raster values at {len(df):,} label points...")
+    df["v8_score"] = sample_multi_raster(v8_paths, lons, lats)
+    print(f"    V8 valid samples: {(~np.isnan(df['v8_score'])).sum():,} / {len(df):,}")
+
+    if v6_paths:
+        df["v6_score"] = sample_multi_raster(v6_paths, lons, lats)
+        print(f"    V6 valid samples: {(~np.isnan(df['v6_score'])).sum():,} / {len(df):,}")
+    else:
+        df["v6_score"] = np.nan
+
+    print(f"\n[5] Value distribution fingerprints")
+    print(f"    (V6 ground truth from run2 was: mean=0.82 std=0.02 — flat regression-to-mean failure)")
+    fps = []
+    for name, col in [("V6", "v6_score"), ("V8", "v8_score")]:
+        fp = value_fingerprint(name, df[col].values)
+        fps.append(fp)
+        if fp.get("n", 0):
+            print(f"    {name}: n={fp['n']:,}  min={fp['min']:.4f}  mean={fp['mean']:.4f}  std={fp['std']:.4f}  max={fp['max']:.4f}")
+            print(f"         p1={fp['p1']:.4f}  p25={fp['p25']:.4f}  median={fp['median']:.4f}  p75={fp['p75']:.4f}  p99={fp['p99']:.4f}")
+    pd.DataFrame(fps).to_csv(out / "value_fingerprints.csv", index=False)
+
+    print(f"\n[6] AUCs — in-sample (all 40,989 labels)")
+    in_sample = []
+    for name, col in [("V6", "v6_score"), ("V8", "v8_score")]:
+        r = compute_aucs(y, df[col].values, f"{name}_in_sample")
+        in_sample.append(r)
+        if not np.isnan(r.get("roc_auc", np.nan)):
+            print(f"    {r['label']:>20s}  n={r['n']:>6,}  ROC-AUC={r['roc_auc']:.4f}  PR-AUC={r['pr_auc']:.4f}  pos-rate={r['positive_rate']:.3f}")
+        else:
+            print(f"    {r['label']:>20s}  no overlap / insufficient data")
+
+    print(f"\n[7] AUCs — spatial holdout (longitude fold {args.holdout_fold} of 5)")
+    df["fold"] = spatial_holdout(df, k=5)
+    holdout = df[df["fold"] == args.holdout_fold]
+    print(f"    holdout n={len(holdout):,}  lon range=[{holdout['lon'].min():.2f}, {holdout['lon'].max():.2f}]")
+    holdout_aucs = []
+    for name, col in [("V6", "v6_score"), ("V8", "v8_score")]:
+        r = compute_aucs(holdout["sample_karst_score"].values, holdout[col].values, f"{name}_holdout_fold{args.holdout_fold}")
+        holdout_aucs.append(r)
+        if not np.isnan(r.get("roc_auc", np.nan)):
+            print(f"    {r['label']:>30s}  n={r['n']:>6,}  ROC-AUC={r['roc_auc']:.4f}  PR-AUC={r['pr_auc']:.4f}")
+
+    pd.DataFrame(in_sample + holdout_aucs).to_csv(out / "auc_summary.csv", index=False)
+
+    print(f"\n[8] Plotting diagnostics...")
+    plot_score_histograms(df, "v8_score", "V8", out / "hist_v8_by_class.png")
+    print(f"    wrote hist_v8_by_class.png")
+    if v6_paths:
+        plot_score_histograms(df, "v6_score", "V6", out / "hist_v6_by_class.png")
+        print(f"    wrote hist_v6_by_class.png")
+
+    scores = {"V8": df["v8_score"].values}
+    if v6_paths:
+        scores["V6"] = df["v6_score"].values
+    plot_roc(y, scores, out / "roc_v8_v6.png")
+    print(f"    wrote roc_v8_v6.png")
+
+    if v6_paths:
+        plot_v8_v6_scatter(df, out / "scatter_v8_v6.png")
+        print(f"    wrote scatter_v8_v6.png")
+
+    # Save full per-point sample table
+    df_out = df[["lon", "lat", "task_name", "sample_category", "sample_karst_score", "v8_score", "v6_score", "fold"]]
+    df_out.to_csv(out / "per_point_scores.csv", index=False)
+    print(f"    wrote per_point_scores.csv  ({len(df_out):,} rows)")
+
+    print(f"\n{'=' * 70}")
+    print("VERDICT GUIDE:")
+    print(f"  V6 in-sample AUC was likely ~0.50–0.55 (the regression-to-mean failure)")
+    print(f"  V8 should target:")
+    print(f"    - in-sample AUC > 0.80  (model fits)")
+    print(f"    - holdout AUC   > 0.70  (model generalizes spatially)")
+    print(f"    - value std > 0.10 (real spatial discrimination, not flat 0.82±0.02)")
+    print(f"    - histogram visibly bimodal (modes near 0 and 1)")
+    print(f"{'=' * 70}")
+
+
+if __name__ == "__main__":
+    main()

v8/rebuild_summary.csv

@@ -0,0 +1,11 @@
+metric,value
+total_features,40989.0
+n_positives (karst),22021.0
+n_negatives (other),18968.0
+n_west,557.0
+n_central,21517.0
+n_east,18915.0
+max_min_class_ratio,9.9
+sample_karst_score_mean,0.537
+n_shards,5.0
+shard_size_target,8198.0

v8/studio/import_full.geojson

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

v8/studio/import_full.json

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