| |
| """Evaluate the declared Sentinel-1 Otsu baseline against evaluator-only labels. |
| |
| The canonical tasks intentionally ask for properties of a predicted mask. This |
| script is a separate construct-validity check: it recreates that mask from each |
| declared S1 input and compares it with the Sen1Floods11 ``LabelHand`` reference. |
| Reference labels are never added to the agent's initial artifacts or answers. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| from collections import Counter, defaultdict |
| from pathlib import Path |
| from typing import Any, Iterable |
|
|
| import numpy as np |
| import rasterio |
|
|
|
|
| METHOD = "s1_min_backscatter_otsu_v1" |
| REFERENCE_NAME = "Sen1Floods11 v1.1 LabelHand" |
| ACCURACY_KEYS = {"accuracy", "iou", "f1", "precision", "recall"} |
|
|
|
|
| def sha256(path: Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as stream: |
| for chunk in iter(lambda: stream.read(1024 * 1024), b""): |
| digest.update(chunk) |
| return digest.hexdigest() |
|
|
|
|
| def round6(value: float | None) -> float | None: |
| return None if value is None else round(float(value), 6) |
|
|
|
|
| def safe_div(numerator: int, denominator: int) -> float | None: |
| return None if denominator == 0 else numerator / denominator |
|
|
|
|
| def otsu_threshold(values: np.ndarray) -> float: |
| """Match the worker's 256-bin Otsu implementation exactly.""" |
| values = values[np.isfinite(values)] |
| if values.size == 0: |
| return 0.0 |
| hist, edges = np.histogram(values, bins=256) |
| centers = (edges[:-1] + edges[1:]) / 2 |
| total = int(hist.sum()) |
| if total == 0: |
| return float(np.nanmean(values)) |
| weight1 = np.cumsum(hist) |
| weight2 = total - weight1 |
| mean1 = np.cumsum(hist * centers) / np.maximum(weight1, 1) |
| mean2 = ( |
| np.cumsum((hist * centers)[::-1]) |
| / np.maximum(np.cumsum(hist[::-1]), 1) |
| )[::-1] |
| between = weight1[:-1] * weight2[:-1] * (mean1[:-1] - mean2[1:]) ** 2 |
| if between.size == 0: |
| return float(np.nanmean(values)) |
| return float(centers[:-1][int(np.argmax(between))]) |
|
|
|
|
| def predicted_mask(path: Path) -> tuple[np.ndarray, np.ndarray, float, dict[str, Any]]: |
| with rasterio.open(path) as dataset: |
| band1 = dataset.read(1).astype("float32") |
| band2 = dataset.read(2).astype("float32") if dataset.count >= 2 else band1 |
| valid = np.isfinite(band1) & np.isfinite(band2) |
| if dataset.nodata is not None and np.isfinite(float(dataset.nodata)): |
| valid &= (band1 != float(dataset.nodata)) & (band2 != float(dataset.nodata)) |
| score = np.minimum(band1, band2) |
| threshold = otsu_threshold(score[valid]) |
| mask = valid & (score <= threshold) |
| profile = { |
| "shape": [dataset.height, dataset.width], |
| "crs": str(dataset.crs) if dataset.crs else None, |
| "transform": list(dataset.transform)[:6], |
| } |
| return mask, valid, threshold, profile |
|
|
|
|
| def contains_accuracy_field(value: Any) -> bool: |
| if isinstance(value, dict): |
| if any(str(key).lower() in ACCURACY_KEYS for key in value): |
| return True |
| return any(contains_accuracy_field(item) for item in value.values()) |
| if isinstance(value, list): |
| return any(contains_accuracy_field(item) for item in value) |
| return False |
|
|
|
|
| def declared_paths(value: Any) -> Iterable[str]: |
| if isinstance(value, dict): |
| path = value.get("path") |
| if isinstance(path, str): |
| yield path |
| for item in value.values(): |
| yield from declared_paths(item) |
| elif isinstance(value, list): |
| for item in value: |
| yield from declared_paths(item) |
|
|
|
|
| def load_contract(dataset_path: Path) -> tuple[dict[str, dict[str, Any]], dict[str, Any]]: |
| samples: dict[str, dict[str, Any]] = {} |
| records = [] |
| forbidden_declarations = [] |
| accuracy_answer_ids = [] |
| wrong_method_ids = [] |
|
|
| with dataset_path.open(encoding="utf-8") as stream: |
| for line_number, line in enumerate(stream, 1): |
| record = json.loads(line) |
| record_id = str(record.get("id", "")) |
| if not record_id.startswith("sen1_flood/"): |
| continue |
| records.append(record) |
| sample_id = str(record["sample_id"]) |
| question_type = str(record["question_type"]) |
| expected = record.get("expected_final_answer") or {} |
| if expected.get("prediction_method") != METHOD: |
| wrong_method_ids.append(record_id) |
| if contains_accuracy_field(expected): |
| accuracy_answer_ids.append(record_id) |
| for path in declared_paths(record.get("initial_artifacts") or {}): |
| lowered = path.lower() |
| if "/labelhand.tif" in lowered or "s1otsulabelhand.tif" in lowered: |
| forbidden_declarations.append({"id": record_id, "path": path}) |
|
|
| s1_path = ( |
| record["initial_artifacts"]["sar_chip_1"]["paths"]["s1_image"]["path"] |
| ) |
| entry = samples.setdefault( |
| sample_id, |
| { |
| "sample_id": sample_id, |
| "split": record["split"], |
| "s1_path": s1_path, |
| "question_types": [], |
| "expected_flood_percentages": [], |
| }, |
| ) |
| if entry["split"] != record["split"] or entry["s1_path"] != s1_path: |
| raise ValueError(f"inconsistent split or S1 path for {sample_id}") |
| entry["question_types"].append(question_type) |
| if "flood_percentage" in expected: |
| entry["expected_flood_percentages"].append( |
| {"question_type": question_type, "value": float(expected["flood_percentage"])} |
| ) |
|
|
| if len(records) != 500 or len(samples) != 100: |
| raise ValueError(f"expected 500 records/100 samples, found {len(records)}/{len(samples)}") |
| for sample_id, entry in samples.items(): |
| if Counter(entry["question_types"]) != Counter("ABCDE"): |
| raise ValueError(f"{sample_id}: expected one record for each of A-E") |
|
|
| audit = { |
| "records": len(records), |
| "unique_samples": len(samples), |
| "question_types": sorted({str(row["question_type"]) for row in records}), |
| "records_with_declared_reference_label": len(forbidden_declarations), |
| "declared_reference_label_violations": forbidden_declarations, |
| "records_with_accuracy_fields_in_expected_answer": len(accuracy_answer_ids), |
| "accuracy_field_answer_ids": accuracy_answer_ids, |
| "records_with_wrong_or_missing_prediction_method": len(wrong_method_ids), |
| "wrong_method_ids": wrong_method_ids, |
| "expected_answer_contract": ( |
| "agent-facing answers describe deterministic Otsu predictions; " |
| "reference-label accuracy is evaluator-only" |
| ), |
| } |
| return samples, audit |
|
|
|
|
| def evaluate_sample(root: Path, entry: dict[str, Any]) -> dict[str, Any]: |
| sample_id = entry["sample_id"] |
| s1_path = root / entry["s1_path"] |
| label_path = root / "source_assets" / "sen1_flood" / sample_id / "labels" / "LabelHand.tif" |
| if not s1_path.is_file(): |
| raise FileNotFoundError(f"missing declared S1 input: {s1_path}") |
| if not label_path.is_file(): |
| raise FileNotFoundError(f"missing evaluator-only reference label: {label_path}") |
|
|
| prediction, source_valid, threshold, source_profile = predicted_mask(s1_path) |
| with rasterio.open(label_path) as dataset: |
| label = dataset.read(1) |
| label_profile = { |
| "shape": [dataset.height, dataset.width], |
| "crs": str(dataset.crs) if dataset.crs else None, |
| "transform": list(dataset.transform)[:6], |
| } |
| same_grid = ( |
| source_profile["shape"] == label_profile["shape"] |
| and source_profile["crs"] == label_profile["crs"] |
| and np.allclose( |
| source_profile["transform"], |
| label_profile["transform"], |
| rtol=0.0, |
| atol=1e-12, |
| ) |
| ) |
| if not same_grid: |
| raise ValueError(f"{sample_id}: S1/reference grids differ") |
| values = {int(value) for value in np.unique(label)} |
| if not values.issubset({-1, 0, 1}): |
| raise ValueError(f"{sample_id}: unsupported reference values {sorted(values)}") |
|
|
| full_prediction_count = int(prediction.sum()) |
| full_valid_count = int(source_valid.sum()) |
| full_percentage = full_prediction_count / full_valid_count * 100 if full_valid_count else 0.0 |
| expected_percentages = entry["expected_flood_percentages"] |
| canonical_percentage_match = bool(expected_percentages) and all( |
| abs(round(full_percentage, 6) - round(item["value"], 6)) <= 1e-6 |
| for item in expected_percentages |
| ) |
|
|
| valid = label != -1 |
| ground_truth = label == 1 |
| prediction = prediction & valid |
| tp = int((prediction & ground_truth).sum()) |
| fp = int((prediction & (label == 0)).sum()) |
| fn = int(((~prediction) & ground_truth & valid).sum()) |
| tn = int(((~prediction) & (label == 0) & valid).sum()) |
| precision = safe_div(tp, tp + fp) |
| recall = safe_div(tp, tp + fn) |
| iou = safe_div(tp, tp + fp + fn) |
| f1 = safe_div(2 * tp, 2 * tp + fp + fn) |
|
|
| return { |
| "sample_id": sample_id, |
| "split": entry["split"], |
| "question_record_count": 5, |
| "prediction_method": METHOD, |
| "reference": REFERENCE_NAME, |
| "s1_path": entry["s1_path"], |
| "reference_label_path": str(label_path.relative_to(root)), |
| "s1_sha256": sha256(s1_path), |
| "reference_label_sha256": sha256(label_path), |
| "prediction_threshold": round(float(threshold), 8), |
| "computed_full_s1_flood_percentage": round6(full_percentage), |
| "canonical_expected_flood_percentages": expected_percentages, |
| "canonical_prediction_percentage_match": canonical_percentage_match, |
| "valid_reference_pixels": int(valid.sum()), |
| "reference_flood_pixels": int(ground_truth.sum()), |
| "predicted_flood_pixels_in_reference_footprint": int(prediction.sum()), |
| "TP": tp, |
| "FP": fp, |
| "FN": fn, |
| "TN": tn, |
| "IoU": round6(iou), |
| "precision": round6(precision), |
| "recall": round6(recall), |
| "F1": round6(f1), |
| } |
|
|
|
|
| def summarize(rows: list[dict[str, Any]]) -> dict[str, Any]: |
| def metric_mean(name: str) -> float | None: |
| values = [float(row[name]) for row in rows if row.get(name) is not None] |
| return round6(float(np.mean(values))) if values else None |
|
|
| aggregate = {name: sum(int(row[name]) for row in rows) for name in ("TP", "FP", "FN", "TN")} |
| tp, fp, fn = aggregate["TP"], aggregate["FP"], aggregate["FN"] |
| return { |
| "samples": len(rows), |
| "question_records_represented": len(rows) * 5, |
| "samples_without_reference_flood_pixels": sum( |
| int(row["reference_flood_pixels"]) == 0 for row in rows |
| ), |
| "macro": { |
| "IoU": metric_mean("IoU"), |
| "precision": metric_mean("precision"), |
| "recall": metric_mean("recall"), |
| "F1": metric_mean("F1"), |
| "recall_defined_samples": sum(row.get("recall") is not None for row in rows), |
| }, |
| "aggregate_confusion": aggregate, |
| "micro": { |
| "IoU": round6(safe_div(tp, tp + fp + fn)), |
| "precision": round6(safe_div(tp, tp + fp)), |
| "recall": round6(safe_div(tp, tp + fn)), |
| "F1": round6(safe_div(2 * tp, 2 * tp + fp + fn)), |
| }, |
| } |
|
|
|
|
| def write_report(output_dir: Path, result: dict[str, Any]) -> None: |
| output_dir.mkdir(parents=True, exist_ok=True) |
| (output_dir / "summary.json").write_text( |
| json.dumps(result, indent=2, sort_keys=False) + "\n", encoding="utf-8" |
| ) |
| with (output_dir / "per_sample_metrics.jsonl").open("w", encoding="utf-8") as stream: |
| for row in result["per_sample_metrics"]: |
| stream.write(json.dumps(row, sort_keys=True) + "\n") |
|
|
| held_out = result["summaries"]["test"] |
| overall = result["summaries"]["all"] |
| audit = result["contract_audit"] |
| text = f"""# C12 Sentinel-1 reference-label evaluation |
| |
| This is an evaluator-side construct-validity report. The 500 agent-facing |
| questions and expected answers describe outputs of `{METHOD}`. They do not |
| claim that those outputs equal the Sen1Floods11 hand labels, and the labels are |
| not declared agent inputs. |
| |
| ## Contract audit |
| |
| - Sentinel records: {audit['records']} (100 scenes x A-E) |
| - Declared reference-label paths: {audit['records_with_declared_reference_label']} |
| - Expected answers containing accuracy/IoU/F1/precision/recall: {audit['records_with_accuracy_fields_in_expected_answer']} |
| - Wrong or missing `prediction_method`: {audit['records_with_wrong_or_missing_prediction_method']} |
| - Scenes whose recomputed flood percentage matches the canonical answer: {audit['samples_matching_canonical_prediction_percentage']}/100 |
| |
| ## Held-out test result |
| |
| - Scenes: {held_out['samples']} ({held_out['question_records_represented']} question records) |
| - Macro IoU / F1: {held_out['macro']['IoU']} / {held_out['macro']['F1']} |
| - Macro precision / recall: {held_out['macro']['precision']} / {held_out['macro']['recall']} |
| - Micro IoU / F1: {held_out['micro']['IoU']} / {held_out['micro']['F1']} |
| - Micro precision / recall: {held_out['micro']['precision']} / {held_out['micro']['recall']} |
| |
| ## All-scene diagnostic |
| |
| - Scenes: {overall['samples']} ({overall['question_records_represented']} question records) |
| - Macro IoU / F1: {overall['macro']['IoU']} / {overall['macro']['F1']} |
| - Micro IoU / F1: {overall['micro']['IoU']} / {overall['micro']['F1']} |
| - Scenes with no positive reference pixels (recall undefined): {overall['samples_without_reference_flood_pixels']} |
| |
| ## Interpretation |
| |
| The baseline has relatively high recall and low precision; it is a simple, |
| reproducible flood-candidate baseline, not a validated operational flood map. |
| The held-out metrics quantify its agreement with `LabelHand`, but do not turn |
| the agent-facing targets into ground-truth flood masks. No acceptance threshold |
| was selected after observing these results. |
| """ |
| (output_dir / "README.md").write_text(text, encoding="utf-8") |
|
|
|
|
| def parser() -> argparse.ArgumentParser: |
| result = argparse.ArgumentParser(description=__doc__) |
| root = Path(__file__).resolve().parents[1] |
| result.add_argument("--root", type=Path, default=root) |
| result.add_argument( |
| "--dataset", |
| type=Path, |
| default=Path("data/core/geodisaster_2921_source_with_splits.jsonl"), |
| ) |
| result.add_argument( |
| "--output-dir", |
| type=Path, |
| default=Path("sen1_accuracy_results"), |
| ) |
| return result |
|
|
|
|
| def main() -> None: |
| args = parser().parse_args() |
| root = args.root.resolve() |
| dataset = args.dataset if args.dataset.is_absolute() else root / args.dataset |
| output_dir = args.output_dir if args.output_dir.is_absolute() else root / args.output_dir |
| samples, audit = load_contract(dataset) |
| if audit["records_with_declared_reference_label"]: |
| raise RuntimeError("reference-label leakage detected in declared initial artifacts") |
| if audit["records_with_accuracy_fields_in_expected_answer"]: |
| raise RuntimeError("agent-facing expected answers improperly contain accuracy fields") |
| if audit["records_with_wrong_or_missing_prediction_method"]: |
| raise RuntimeError("Sentinel expected-answer method contract is inconsistent") |
|
|
| rows = [evaluate_sample(root, samples[key]) for key in sorted(samples)] |
| canonical_mismatches = [ |
| row["sample_id"] for row in rows if not row["canonical_prediction_percentage_match"] |
| ] |
| audit["samples_matching_canonical_prediction_percentage"] = len(rows) - len(canonical_mismatches) |
| audit["canonical_prediction_percentage_mismatches"] = canonical_mismatches |
| if canonical_mismatches: |
| raise RuntimeError( |
| "evaluator prediction does not reproduce canonical expected values for: " |
| + ", ".join(canonical_mismatches) |
| ) |
| grouped: dict[str, list[dict[str, Any]]] = defaultdict(list) |
| for row in rows: |
| grouped[str(row["split"])].append(row) |
| if set(grouped) != {"train", "test"}: |
| raise ValueError(f"unexpected sample splits: {sorted(grouped)}") |
| result = { |
| "schema_version": "c12_sen1_reference_label_evaluation_v1", |
| "dataset": str(dataset.relative_to(root)), |
| "dataset_sha256": sha256(dataset), |
| "prediction_method": METHOD, |
| "reference": REFERENCE_NAME, |
| "reference_valid_values": [0, 1], |
| "reference_nodata_value": -1, |
| "contract_audit": audit, |
| "summaries": { |
| "all": summarize(rows), |
| "train": summarize(grouped["train"]), |
| "test": summarize(grouped["test"]), |
| }, |
| "per_sample_metrics": rows, |
| } |
| write_report(output_dir, result) |
| print(json.dumps({"output_dir": str(output_dir), "summaries": result["summaries"]}, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
