From 18c26c857669fe1c49e683a85e73cf805539bfbb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Erick=20Hecht=20L=C3=B3pez?= Date: Mon, 5 Oct 2026 19:29:11 -0300 Subject: [PATCH] feat: publish LAB03 spatial cross-validation --- README.md | 52 +- environment.yml | 4 + .../03_spatial_cross_validation.ipynb | 1283 +++++++++++++++++ .../03a_run_spatial_cv_experiment.py | 452 ++++++ .../03b_summarize_cv_results.py | 260 ++++ labs/lab03_spatial_cross_validation/README.md | 298 ++++ .../results/aggregate_comparison.csv | 4 + .../results/aggregate_metrics.csv | 7 + .../results/experiment_metadata.json | 31 + .../results/fold_results.csv | 31 + .../results/scenario_diagnostics.csv | 4 + .../results/strategy_summary.csv | 7 + .../results/validation_comparison.csv | 4 + src/geoai/validation.py | 380 +++++ tests/test_validation.py | 200 +++ 15 files changed, 3013 insertions(+), 4 deletions(-) create mode 100644 labs/lab03_spatial_cross_validation/03_spatial_cross_validation.ipynb create mode 100644 labs/lab03_spatial_cross_validation/03a_run_spatial_cv_experiment.py create mode 100644 labs/lab03_spatial_cross_validation/03b_summarize_cv_results.py create mode 100644 labs/lab03_spatial_cross_validation/README.md create mode 100644 labs/lab03_spatial_cross_validation/results/aggregate_comparison.csv create mode 100644 labs/lab03_spatial_cross_validation/results/aggregate_metrics.csv create mode 100644 labs/lab03_spatial_cross_validation/results/experiment_metadata.json create mode 100644 labs/lab03_spatial_cross_validation/results/fold_results.csv create mode 100644 labs/lab03_spatial_cross_validation/results/scenario_diagnostics.csv create mode 100644 labs/lab03_spatial_cross_validation/results/strategy_summary.csv create mode 100644 labs/lab03_spatial_cross_validation/results/validation_comparison.csv create mode 100644 src/geoai/validation.py create mode 100644 tests/test_validation.py diff --git a/README.md b/README.md index 1baaee6..e939c1d 100644 --- a/README.md +++ b/README.md @@ -106,6 +106,34 @@ sampling density is not underlying spatial signal --- +### LAB 03 - Spatial Cross-Validation + +[Open the recruiter-facing notebook](labs/lab03_spatial_cross_validation/03_spatial_cross_validation.ipynb) + +**Problem:** conventional random cross-validation can produce optimistic performance estimates when spatially close observations are distributed between training and validation sets. + +The walkthrough demonstrates: + +- Random K-Fold versus Spatial Block Cross-Validation; +- a fixed local KNN baseline so that validation design, rather than model selection, is the experimental variable; +- 5 km spatial blocks as the primary validation scenario; +- 10 km sensitivity analysis; +- 20 km stress testing; +- train-validation spatial-separation diagnostics; +- spatial-group overlap diagnostics; +- RMSE and MAE as primary performance metrics; +- limitations of R² when validation folds contain very low target variance. + +For the primary 5 km scenario: + +- Random pooled RMSE: **3.9676**; +- Spatial Block CV pooled RMSE: **4.2610**; +- relative RMSE optimism: **6.89%**; +- Random median test-to-train separation: **1.11 km**; +- Spatial median test-to-train separation: **2.39 km**; +- mean 5 km spatial-group overlap: **73.6** for Random K-Fold versus **0.0** for Spatial Block CV. + +The result is experiment-specific and is not presented as a universal correction factor or as evidence that one spatial block size is optimal for other datasets. ## Why this matters for GeoAI Spatial errors can silently propagate into features such as: @@ -180,7 +208,21 @@ mining-geospatial-analytics/ | |-- monte_carlo_by_realization.csv | `-- resolution_summary.csv | -|-- src/ +| | +| `-- lab03_spatial_cross_validation/ +| |-- 03_spatial_cross_validation.ipynb +| |-- 03a_run_spatial_cv_experiment.py +| |-- 03b_summarize_cv_results.py +| |-- README.md +| `-- results/ +| |-- aggregate_comparison.csv +| |-- aggregate_metrics.csv +| |-- experiment_metadata.json +| |-- fold_results.csv +| |-- scenario_diagnostics.csv +| |-- strategy_summary.csv +| `-- validation_comparison.csv +||-- src/ | `-- geoai/ | |-- __init__.py | |-- crs.py @@ -288,7 +330,7 @@ Future external datasets will require explicit review of source, license, attrib | --- | --- | --- | | LAB 01 | Geospatial Python Foundations | Complete | | LAB 02 | Spatial Exploratory Data Analysis | Complete | -| LAB 03 | Spatial Cross-Validation | Planned | +| LAB 03 | Spatial Cross-Validation | Complete | | LAB 04 | Geochemical CoDA | Planned | | LAB 05 | Mineral Prospectivity Mapping | Planned | | LAB 06 | Explainable GeoAI | Planned | @@ -297,9 +339,11 @@ Future external datasets will require explicit review of source, license, attrib | LAB 09 | Deep Learning for GeoAI | Planned | | LAB 10 | Graph & Multimodal GeoAI | Planned | -LAB 01 and LAB 02 are completed and validated. +LAB 01, LAB 02, and LAB 03 are completed and validated. + +LAB 03 extends the portfolio from exploratory spatial reasoning into spatial cross-validation, with explicit attention to spatial leakage, train-validation separation, spatial-group overlap, and the limitations of conventional random cross-validation. -LAB 03 will extend the portfolio from exploratory spatial reasoning into spatial cross-validation, with explicit attention to spatial leakage and the limitations of conventional random train/test splits. +LAB 04 will move into geochemical compositional data analysis while preserving the same emphasis on reproducibility, explicit assumptions, and spatially appropriate validation. ## Technical principles diff --git a/environment.yml b/environment.yml index 75993d0..2afae78 100644 --- a/environment.yml +++ b/environment.yml @@ -13,6 +13,10 @@ dependencies: - numpy=2.5.* - pandas=3.0.* + # Machine learning and statistical validation + - scipy=1.18.* + - scikit-learn=1.9.* + # Geospatial vector stack - geopandas-base=1.1.* - shapely=2.1.* diff --git a/labs/lab03_spatial_cross_validation/03_spatial_cross_validation.ipynb b/labs/lab03_spatial_cross_validation/03_spatial_cross_validation.ipynb new file mode 100644 index 0000000..0fd952d --- /dev/null +++ b/labs/lab03_spatial_cross_validation/03_spatial_cross_validation.ipynb @@ -0,0 +1,1283 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0d41c0dc", + "metadata": {}, + "source": [ + "# LAB 03 ? Spatial Cross-Validation\n", + "\n", + "## Random K-Fold versus spatially blocked validation\n", + "\n", + "This laboratory evaluates how validation design changes the apparent\n", + "predictive performance of a spatial model.\n", + "\n", + "The experiment uses only controlled synthetic data. No real exploration,\n", + "assay, grade, deposit, or prospectivity data are used.\n", + "\n", + "### Research question\n", + "\n", + "**How much optimism can conventional random cross-validation introduce when\n", + "training and validation observations remain spatially close?**\n", + "\n", + "The experiment holds the model and data-generating process fixed while\n", + "changing the validation strategy." + ] + }, + { + "cell_type": "markdown", + "id": "5440328a", + "metadata": {}, + "source": [ + "## Experimental design\n", + "\n", + "The synthetic sampling process is inherited from LAB02 and contains:\n", + "\n", + "- 800 observations\n", + "- 500 regional samples\n", + "- 300 campaign samples\n", + "- projected coordinates in EPSG:32719\n", + "- an observed synthetic spatial signal\n", + "- a noise-free synthetic signal retained only as a reference\n", + "\n", + "The predictive baseline is a distance-weighted K-nearest-neighbours\n", + "regressor using only Easting and Northing.\n", + "\n", + "The validation comparison is:\n", + "\n", + "1. reproducible Random K-Fold;\n", + "2. spatial block cross-validation.\n", + "\n", + "Block sizes of 5 km, 10 km, and 20 km are evaluated.\n", + "\n", + "The **5 km design is the primary scenario** because its folds retain broad\n", + "spatial support. The 10 km and 20 km designs are retained as sensitivity\n", + "and stress-test scenarios." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "68e33e95", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-05T00:53:44.299076Z", + "iopub.status.busy": "2026-10-05T00:53:44.298857Z", + "iopub.status.idle": "2026-10-05T00:53:46.257764Z", + "shell.execute_reply": "2026-10-05T00:53:46.256296Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "LAB03_NOTEBOOK_SETUP = PASS\n", + "Primary spatial block: 5 km\n", + "CRS: EPSG:32719\n" + ] + } + ], + "source": [ + "%matplotlib inline\n", + "\n", + "from pathlib import Path\n", + "import json\n", + "import sys\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "REPO_ROOT = Path.cwd()\n", + "SRC_DIR = REPO_ROOT / \"src\"\n", + "\n", + "if str(SRC_DIR) not in sys.path:\n", + " sys.path.insert(0, str(SRC_DIR))\n", + "\n", + "from geoai.spatial import (\n", + " DEFAULT_BOUNDS,\n", + " DEFAULT_CRS,\n", + " generate_synthetic_sampling,\n", + ")\n", + "from geoai.validation import (\n", + " assign_spatial_blocks,\n", + " spatial_group_kfold_indices,\n", + ")\n", + "\n", + "LAB_DIR = REPO_ROOT / \"labs\" / \"lab03_spatial_cross_validation\"\n", + "RESULTS_DIR = LAB_DIR / \"results\"\n", + "\n", + "PRIMARY_BLOCK_M = 5000.0\n", + "SENSITIVITY_BLOCKS_M = (10000.0, 20000.0)\n", + "SEED = 12345\n", + "\n", + "print(\"LAB03_NOTEBOOK_SETUP = PASS\")\n", + "print(\"Primary spatial block:\", f\"{PRIMARY_BLOCK_M / 1000:.0f} km\")\n", + "print(\"CRS:\", DEFAULT_CRS)" + ] + }, + { + "cell_type": "markdown", + "id": "fffbe061", + "metadata": {}, + "source": [ + "## 1. Load the persisted experiment\n", + "\n", + "The numerical experiment was executed independently before this notebook was\n", + "built. The notebook reads the persisted outputs so that presentation and\n", + "scientific interpretation do not silently alter the experiment." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c0401dd9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-05T00:53:46.259812Z", + "iopub.status.busy": "2026-10-05T00:53:46.259546Z", + "iopub.status.idle": "2026-10-05T00:53:46.326308Z", + "shell.execute_reply": "2026-10-05T00:53:46.324588Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PERSISTED_RESULTS = VERIFIED\n", + "Observations: 800\n", + "CV folds: 5\n", + "Model: KNeighborsRegressor\n", + "Neighbors: 15\n" + ] + } + ], + "source": [ + "fold_results = pd.read_csv(RESULTS_DIR / \"fold_results.csv\")\n", + "aggregate_metrics = pd.read_csv(RESULTS_DIR / \"aggregate_metrics.csv\")\n", + "aggregate_comparison = pd.read_csv(\n", + " RESULTS_DIR / \"aggregate_comparison.csv\"\n", + ")\n", + "scenario_diagnostics = pd.read_csv(\n", + " RESULTS_DIR / \"scenario_diagnostics.csv\"\n", + ")\n", + "\n", + "metadata = json.loads(\n", + " (RESULTS_DIR / \"experiment_metadata.json\").read_text(\n", + " encoding=\"utf-8\"\n", + " )\n", + ")\n", + "\n", + "required_sizes = {5000.0, 10000.0, 20000.0}\n", + "\n", + "assert set(aggregate_comparison[\"block_size_m\"]) == required_sizes\n", + "assert metadata[\"n_samples\"] == 800\n", + "assert metadata[\"seed\"] == SEED\n", + "\n", + "print(\"PERSISTED_RESULTS = VERIFIED\")\n", + "print(\"Observations:\", metadata[\"n_samples\"])\n", + "print(\"CV folds:\", metadata[\"n_splits\"])\n", + "print(\"Model:\", metadata[\"model\"])\n", + "print(\"Neighbors:\", metadata[\"n_neighbors\"])" + ] + }, + { + "cell_type": "markdown", + "id": "54027ad8", + "metadata": {}, + "source": [ + "## 2. Reconstruct the controlled spatial dataset\n", + "\n", + "The dataset is regenerated with the recorded seed. `signal` is the modelling\n", + "target. `signal_true` is retained only to understand the synthetic\n", + "data-generating process and is not supplied to the model." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "56b2d2d1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-05T00:53:46.328534Z", + "iopub.status.busy": "2026-10-05T00:53:46.328268Z", + "iopub.status.idle": "2026-10-05T00:53:46.384932Z", + "shell.execute_reply": "2026-10-05T00:53:46.383586Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sample_idsampling_componentsignal_truesignal
0S0001regional10.00000015.480627
1S0002regional10.0000116.262295
2S0003regional10.00000012.893035
3S0004regional10.0000009.663387
4S0005regional10.0061107.958912
\n", + "
" + ], + "text/plain": [ + " sample_id sampling_component signal_true signal\n", + "0 S0001 regional 10.000000 15.480627\n", + "1 S0002 regional 10.000011 6.262295\n", + "2 S0003 regional 10.000000 12.893035\n", + "3 S0004 regional 10.000000 9.663387\n", + "4 S0005 regional 10.006110 7.958912" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "frame = generate_synthetic_sampling(seed=SEED)\n", + "\n", + "x = frame.geometry.x.to_numpy(dtype=float)\n", + "y = frame.geometry.y.to_numpy(dtype=float)\n", + "\n", + "assert len(frame) == metadata[\"n_samples\"]\n", + "\n", + "frame[\n", + " [\n", + " \"sample_id\",\n", + " \"sampling_component\",\n", + " \"signal_true\",\n", + " \"signal\",\n", + " ]\n", + "].head()" + ] + }, + { + "cell_type": "markdown", + "id": "6814dd7c", + "metadata": {}, + "source": [ + "## 3. Primary spatial validation geometry ? 5 km\n", + "\n", + "Each 5 km spatial block is assigned wholly to one validation fold. This\n", + "prevents the same block from appearing simultaneously in training and\n", + "validation.\n", + "\n", + "Spatial blocking reduces direct spatial information sharing; it does not\n", + "prove complete spatial independence." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4f5d8e4b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-05T00:53:46.386932Z", + "iopub.status.busy": "2026-10-05T00:53:46.386704Z", + "iopub.status.idle": "2026-10-05T00:53:46.401569Z", + "shell.execute_reply": "2026-10-05T00:53:46.400232Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Populated 5 km blocks: 224\n", + "Samples per fold: {0: 160, 1: 160, 2: 160, 3: 160, 4: 160}\n" + ] + } + ], + "source": [ + "primary_groups = assign_spatial_blocks(\n", + " x,\n", + " y,\n", + " block_size=PRIMARY_BLOCK_M,\n", + " origin_x=DEFAULT_BOUNDS[0],\n", + " origin_y=DEFAULT_BOUNDS[2],\n", + ")\n", + "\n", + "primary_splits = spatial_group_kfold_indices(\n", + " primary_groups,\n", + " n_splits=metadata[\"n_splits\"],\n", + ")\n", + "\n", + "sample_fold = np.empty(len(frame), dtype=int)\n", + "\n", + "for split in primary_splits:\n", + " sample_fold[split.test_idx] = split.fold\n", + "\n", + "frame = frame.copy()\n", + "frame[\"spatial_fold_5km\"] = sample_fold\n", + "\n", + "print(\"Populated 5 km blocks:\", np.unique(primary_groups).size)\n", + "print(\n", + " \"Samples per fold:\",\n", + " frame.groupby(\"spatial_fold_5km\").size().to_dict(),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f598092c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-05T00:53:46.403816Z", + "iopub.status.busy": "2026-10-05T00:53:46.403539Z", + "iopub.status.idle": "2026-10-05T00:53:46.691321Z", + "shell.execute_reply": "2026-10-05T00:53:46.690246Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 7))\n", + "\n", + "points = ax.scatter(\n", + " frame.geometry.x,\n", + " frame.geometry.y,\n", + " c=frame[\"spatial_fold_5km\"],\n", + " s=20,\n", + ")\n", + "\n", + "ax.set_title(\"LAB03 ? 5 KM SPATIAL CROSS-VALIDATION FOLDS\")\n", + "ax.set_xlabel(\"Easting (m)\")\n", + "ax.set_ylabel(\"Northing (m)\")\n", + "ax.set_aspect(\"equal\")\n", + "\n", + "colorbar = fig.colorbar(points, ax=ax)\n", + "colorbar.set_label(\"Validation fold\")\n", + "colorbar.set_ticks(range(metadata[\"n_splits\"]))\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c96fd5bf", + "metadata": {}, + "source": [ + "## 4. Primary comparison ? Random CV versus 5 km Spatial CV\n", + "\n", + "RMSE and MAE are treated as the primary performance metrics.\n", + "\n", + "R? is reported as a complementary diagnostic because spatial folds may have\n", + "very different target variance. Under low within-fold variance, R? can become\n", + "unstable or negative even when absolute prediction error remains moderate." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "eca532f7", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-05T00:53:46.693895Z", + "iopub.status.busy": "2026-10-05T00:53:46.693640Z", + "iopub.status.idle": "2026-10-05T00:53:46.707952Z", + "shell.execute_reply": "2026-10-05T00:53:46.706562Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
MetricRandom K-FoldSpatial CV ? 5 km
0Pooled RMSE3.9684.261
1Pooled MAE2.8072.962
2Median test-to-train separation (m)1107.7092387.713
\n", + "
" + ], + "text/plain": [ + " Metric Random K-Fold Spatial CV ? 5 km\n", + "0 Pooled RMSE 3.968 4.261\n", + "1 Pooled MAE 2.807 2.962\n", + "2 Median test-to-train separation (m) 1107.709 2387.713" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "primary = aggregate_comparison.loc[\n", + " aggregate_comparison[\"block_size_m\"] == PRIMARY_BLOCK_M\n", + "].iloc[0]\n", + "\n", + "primary_table = pd.DataFrame(\n", + " {\n", + " \"Metric\": [\n", + " \"Pooled RMSE\",\n", + " \"Pooled MAE\",\n", + " \"Median test-to-train separation (m)\",\n", + " ],\n", + " \"Random K-Fold\": [\n", + " primary[\"random_pooled_rmse\"],\n", + " primary[\"random_pooled_mae\"],\n", + " primary[\"random_median_separation_m\"],\n", + " ],\n", + " \"Spatial CV ? 5 km\": [\n", + " primary[\"spatial_pooled_rmse\"],\n", + " primary[\"spatial_pooled_mae\"],\n", + " primary[\"spatial_median_separation_m\"],\n", + " ],\n", + " }\n", + ")\n", + "\n", + "primary_table.round(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5a5ee4e2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-05T00:53:46.710150Z", + "iopub.status.busy": "2026-10-05T00:53:46.709904Z", + "iopub.status.idle": "2026-10-05T00:53:46.715783Z", + "shell.execute_reply": "2026-10-05T00:53:46.714933Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Random pooled RMSE: 3.9676\n", + "Spatial pooled RMSE: 4.2610\n", + "Relative RMSE optimism: 6.89%\n", + "Random median separation: 1.11 km\n", + "Spatial median separation: 2.39 km\n" + ] + } + ], + "source": [ + "print(\n", + " \"Random pooled RMSE:\",\n", + " f\"{primary['random_pooled_rmse']:.4f}\",\n", + ")\n", + "print(\n", + " \"Spatial pooled RMSE:\",\n", + " f\"{primary['spatial_pooled_rmse']:.4f}\",\n", + ")\n", + "print(\n", + " \"Relative RMSE optimism:\",\n", + " f\"{primary['relative_rmse_optimism_pct']:.2f}%\",\n", + ")\n", + "print(\n", + " \"Random median separation:\",\n", + " f\"{primary['random_median_separation_m'] / 1000:.2f} km\",\n", + ")\n", + "print(\n", + " \"Spatial median separation:\",\n", + " f\"{primary['spatial_median_separation_m'] / 1000:.2f} km\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "d48d4db9", + "metadata": {}, + "source": [ + "### Interpretation\n", + "\n", + "In the primary controlled scenario, Random K-Fold evaluates observations that\n", + "remain geographically closer to their training data. Spatial blocking\n", + "increases this separation and produces a more demanding estimate of\n", + "generalization.\n", + "\n", + "The result should be interpreted as evidence for this synthetic experiment\n", + "and this fixed local model, not as a universal correction factor for spatial\n", + "machine learning." + ] + }, + { + "cell_type": "markdown", + "id": "c159ba22", + "metadata": {}, + "source": [ + "## 5. Sensitivity to spatial block size\n", + "\n", + "Larger blocks make validation increasingly spatially restrictive, but they\n", + "also reduce the number of independent spatial units available to distribute\n", + "across folds.\n", + "\n", + "For this reason, stronger performance degradation at larger block sizes\n", + "cannot be interpreted only as ?more leakage removed?; fold support and target\n", + "heterogeneity must also be examined." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "81d2abab", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-05T00:53:46.719284Z", + "iopub.status.busy": "2026-10-05T00:53:46.719023Z", + "iopub.status.idle": "2026-10-05T00:53:46.734289Z", + "shell.execute_reply": "2026-10-05T00:53:46.732793Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
block_size_kmrandom_pooled_rmsespatial_pooled_rmserelative_rmse_optimism_pctrandom_median_separation_mspatial_median_separation_m
05.03.9684.2616.8851107.7092387.713
110.03.9685.08721.9991107.7093192.453
220.03.9685.23224.1671107.7095413.619
\n", + "
" + ], + "text/plain": [ + " block_size_km random_pooled_rmse spatial_pooled_rmse \\\n", + "0 5.0 3.968 4.261 \n", + "1 10.0 3.968 5.087 \n", + "2 20.0 3.968 5.232 \n", + "\n", + " relative_rmse_optimism_pct random_median_separation_m \\\n", + "0 6.885 1107.709 \n", + "1 21.999 1107.709 \n", + "2 24.167 1107.709 \n", + "\n", + " spatial_median_separation_m \n", + "0 2387.713 \n", + "1 3192.453 \n", + "2 5413.619 " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "comparison_display = aggregate_comparison[\n", + " [\n", + " \"block_size_m\",\n", + " \"random_pooled_rmse\",\n", + " \"spatial_pooled_rmse\",\n", + " \"relative_rmse_optimism_pct\",\n", + " \"random_median_separation_m\",\n", + " \"spatial_median_separation_m\",\n", + " ]\n", + "].copy()\n", + "\n", + "comparison_display[\"block_size_km\"] = (\n", + " comparison_display[\"block_size_m\"] / 1000\n", + ")\n", + "\n", + "comparison_display[\n", + " [\n", + " \"block_size_km\",\n", + " \"random_pooled_rmse\",\n", + " \"spatial_pooled_rmse\",\n", + " \"relative_rmse_optimism_pct\",\n", + " \"random_median_separation_m\",\n", + " \"spatial_median_separation_m\",\n", + " ]\n", + "].round(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f5092683", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-05T00:53:46.737299Z", + "iopub.status.busy": "2026-10-05T00:53:46.737057Z", + "iopub.status.idle": "2026-10-05T00:53:46.892862Z", + "shell.execute_reply": "2026-10-05T00:53:46.891456Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_data = aggregate_comparison.copy()\n", + "labels = [\n", + " f\"{value / 1000:.0f} km\"\n", + " for value in plot_data[\"block_size_m\"]\n", + "]\n", + "\n", + "positions = np.arange(len(plot_data))\n", + "width = 0.36\n", + "\n", + "fig, ax = plt.subplots(figsize=(8, 5))\n", + "\n", + "ax.bar(\n", + " positions - width / 2,\n", + " plot_data[\"random_pooled_rmse\"],\n", + " width,\n", + " label=\"Random K-Fold\",\n", + ")\n", + "ax.bar(\n", + " positions + width / 2,\n", + " plot_data[\"spatial_pooled_rmse\"],\n", + " width,\n", + " label=\"Spatial Block CV\",\n", + ")\n", + "\n", + "ax.set_title(\"LAB03 ? POOLED RMSE BY VALIDATION DESIGN\")\n", + "ax.set_xlabel(\"Spatial block size\")\n", + "ax.set_ylabel(\"Pooled RMSE\")\n", + "ax.set_xticks(positions, labels)\n", + "ax.legend()\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a778119e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-05T00:53:46.894887Z", + "iopub.status.busy": "2026-10-05T00:53:46.894698Z", + "iopub.status.idle": "2026-10-05T00:53:47.030920Z", + "shell.execute_reply": "2026-10-05T00:53:47.029580Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 5))\n", + "\n", + "ax.plot(\n", + " plot_data[\"block_size_m\"] / 1000,\n", + " plot_data[\"random_median_separation_m\"] / 1000,\n", + " marker=\"o\",\n", + " label=\"Random K-Fold\",\n", + ")\n", + "ax.plot(\n", + " plot_data[\"block_size_m\"] / 1000,\n", + " plot_data[\"spatial_median_separation_m\"] / 1000,\n", + " marker=\"o\",\n", + " label=\"Spatial Block CV\",\n", + ")\n", + "\n", + "ax.set_title(\"LAB03 ? MEDIAN TEST-TO-TRAIN SPATIAL SEPARATION\")\n", + "ax.set_xlabel(\"Spatial block size (km)\")\n", + "ax.set_ylabel(\"Median nearest train distance (km)\")\n", + "ax.legend()\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "142ffd5a", + "metadata": {}, + "source": [ + "## 6. Fold stability\n", + "\n", + "A validation strategy should not be judged only from its mean score. Fold\n", + "dispersion helps identify whether the apparent performance estimate is being\n", + "driven by particular spatial regions." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "dfd8537a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-05T00:53:47.032909Z", + "iopub.status.busy": "2026-10-05T00:53:47.032707Z", + "iopub.status.idle": "2026-10-05T00:53:47.051531Z", + "shell.execute_reply": "2026-10-05T00:53:47.049919Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
strategyrandom_kfoldspatial_block
fold
04.0845.204
13.8244.019
23.9593.741
34.2913.639
43.6504.507
\n", + "
" + ], + "text/plain": [ + "strategy random_kfold spatial_block\n", + "fold \n", + "0 4.084 5.204\n", + "1 3.824 4.019\n", + "2 3.959 3.741\n", + "3 4.291 3.639\n", + "4 3.650 4.507" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "primary_folds = fold_results[\n", + " fold_results[\"block_size_m\"] == PRIMARY_BLOCK_M\n", + "].copy()\n", + "\n", + "fold_rmse = primary_folds.pivot(\n", + " index=\"fold\",\n", + " columns=\"strategy\",\n", + " values=\"rmse\",\n", + ")\n", + "\n", + "fold_rmse.round(3)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "290b9e9f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-05T00:53:47.054157Z", + "iopub.status.busy": "2026-10-05T00:53:47.053912Z", + "iopub.status.idle": "2026-10-05T00:53:47.209937Z", + "shell.execute_reply": "2026-10-05T00:53:47.207140Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 5))\n", + "\n", + "positions = np.arange(len(fold_rmse))\n", + "width = 0.36\n", + "\n", + "ax.bar(\n", + " positions - width / 2,\n", + " fold_rmse[\"random_kfold\"],\n", + " width,\n", + " label=\"Random K-Fold\",\n", + ")\n", + "ax.bar(\n", + " positions + width / 2,\n", + " fold_rmse[\"spatial_block\"],\n", + " width,\n", + " label=\"Spatial Block CV ? 5 km\",\n", + ")\n", + "\n", + "ax.set_title(\"LAB03 ? FOLD-LEVEL RMSE, PRIMARY 5 KM DESIGN\")\n", + "ax.set_xlabel(\"Fold\")\n", + "ax.set_ylabel(\"RMSE\")\n", + "ax.set_xticks(positions, fold_rmse.index)\n", + "ax.legend()\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "fee9d8c7", + "metadata": {}, + "source": [ + "## 7. Why 5 km is the primary scenario\n", + "\n", + "The selection is based on validation support, not on choosing the result that\n", + "best matches the hypothesis.\n", + "\n", + "At 5 km, all five folds retain many populated blocks and balanced sample\n", + "counts. At 10 km and 20 km, one or more folds can be dominated by a single\n", + "large block with almost no variation in the underlying synthetic signal.\n", + "\n", + "Those coarser designs remain informative stress tests, but they provide less\n", + "stable fold-level inference." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "26e82689", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-05T00:53:47.212507Z", + "iopub.status.busy": "2026-10-05T00:53:47.212301Z", + "iopub.status.idle": "2026-10-05T00:53:47.222924Z", + "shell.execute_reply": "2026-10-05T00:53:47.221561Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
block_size_kmpopulated_blocksmin_test_blocksmax_test_blocksmedian_test_blocksmin_test_nmax_test_nmin_signal_true_sdmax_signal_true_sd
05.0224374846.01601605.79511.509
110.06411816.01551780.00014.229
220.016154.01292390.00014.997
\n", + "
" + ], + "text/plain": [ + " block_size_km populated_blocks min_test_blocks max_test_blocks \\\n", + "0 5.0 224 37 48 \n", + "1 10.0 64 1 18 \n", + "2 20.0 16 1 5 \n", + "\n", + " median_test_blocks min_test_n max_test_n min_signal_true_sd \\\n", + "0 46.0 160 160 5.795 \n", + "1 16.0 155 178 0.000 \n", + "2 4.0 129 239 0.000 \n", + "\n", + " max_signal_true_sd \n", + "0 11.509 \n", + "1 14.229 \n", + "2 14.997 " + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scenario_diagnostics.assign(\n", + " block_size_km=scenario_diagnostics[\"block_size_m\"] / 1000\n", + ")[\n", + " [\n", + " \"block_size_km\",\n", + " \"populated_blocks\",\n", + " \"min_test_blocks\",\n", + " \"max_test_blocks\",\n", + " \"median_test_blocks\",\n", + " \"min_test_n\",\n", + " \"max_test_n\",\n", + " \"min_signal_true_sd\",\n", + " \"max_signal_true_sd\",\n", + " ]\n", + "].round(3)" + ] + }, + { + "cell_type": "markdown", + "id": "c06721ae", + "metadata": {}, + "source": [ + "## 8. Methodological limitations\n", + "\n", + "This laboratory intentionally isolates one methodological issue.\n", + "\n", + "The conclusions are bounded by the following conditions:\n", + "\n", + "- the data are synthetic;\n", + "- the target is a controlled smooth spatial signal plus noise;\n", + "- the model is a fixed KNN baseline;\n", + "- coordinates are the only predictive features;\n", + "- regular grid blocking is used;\n", + "- no spatial buffer is applied between train and validation samples;\n", + "- only one realization of the primary predictive experiment is presented;\n", + "- the experiment does not estimate mineral prospectivity.\n", + "\n", + "More advanced spatial validation designs may include buffers, leave-location-\n", + "out schemes, geological-domain grouping, repeated spatial partitions, or\n", + "nested spatial cross-validation." + ] + }, + { + "cell_type": "markdown", + "id": "a92b6b7c", + "metadata": {}, + "source": [ + "## 9. Conclusion\n", + "\n", + "LAB03 demonstrates why validation design is part of the scientific model\n", + "rather than merely an implementation detail.\n", + "\n", + "For the primary 5 km scenario, spatial blocking eliminates direct block\n", + "overlap between training and validation, increases geographic separation,\n", + "and produces a higher pooled prediction error than Random K-Fold.\n", + "\n", + "The 10 km and 20 km experiments show that increasingly coarse spatial\n", + "blocking can produce an even more demanding test, but also reduce effective\n", + "spatial support and destabilize fold-level metrics such as R?.\n", + "\n", + "Therefore, model performance in spatial machine learning should always be\n", + "interpreted together with the geometry and support of the validation design." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "556a30c1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-10-05T00:53:47.225046Z", + "iopub.status.busy": "2026-10-05T00:53:47.224863Z", + "iopub.status.idle": "2026-10-05T00:53:47.232687Z", + "shell.execute_reply": "2026-10-05T00:53:47.230881Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PRIMARY_SCENARIO = 5 km\n", + "RMSE optimism relative to Spatial CV: 6.89%\n", + "Spatial fold block overlap: 0\n", + "LAB03_NOTEBOOK_VALIDATION = PASS\n" + ] + } + ], + "source": [ + "primary_diag = scenario_diagnostics.loc[\n", + " scenario_diagnostics[\"block_size_m\"] == PRIMARY_BLOCK_M\n", + "].iloc[0]\n", + "\n", + "assert primary_diag[\"min_test_blocks\"] >= 30\n", + "assert primary_diag[\"min_test_n\"] == primary_diag[\"max_test_n\"] == 160\n", + "\n", + "spatial_primary = aggregate_metrics[\n", + " (aggregate_metrics[\"block_size_m\"] == PRIMARY_BLOCK_M)\n", + " & (aggregate_metrics[\"strategy\"] == \"spatial_block\")\n", + "].iloc[0]\n", + "\n", + "assert spatial_primary[\"mean_group_overlap\"] == 0.0\n", + "\n", + "print(\"PRIMARY_SCENARIO = 5 km\")\n", + "print(\n", + " \"RMSE optimism relative to Spatial CV:\",\n", + " f\"{primary['relative_rmse_optimism_pct']:.2f}%\",\n", + ")\n", + "print(\n", + " \"Spatial fold block overlap:\",\n", + " int(spatial_primary[\"mean_group_overlap\"]),\n", + ")\n", + "print(\"LAB03_NOTEBOOK_VALIDATION = PASS\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/labs/lab03_spatial_cross_validation/03a_run_spatial_cv_experiment.py b/labs/lab03_spatial_cross_validation/03a_run_spatial_cv_experiment.py new file mode 100644 index 0000000..2674427 --- /dev/null +++ b/labs/lab03_spatial_cross_validation/03a_run_spatial_cv_experiment.py @@ -0,0 +1,452 @@ +from __future__ import annotations + +import json +from pathlib import Path + +import numpy as np +import pandas as pd +from sklearn.metrics import ( + mean_absolute_error, + mean_squared_error, + r2_score, +) +from sklearn.neighbors import KNeighborsRegressor + +from geoai.spatial import ( + DEFAULT_BOUNDS, + DEFAULT_CRS, + generate_synthetic_sampling, +) +from geoai.validation import ( + FoldSplit, + assign_spatial_blocks, + random_kfold_indices, + spatial_group_kfold_indices, + summarize_fold_geometry, +) + + +SEED = 12345 +N_SPLITS = 5 +N_NEIGHBORS = 15 +BLOCK_SIZES_M = (5000.0, 10000.0, 20000.0) + +LAB_DIR = Path(__file__).resolve().parent +RESULTS_DIR = LAB_DIR / "results" + + +def build_features( + frame, +) -> tuple[np.ndarray, np.ndarray, np.ndarray]: + """Extract coordinate features and observed/reference targets.""" + x = frame.geometry.x.to_numpy(dtype=float) + y = frame.geometry.y.to_numpy(dtype=float) + + features = np.column_stack( + [x, y] + ) + + target = frame["signal"].to_numpy( + dtype=float + ) + + target_true = frame["signal_true"].to_numpy( + dtype=float + ) + + return features, target, target_true + + +def make_model() -> KNeighborsRegressor: + """ + Return the fixed local baseline used for every validation strategy. + + The model is intentionally simple. LAB03 isolates validation design, + rather than performing model selection. + """ + return KNeighborsRegressor( + n_neighbors=N_NEIGHBORS, + weights="distance", + metric="euclidean", + ) + + +def evaluate_splits( + *, + features: np.ndarray, + target: np.ndarray, + splits: tuple[FoldSplit, ...], + strategy: str, + block_size_m: float, + x: np.ndarray, + y: np.ndarray, + groups: np.ndarray, +) -> pd.DataFrame: + """Evaluate one fixed model under a supplied CV design.""" + geometry_rows = { + int(row["fold"]): row + for row in summarize_fold_geometry( + x, + y, + splits, + groups=groups, + ) + } + + rows: list[dict[str, float | int | str]] = [] + + for split in splits: + model = make_model() + + model.fit( + features[split.train_idx], + target[split.train_idx], + ) + + prediction = model.predict( + features[split.test_idx] + ) + + rmse = float( + np.sqrt( + mean_squared_error( + target[split.test_idx], + prediction, + ) + ) + ) + + mae = float( + mean_absolute_error( + target[split.test_idx], + prediction, + ) + ) + + r2 = float( + r2_score( + target[split.test_idx], + prediction, + ) + ) + + geometry = geometry_rows[int(split.fold)] + + rows.append( + { + "strategy": strategy, + "block_size_m": float(block_size_m), + "fold": int(split.fold), + "train_n": int(split.train_idx.size), + "test_n": int(split.test_idx.size), + "rmse": rmse, + "mae": mae, + "r2": r2, + "min_test_to_train_distance_m": float( + geometry["min_test_to_train_distance"] + ), + "median_test_to_train_distance_m": float( + geometry["median_test_to_train_distance"] + ), + "mean_test_to_train_distance_m": float( + geometry["mean_test_to_train_distance"] + ), + "group_overlap": int( + geometry["group_overlap"] + ), + } + ) + + return pd.DataFrame(rows) + + +def summarize_results( + fold_results: pd.DataFrame, +) -> pd.DataFrame: + """Aggregate fold-level performance by validation strategy.""" + summary = ( + fold_results + .groupby( + ["block_size_m", "strategy"], + as_index=False, + ) + .agg( + rmse_mean=("rmse", "mean"), + rmse_sd=("rmse", "std"), + mae_mean=("mae", "mean"), + mae_sd=("mae", "std"), + r2_mean=("r2", "mean"), + r2_sd=("r2", "std"), + median_separation_m=( + "median_test_to_train_distance_m", + "median", + ), + mean_group_overlap=( + "group_overlap", + "mean", + ), + ) + ) + + return summary + + +def build_comparison( + summary: pd.DataFrame, +) -> pd.DataFrame: + """ + Compare random and spatial validation at each block resolution. + + Positive RMSE optimism means random CV reports a smaller error than + spatial CV. + """ + random_rows = ( + summary[ + summary["strategy"] == "random_kfold" + ] + .set_index("block_size_m") + ) + + spatial_rows = ( + summary[ + summary["strategy"] == "spatial_block" + ] + .set_index("block_size_m") + ) + + rows: list[dict[str, float]] = [] + + for block_size in BLOCK_SIZES_M: + random_row = random_rows.loc[block_size] + spatial_row = spatial_rows.loc[block_size] + + random_rmse = float( + random_row["rmse_mean"] + ) + spatial_rmse = float( + spatial_row["rmse_mean"] + ) + + random_mae = float( + random_row["mae_mean"] + ) + spatial_mae = float( + spatial_row["mae_mean"] + ) + + random_r2 = float( + random_row["r2_mean"] + ) + spatial_r2 = float( + spatial_row["r2_mean"] + ) + + relative_rmse_optimism_pct = ( + np.nan + if spatial_rmse == 0 + else + 100.0 + * (spatial_rmse - random_rmse) + / spatial_rmse + ) + + rows.append( + { + "block_size_m": float(block_size), + "random_rmse": random_rmse, + "spatial_rmse": spatial_rmse, + "rmse_gap_spatial_minus_random": ( + spatial_rmse - random_rmse + ), + "relative_rmse_optimism_pct": float( + relative_rmse_optimism_pct + ), + "random_mae": random_mae, + "spatial_mae": spatial_mae, + "mae_gap_spatial_minus_random": ( + spatial_mae - random_mae + ), + "random_r2": random_r2, + "spatial_r2": spatial_r2, + "r2_gap_random_minus_spatial": ( + random_r2 - spatial_r2 + ), + "random_median_separation_m": float( + random_row[ + "median_separation_m" + ] + ), + "spatial_median_separation_m": float( + spatial_row[ + "median_separation_m" + ] + ), + } + ) + + return pd.DataFrame(rows) + + +def run_experiment() -> None: + """Run the controlled LAB03 validation experiment.""" + RESULTS_DIR.mkdir( + parents=True, + exist_ok=True, + ) + + frame = generate_synthetic_sampling( + seed=SEED + ) + + features, target, target_true = ( + build_features(frame) + ) + + x = features[:, 0] + y = features[:, 1] + + random_splits = random_kfold_indices( + n_samples=len(frame), + n_splits=N_SPLITS, + random_state=SEED, + ) + + result_frames: list[pd.DataFrame] = [] + + for block_size in BLOCK_SIZES_M: + groups = assign_spatial_blocks( + x, + y, + block_size=block_size, + origin_x=DEFAULT_BOUNDS[0], + origin_y=DEFAULT_BOUNDS[2], + ) + + spatial_splits = ( + spatial_group_kfold_indices( + groups, + n_splits=N_SPLITS, + ) + ) + + random_result = evaluate_splits( + features=features, + target=target, + splits=random_splits, + strategy="random_kfold", + block_size_m=block_size, + x=x, + y=y, + groups=groups, + ) + + spatial_result = evaluate_splits( + features=features, + target=target, + splits=spatial_splits, + strategy="spatial_block", + block_size_m=block_size, + x=x, + y=y, + groups=groups, + ) + + result_frames.extend( + [ + random_result, + spatial_result, + ] + ) + + fold_results = pd.concat( + result_frames, + ignore_index=True, + ) + + summary = summarize_results( + fold_results + ) + + comparison = build_comparison( + summary + ) + + fold_results.to_csv( + RESULTS_DIR / "fold_results.csv", + index=False, + ) + + summary.to_csv( + RESULTS_DIR / "strategy_summary.csv", + index=False, + ) + + comparison.to_csv( + RESULTS_DIR / "validation_comparison.csv", + index=False, + ) + + metadata = { + "seed": SEED, + "n_samples": int(len(frame)), + "n_regional": int( + (frame["sampling_component"] == "regional") + .sum() + ), + "n_campaign": int( + (frame["sampling_component"] == "campaign") + .sum() + ), + "crs": DEFAULT_CRS, + "bounds": list(DEFAULT_BOUNDS), + "target": "signal", + "reference_target": "signal_true", + "signal_true_min": float( + target_true.min() + ), + "signal_true_max": float( + target_true.max() + ), + "n_splits": N_SPLITS, + "model": "KNeighborsRegressor", + "n_neighbors": N_NEIGHBORS, + "weights": "distance", + "features": [ + "easting", + "northing", + ], + "block_sizes_m": list( + BLOCK_SIZES_M + ), + "interpretation_rule": ( + "Positive RMSE gap (spatial minus random) indicates " + "that random CV reports a more optimistic error estimate." + ), + } + + ( + RESULTS_DIR + / "experiment_metadata.json" + ).write_text( + json.dumps( + metadata, + indent=2, + sort_keys=True, + ) + + "\n", + encoding="utf-8", + newline=chr(10), + ) + + print("LAB03_EXPERIMENT = PASS") + print() + print("VALIDATION COMPARISON") + print( + comparison.to_string( + index=False + ) + ) + + +if __name__ == "__main__": + run_experiment() diff --git a/labs/lab03_spatial_cross_validation/03b_summarize_cv_results.py b/labs/lab03_spatial_cross_validation/03b_summarize_cv_results.py new file mode 100644 index 0000000..96f2e40 --- /dev/null +++ b/labs/lab03_spatial_cross_validation/03b_summarize_cv_results.py @@ -0,0 +1,260 @@ +from __future__ import annotations + +from pathlib import Path + +import numpy as np +import pandas as pd + +from geoai.spatial import ( + DEFAULT_BOUNDS, + generate_synthetic_sampling, +) +from geoai.validation import ( + assign_spatial_blocks, + spatial_group_kfold_indices, +) + + +LAB_DIR = Path(__file__).resolve().parent +RESULTS_DIR = LAB_DIR / "results" + +SEED = 12345 +N_SPLITS = 5 +BLOCK_SIZES_M = (5000.0, 10000.0, 20000.0) + + +def aggregate_fold_metrics( + fold_results: pd.DataFrame, +) -> pd.DataFrame: + rows = [] + + for (block_size, strategy), group in fold_results.groupby( + ["block_size_m", "strategy"], + sort=True, + ): + n = group["test_n"].to_numpy(dtype=float) + rmse = group["rmse"].to_numpy(dtype=float) + mae = group["mae"].to_numpy(dtype=float) + + total_n = float(n.sum()) + + pooled_rmse = float( + np.sqrt( + np.sum(n * rmse**2) + / total_n + ) + ) + + pooled_mae = float( + np.sum(n * mae) + / total_n + ) + + rows.append( + { + "block_size_m": float(block_size), + "strategy": strategy, + "test_n_total": int(total_n), + "pooled_rmse": pooled_rmse, + "pooled_mae": pooled_mae, + "fold_r2_mean": float( + group["r2"].mean() + ), + "fold_r2_sd": float( + group["r2"].std(ddof=1) + ), + "fold_rmse_sd": float( + group["rmse"].std(ddof=1) + ), + "median_separation_m": float( + group[ + "median_test_to_train_distance_m" + ].median() + ), + "mean_group_overlap": float( + group["group_overlap"].mean() + ), + } + ) + + return pd.DataFrame(rows) + + +def build_comparison( + aggregate: pd.DataFrame, +) -> pd.DataFrame: + rows = [] + + for block_size in BLOCK_SIZES_M: + subset = aggregate[ + aggregate["block_size_m"] == block_size + ] + + random_row = subset[ + subset["strategy"] == "random_kfold" + ].iloc[0] + + spatial_row = subset[ + subset["strategy"] == "spatial_block" + ].iloc[0] + + random_rmse = float( + random_row["pooled_rmse"] + ) + spatial_rmse = float( + spatial_row["pooled_rmse"] + ) + + rows.append( + { + "block_size_m": block_size, + "random_pooled_rmse": random_rmse, + "spatial_pooled_rmse": spatial_rmse, + "rmse_gap_spatial_minus_random": ( + spatial_rmse - random_rmse + ), + "relative_rmse_optimism_pct": ( + 100.0 + * (spatial_rmse - random_rmse) + / spatial_rmse + ), + "random_pooled_mae": float( + random_row["pooled_mae"] + ), + "spatial_pooled_mae": float( + spatial_row["pooled_mae"] + ), + "random_median_separation_m": float( + random_row["median_separation_m"] + ), + "spatial_median_separation_m": float( + spatial_row["median_separation_m"] + ), + } + ) + + return pd.DataFrame(rows) + + +def build_scenario_diagnostics() -> pd.DataFrame: + frame = generate_synthetic_sampling( + seed=SEED + ) + + x = frame.geometry.x.to_numpy(dtype=float) + y = frame.geometry.y.to_numpy(dtype=float) + + target_true = frame[ + "signal_true" + ].to_numpy(dtype=float) + + rows = [] + + for block_size in BLOCK_SIZES_M: + groups = assign_spatial_blocks( + x, + y, + block_size=block_size, + origin_x=DEFAULT_BOUNDS[0], + origin_y=DEFAULT_BOUNDS[2], + ) + + splits = spatial_group_kfold_indices( + groups, + n_splits=N_SPLITS, + ) + + block_counts = [] + test_sizes = [] + true_sds = [] + + for split in splits: + block_counts.append( + int( + np.unique( + groups[split.test_idx] + ).size + ) + ) + + test_sizes.append( + int(split.test_idx.size) + ) + + true_sds.append( + float( + np.std( + target_true[split.test_idx], + ddof=1, + ) + ) + ) + + rows.append( + { + "block_size_m": block_size, + "populated_blocks": int( + np.unique(groups).size + ), + "min_test_blocks": min(block_counts), + "max_test_blocks": max(block_counts), + "median_test_blocks": float( + np.median(block_counts) + ), + "min_test_n": min(test_sizes), + "max_test_n": max(test_sizes), + "min_signal_true_sd": min(true_sds), + "max_signal_true_sd": max(true_sds), + } + ) + + return pd.DataFrame(rows) + + +def main() -> None: + fold_results = pd.read_csv( + RESULTS_DIR / "fold_results.csv" + ) + + aggregate = aggregate_fold_metrics( + fold_results + ) + + comparison = build_comparison( + aggregate + ) + + diagnostics = build_scenario_diagnostics() + + aggregate.to_csv( + RESULTS_DIR / "aggregate_metrics.csv", + index=False, + ) + + comparison.to_csv( + RESULTS_DIR / "aggregate_comparison.csv", + index=False, + ) + + diagnostics.to_csv( + RESULTS_DIR / "scenario_diagnostics.csv", + index=False, + ) + + print("AGGREGATE METRICS") + print(aggregate.to_string(index=False)) + + print() + print("AGGREGATE COMPARISON") + print(comparison.to_string(index=False)) + + print() + print("SCENARIO DIAGNOSTICS") + print(diagnostics.to_string(index=False)) + + print() + print("LAB03_AGGREGATION = PASS") + + +if __name__ == "__main__": + main() diff --git a/labs/lab03_spatial_cross_validation/README.md b/labs/lab03_spatial_cross_validation/README.md new file mode 100644 index 0000000..795e0c2 --- /dev/null +++ b/labs/lab03_spatial_cross_validation/README.md @@ -0,0 +1,298 @@ +# LAB03 — Spatial Cross-Validation + +## Research question + +How much optimism can conventional random cross-validation introduce when training and validation observations remain spatially close? + +## Objective + +This laboratory evaluates how the estimated predictive error changes when a spatially autocorrelated synthetic dataset is validated using two different cross-validation strategies: + +- conventional Random K-Fold cross-validation; +- Spatial Block Cross-Validation. + +The experiment intentionally keeps the dataset, features, target, model, and model hyperparameters fixed. The purpose is not to maximize predictive performance, but to isolate the effect of the validation design. + +## Hypothesis + +When nearby observations share spatial structure, conventional random cross-validation may place geographically close samples in both training and validation sets. + +For a local prediction model, this can produce a more optimistic estimate of out-of-sample error than a validation strategy that enforces stronger spatial separation between training and validation observations. + +This laboratory tests that hypothesis under a controlled synthetic setting. It does not assume that the magnitude of the effect observed here generalizes to other datasets, models, spatial processes, or block definitions. + +## Dataset + +LAB03 reuses the synthetic spatial sampling generator developed in the project: + +`generate_synthetic_sampling(seed=12345)` + +Source: + +`src/geoai/spatial.py` + +The dataset contains 800 observations: + +- 500 regional samples; +- 300 campaign samples. + +Coordinate reference system: + +`EPSG:32719` + +Approximate spatial extent: + +- Easting: 350000–430000 m; +- Northing: 7100000–7180000 m. + +### Prediction target + +The observed prediction target is: + +`signal` + +The synthetic latent field: + +`signal_true` + +is retained only as a diagnostic reference and is not supplied to the predictive model. + +### Model features + +The model uses only: + +- `Easting`; +- `Northing`. + +This simple feature definition is deliberate. LAB03 studies validation design rather than feature engineering. + +## Fixed predictive model + +The experiment uses a fixed `KNeighborsRegressor` configuration: + +- `n_neighbors = 15`; +- `weights = "distance"`; +- `metric = "euclidean"`. + +KNN was selected as a deliberately local baseline because its predictions depend strongly on nearby observations. + +No hyperparameter tuning or model selection is performed inside this laboratory. + +## Validation strategies + +### Random K-Fold + +Configuration: + +- 5 folds; +- random seed: `12345`. + +Random K-Fold does not explicitly enforce spatial separation between training and validation observations. + +### Spatial Block Cross-Validation + +Three spatial block sizes are evaluated: + +- 5 km; +- 10 km; +- 20 km. + +Entire spatial blocks are assigned to folds, so observations belonging to the same block are not split between training and validation within a spatial CV scenario. + +## Primary scenario: 5 km spatial blocks + +The 5 km configuration is the primary inferential scenario. + +It provides a useful balance between increased train-validation spatial separation and sufficient spatial support within each validation fold. + +Diagnostics showed: + +- 224 populated spatial blocks; +- approximately 37–48 validation blocks per fold; +- exactly 160 validation observations per fold; +- adequate variation of the latent synthetic signal across folds; +- positive spatial-fold R² values. + +For these reasons, the 5 km result is used for the principal comparison with Random K-Fold. + +## Aggregate results + +| Validation design | Pooled RMSE | Pooled MAE | Median test-to-train separation | +| --- | ---: | ---: | ---: | +| Random K-Fold | 3.9676 | 2.8067 | 1.11 km | +| Spatial Block CV — 5 km | 4.2610 | 2.9618 | 2.39 km | + +For the primary 5 km scenario: + +- absolute RMSE gap: `0.2934`; +- relative RMSE optimism: `6.89%`; +- mean 5 km group overlap under Random K-Fold: `73.6`; +- mean 5 km group overlap under Spatial Block CV: `0.0`. + +The term relative RMSE optimism describes the difference observed in this controlled experiment between the lower Random K-Fold error estimate and the corresponding spatial validation error estimate. + +It must not be interpreted as a universal correction factor. + +## Sensitivity analysis + +Larger blocks increase spatial separation, but they also reduce the number of independent spatial groups available for constructing balanced folds. + +| Scenario | Random pooled RMSE | Spatial pooled RMSE | Relative RMSE optimism | Spatial median separation | +| --- | ---: | ---: | ---: | ---: | +| 5 km — primary | 3.9676 | 4.2610 | 6.89% | 2.39 km | +| 10 km — sensitivity | 3.9676 | 5.0866 | 22.00% | 3.19 km | +| 20 km — stress test | 3.9676 | 5.2320 | 24.17% | 5.41 km | + +### 10 km blocks + +The 10 km scenario contains 64 populated blocks. + +Some validation folds have limited spatial support, including a fold with only one validation block and very low within-fold variation in the latent synthetic signal. + +Consequently, this configuration is treated as a sensitivity analysis rather than the primary estimate. + +### 20 km blocks + +The 20 km configuration contains only 16 populated blocks. + +At this scale, some folds are effectively dominated by very few spatial regions and validation sample sizes become substantially less balanced. + +The 20 km scenario therefore acts as a stress test of stronger spatial separation rather than as the principal validation design. + +## Interpretation of R² + +RMSE and MAE are the primary evaluation metrics in LAB03. + +R² is retained as a complementary diagnostic. + +For spatial folds with very low within-fold target variance, R² can become unstable or negative even when absolute prediction errors remain interpretable. + +A negative spatial-fold R² should therefore not automatically be interpreted as evidence that spatial validation itself has failed. + +Instead, it must be assessed together with: + +- validation-fold sample size; +- target variance; +- number of spatial groups; +- train-validation separation; +- RMSE; +- MAE. + +This is one reason why the 5 km scenario is preferred for the primary comparison. + +## Scientific interpretation + +In this controlled synthetic experiment with a fixed local KNN model, Random K-Fold produced a more optimistic estimate of predictive error than Spatial Block Cross-Validation. + +Increasing spatial separation between training and validation observations increased the estimated prediction error. + +However, larger spatial blocks also reduced the spatial support available within individual folds and increased metric instability. + +The result therefore does not imply that: + +- Random K-Fold always overestimates performance by 6.89%; +- 5 km is an optimal spatial block size for other datasets; +- Spatial Block CV is universally superior to every other validation strategy; +- the 10 km and 20 km differences represent unbiased estimates of real-world deployment error. + +Instead, LAB03 demonstrates that validation geometry can materially affect estimated model performance when observations and predictions are spatially structured. + +## Limitations + +This laboratory has several intentional limitations. + +1. The dataset is synthetic. +2. Only one synthetic realization and fixed random seed are used. +3. The predictive model is a single local KNN baseline. +4. Only coordinate features are supplied to the model. +5. Spatial block size is evaluated at three predefined scales. +6. Larger block sizes reduce the number of populated spatial groups and can produce unstable folds. +7. The experiment does not reproduce the geological, geochemical, geophysical, sampling, censoring, and measurement complexities of a real mineral exploration program. +8. The observed error differences are experiment-specific and must not be generalized as universal spatial-CV correction factors. + +These limitations are deliberate because the objective is methodological isolation rather than production-grade mineral prospectivity modelling. + +## Reproducibility + +The experiment uses deterministic seeds where randomness is involved. + +Core implementation: + +`src/geoai/validation.py` + +Validation tests: + +`tests/test_validation.py` + +LAB03 workflow: + +`labs/lab03_spatial_cross_validation/03a_run_spatial_cv_experiment.py` + +`labs/lab03_spatial_cross_validation/03b_summarize_cv_results.py` + +`labs/lab03_spatial_cross_validation/03c_build_notebook.py` + +`labs/lab03_spatial_cross_validation/03d_execute_notebook.py` + +Executed notebook: + +`labs/lab03_spatial_cross_validation/03_spatial_cross_validation.ipynb` + +### Persisted results + +The laboratory persists its analytical outputs under: + +`labs/lab03_spatial_cross_validation/results/` + +Generated files include: + +- `experiment_metadata.json`; +- `fold_results.csv`; +- `strategy_summary.csv`; +- `validation_comparison.csv`; +- `aggregate_metrics.csv`; +- `aggregate_comparison.csv`; +- `scenario_diagnostics.csv`. + +The experiment, aggregation pipeline, unit tests, and executed notebook were validated before finalizing this README. + +## Validation status + +Validated LAB03 checkpoints include: + +- LAB03 experiment: PASS; +- LAB03 aggregation: PASS; +- LAB03 notebook build: PASS; +- LAB03 notebook execution: PASS; +- executed notebook code cells: 14/14; +- notebook error outputs: 0; +- notebook PNG outputs: 4; +- LAB03 notebook QA: PASS; +- LAB03-specific tests: 7 passed; +- complete project test suite at the validated checkpoint: 31 passed. + +The notebook is already a validated artifact and should not be rebuilt solely because of README changes. + +## Public reproducibility scope + +This public laboratory contains the analytical components required to inspect and reproduce the spatial cross-validation experiment: + +- executed analytical notebook; +- experiment and aggregation scripts; +- reusable spatial-validation utilities; +- automated validation tests; +- persisted synthetic result artifacts. + +The laboratory uses synthetic data only. It contains no real exploration data, mineral prospectivity rankings, proprietary feature engineering, or confidential project information. + +Notebook-build and release-orchestration utilities are intentionally excluded from the public portfolio because they are implementation tooling rather than part of the analytical demonstration. + +## Key takeaway + +Spatial validation is not only a change in cross-validation syntax. + +It changes the geometry of the prediction problem being evaluated. + +In LAB03, enforcing spatial separation exposed a larger estimated prediction error than conventional Random K-Fold, while excessively large blocks reduced validation support and increased instability. + +The central methodological lesson is therefore to choose spatial validation structures that represent the intended prediction task while retaining sufficient spatial support for meaningful evaluation. diff --git a/labs/lab03_spatial_cross_validation/results/aggregate_comparison.csv b/labs/lab03_spatial_cross_validation/results/aggregate_comparison.csv new file mode 100644 index 0000000..b9b29d6 --- /dev/null +++ b/labs/lab03_spatial_cross_validation/results/aggregate_comparison.csv @@ -0,0 +1,4 @@ +block_size_m,random_pooled_rmse,spatial_pooled_rmse,rmse_gap_spatial_minus_random,relative_rmse_optimism_pct,random_pooled_mae,spatial_pooled_mae,random_median_separation_m,spatial_median_separation_m +5000.0,3.967584239810065,4.260958256754344,0.29337401694427845,6.885165243739029,2.8066854500368925,2.961797439759372,1107.7087304002262,2387.7126328749814 +10000.0,3.967584239810065,5.0865932292237295,1.1190089894136643,21.999183716611785,2.8066854500368925,3.3882344913916387,1107.7087304002262,3192.4526836624264 +20000.0,3.967584239810065,5.232000609815652,1.2644163700055873,24.166976732254977,2.8066854500368925,3.35201134576713,1107.7087304002262,5413.619354342806 diff --git a/labs/lab03_spatial_cross_validation/results/aggregate_metrics.csv b/labs/lab03_spatial_cross_validation/results/aggregate_metrics.csv new file mode 100644 index 0000000..e7e008f --- /dev/null +++ b/labs/lab03_spatial_cross_validation/results/aggregate_metrics.csv @@ -0,0 +1,7 @@ +block_size_m,strategy,test_n_total,pooled_rmse,pooled_mae,fold_r2_mean,fold_r2_sd,fold_rmse_sd,median_separation_m,mean_group_overlap +5000.0,random_kfold,800,3.967584239810065,2.8066854500368925,0.8171130614803946,0.06150655300549316,0.24472876473828117,1107.7087304002262,73.6 +5000.0,spatial_block,800,4.260958256754344,2.961797439759372,0.7857146449492519,0.05204876092940676,0.6436813583011676,2387.7126328749814,0.0 +10000.0,random_kfold,800,3.967584239810065,2.8066854500368925,0.8171130614803946,0.06150655300549316,0.24472876473828117,1107.7087304002262,52.6 +10000.0,spatial_block,800,5.0865932292237295,3.3882344913916387,0.2030461372827424,0.8924549840774524,1.3659888686703965,3192.4526836624264,0.0 +20000.0,random_kfold,800,3.967584239810065,2.8066854500368925,0.8171130614803946,0.06150655300549316,0.24472876473828117,1107.7087304002262,16.0 +20000.0,spatial_block,800,5.232000609815652,3.35201134576713,0.3885817820917777,0.4460995192539494,1.8960872393651118,5413.619354342806,0.0 diff --git a/labs/lab03_spatial_cross_validation/results/experiment_metadata.json b/labs/lab03_spatial_cross_validation/results/experiment_metadata.json new file mode 100644 index 0000000..8f8d94a --- /dev/null +++ b/labs/lab03_spatial_cross_validation/results/experiment_metadata.json @@ -0,0 +1,31 @@ +{ + "block_sizes_m": [ + 5000.0, + 10000.0, + 20000.0 + ], + "bounds": [ + 350000.0, + 430000.0, + 7100000.0, + 7180000.0 + ], + "crs": "EPSG:32719", + "features": [ + "easting", + "northing" + ], + "interpretation_rule": "Positive RMSE gap (spatial minus random) indicates that random CV reports a more optimistic error estimate.", + "model": "KNeighborsRegressor", + "n_campaign": 300, + "n_neighbors": 15, + "n_regional": 500, + "n_samples": 800, + "n_splits": 5, + "reference_target": "signal_true", + "seed": 12345, + "signal_true_max": 82.18236829751064, + "signal_true_min": 10.0, + "target": "signal", + "weights": "distance" +} diff --git a/labs/lab03_spatial_cross_validation/results/fold_results.csv b/labs/lab03_spatial_cross_validation/results/fold_results.csv new file mode 100644 index 0000000..2b15d5f --- /dev/null +++ b/labs/lab03_spatial_cross_validation/results/fold_results.csv @@ -0,0 +1,31 @@ +strategy,block_size_m,fold,train_n,test_n,rmse,mae,r2,min_test_to_train_distance_m,median_test_to_train_distance_m,mean_test_to_train_distance_m,group_overlap +random_kfold,5000.0,0,640,160,4.083815092309702,2.9800992314332033,0.7637380274413212,65.75292622664037,1235.6762959860816,1425.3197084038245,80 +random_kfold,5000.0,1,640,160,3.823680362877409,2.5236521537088583,0.8846590191498169,81.1887035021345,1027.311081677168,1265.660434360269,70 +random_kfold,5000.0,2,640,160,3.9591351356082036,2.777454698968836,0.8389413232913173,49.6382333665891,1207.2912764413968,1492.9534131613193,68 +random_kfold,5000.0,3,640,160,4.291041521637258,2.9548747025401934,0.7416833812427839,65.75292622664037,1107.7087304002262,1426.2481017276473,77 +random_kfold,5000.0,4,640,160,3.6500353302252937,2.797346463533371,0.8565435562767338,49.6382333665891,998.7199188170501,1323.0750377734125,73 +spatial_block,5000.0,0,640,160,5.20368209485337,3.369051434105109,0.8138889976112035,140.6468122608286,1468.5770720585015,1769.4068880119569,0 +spatial_block,5000.0,1,640,160,4.0194239631257265,2.9038478204952054,0.7840983426115342,307.5124527854512,2036.3705656642724,2313.218776681739,0 +spatial_block,5000.0,2,640,160,3.741231092144259,2.8952817516682594,0.7878559521802072,140.6468122608286,2443.342892068571,2481.2483579425416,0 +spatial_block,5000.0,3,640,160,3.6385186705764827,2.6500326123351456,0.7019982748952183,307.5124527854512,2387.7126328749814,2495.0492073613714,0 +spatial_block,5000.0,4,640,160,4.506564299819497,2.99077358019314,0.8407316574480962,216.18130927324296,2475.4814515179255,2469.942535591083,0 +random_kfold,10000.0,0,640,160,4.083815092309702,2.9800992314332033,0.7637380274413212,65.75292622664037,1235.6762959860816,1425.3197084038245,54 +random_kfold,10000.0,1,640,160,3.823680362877409,2.5236521537088583,0.8846590191498169,81.1887035021345,1027.311081677168,1265.660434360269,51 +random_kfold,10000.0,2,640,160,3.9591351356082036,2.777454698968836,0.8389413232913173,49.6382333665891,1207.2912764413968,1492.9534131613193,52 +random_kfold,10000.0,3,640,160,4.291041521637258,2.9548747025401934,0.7416833812427839,65.75292622664037,1107.7087304002262,1426.2481017276473,53 +random_kfold,10000.0,4,640,160,3.6500353302252937,2.797346463533371,0.8565435562767338,49.6382333665891,998.7199188170501,1323.0750377734125,53 +spatial_block,10000.0,0,622,178,2.927652442530796,2.325389826408032,-0.05027186201117173,140.6468122608286,2020.846339715853,2122.484345488571,0 +spatial_block,10000.0,1,645,155,6.126103014849665,4.090533765718425,0.8209403794151098,140.6468122608286,2858.8067841699167,2952.0953271671888,0 +spatial_block,10000.0,2,644,156,4.279661767618534,3.026389684251759,0.8493296781674511,276.2426974091469,3523.020152119695,3662.36826949632,0 +spatial_block,10000.0,3,644,156,5.609095187336697,3.664448916627715,-1.254050483218451,395.2581429101856,3192.4526836624264,3379.246727080614,0 +spatial_block,10000.0,4,645,155,6.005793368695291,3.992675152187921,0.6492829740607738,600.946199719658,3989.077794444758,4259.006648042094,0 +random_kfold,20000.0,0,640,160,4.083815092309702,2.9800992314332033,0.7637380274413212,65.75292622664037,1235.6762959860816,1425.3197084038245,16 +random_kfold,20000.0,1,640,160,3.823680362877409,2.5236521537088583,0.8846590191498169,81.1887035021345,1027.311081677168,1265.660434360269,16 +random_kfold,20000.0,2,640,160,3.9591351356082036,2.777454698968836,0.8389413232913173,49.6382333665891,1207.2912764413968,1492.9534131613193,16 +random_kfold,20000.0,3,640,160,4.291041521637258,2.9548747025401934,0.7416833812427839,65.75292622664037,1107.7087304002262,1426.2481017276473,16 +random_kfold,20000.0,4,640,160,3.6500353302252937,2.797346463533371,0.8565435562767338,49.6382333665891,998.7199188170501,1323.0750377734125,16 +spatial_block,20000.0,0,561,239,2.9858743221499036,2.3838498440272122,-0.09569420932825201,140.6468122608286,3179.4259789812036,3489.298390028466,0 +spatial_block,20000.0,1,669,131,3.5321060021070685,2.934084501137661,-0.10261960028294048,140.6468122608286,2902.269207286124,3342.899974185125,0 +spatial_block,20000.0,2,649,151,6.361296371469694,3.6919266846712087,0.7044344510221625,1071.0598276849023,7218.2791712828175,7901.381987008557,0 +spatial_block,20000.0,3,650,150,7.517717721012398,4.622885600868558,0.7564848571318743,600.946199719658,5413.619354342806,6011.293308703246,0 +spatial_block,20000.0,4,671,129,5.243049899214213,3.694497090903339,0.6803034119160438,600.946199719658,6583.925505360809,7798.130259671615,0 diff --git a/labs/lab03_spatial_cross_validation/results/scenario_diagnostics.csv b/labs/lab03_spatial_cross_validation/results/scenario_diagnostics.csv new file mode 100644 index 0000000..f4ba384 --- /dev/null +++ b/labs/lab03_spatial_cross_validation/results/scenario_diagnostics.csv @@ -0,0 +1,4 @@ +block_size_m,populated_blocks,min_test_blocks,max_test_blocks,median_test_blocks,min_test_n,max_test_n,min_signal_true_sd,max_signal_true_sd +5000.0,224,37,48,46.0,160,160,5.794758008052076,11.508729283320998 +10000.0,64,1,18,16.0,155,178,2.2149979169117975e-06,14.229243110017213 +20000.0,16,1,5,4.0,129,239,0.0001189239471318121,14.996736631375654 diff --git a/labs/lab03_spatial_cross_validation/results/strategy_summary.csv b/labs/lab03_spatial_cross_validation/results/strategy_summary.csv new file mode 100644 index 0000000..d2b9a8c --- /dev/null +++ b/labs/lab03_spatial_cross_validation/results/strategy_summary.csv @@ -0,0 +1,7 @@ +block_size_m,strategy,rmse_mean,rmse_sd,mae_mean,mae_sd,r2_mean,r2_sd,median_separation_m,mean_group_overlap +5000.0,random_kfold,3.961541488531573,0.2447287647382811,2.806685450036892,0.18240195615924948,0.8171130614803946,0.06150655300549315,1107.7087304002262,73.6 +5000.0,spatial_block,4.221884024103867,0.6436813583011676,2.961797439759372,0.2606123727775357,0.7857146449492519,0.05204876092940676,2387.7126328749814,0.0 +10000.0,random_kfold,3.961541488531573,0.2447287647382811,2.806685450036892,0.18240195615924948,0.8171130614803946,0.06150655300549315,1107.7087304002262,52.6 +10000.0,spatial_block,4.989661156206196,1.3659888686703965,3.4198874690387706,0.7400047437720985,0.2030461372827424,0.8924549840774524,3192.4526836624264,0.0 +20000.0,random_kfold,3.961541488531573,0.2447287647382811,2.806685450036892,0.18240195615924948,0.8171130614803946,0.06150655300549315,1107.7087304002262,16.0 +20000.0,spatial_block,5.128008863190656,1.8960872393651116,3.4654487443215958,0.8508260132780674,0.3885817820917776,0.4460995192539494,5413.619354342806,0.0 diff --git a/labs/lab03_spatial_cross_validation/results/validation_comparison.csv b/labs/lab03_spatial_cross_validation/results/validation_comparison.csv new file mode 100644 index 0000000..9c0610f --- /dev/null +++ b/labs/lab03_spatial_cross_validation/results/validation_comparison.csv @@ -0,0 +1,4 @@ +block_size_m,random_rmse,spatial_rmse,rmse_gap_spatial_minus_random,relative_rmse_optimism_pct,random_mae,spatial_mae,mae_gap_spatial_minus_random,random_r2,spatial_r2,r2_gap_random_minus_spatial,random_median_separation_m,spatial_median_separation_m +5000.0,3.961541488531573,4.221884024103867,0.2603425355722937,6.166501355459516,2.806685450036892,2.961797439759372,0.15511198972247975,0.8171130614803946,0.7857146449492519,0.031398416531142725,1107.7087304002262,2387.7126328749814 +10000.0,3.961541488531573,4.989661156206196,1.0281196676746234,20.604999728204724,2.806685450036892,3.4198874690387706,0.6132020190018785,0.8171130614803946,0.2030461372827424,0.6140669241976522,1107.7087304002262,3192.4526836624264 +20000.0,3.961541488531573,5.128008863190656,1.1664673746590832,22.7469843711094,2.806685450036892,3.4654487443215958,0.6587632942847037,0.8171130614803946,0.3885817820917776,0.428531279388617,1107.7087304002262,5413.619354342806 diff --git a/src/geoai/validation.py b/src/geoai/validation.py new file mode 100644 index 0000000..3484d41 --- /dev/null +++ b/src/geoai/validation.py @@ -0,0 +1,380 @@ +from __future__ import annotations + +from dataclasses import dataclass +import random +from typing import Iterable + +import numpy as np + + +@dataclass(frozen=True) +class FoldSplit: + """Indices defining one train/test cross-validation split.""" + + fold: int + train_idx: np.ndarray + test_idx: np.ndarray + + +def _validate_n_splits(n_items: int, n_splits: int) -> None: + if n_items < 2: + raise ValueError("At least two items are required.") + + if n_splits < 2: + raise ValueError("n_splits must be at least 2.") + + if n_splits > n_items: + raise ValueError( + "n_splits cannot exceed the number of available items." + ) + + +def _as_finite_vector( + values: Iterable[float], + name: str, +) -> np.ndarray: + array = np.asarray(values, dtype=float) + + if array.ndim != 1: + raise ValueError(f"{name} must be one-dimensional.") + + if array.size == 0: + raise ValueError(f"{name} cannot be empty.") + + if not np.all(np.isfinite(array)): + raise ValueError(f"{name} must contain only finite values.") + + return array + + +def random_kfold_indices( + n_samples: int, + n_splits: int = 5, + random_state: int = 111, +) -> tuple[FoldSplit, ...]: + """ + Create reproducible random K-fold splits. + + Python's standard-library PRNG is used deliberately so split generation + does not depend on NumPy's random module. + """ + _validate_n_splits(n_samples, n_splits) + + indices = list(range(n_samples)) + rng = random.Random(random_state) + rng.shuffle(indices) + + base_size, remainder = divmod(n_samples, n_splits) + + fold_sizes = [ + base_size + (1 if fold < remainder else 0) + for fold in range(n_splits) + ] + + all_indices = np.arange(n_samples, dtype=int) + splits: list[FoldSplit] = [] + + start = 0 + + for fold, fold_size in enumerate(fold_sizes): + stop = start + fold_size + + test_idx = np.sort( + np.asarray(indices[start:stop], dtype=int) + ) + + mask = np.ones(n_samples, dtype=bool) + mask[test_idx] = False + train_idx = all_indices[mask] + + splits.append( + FoldSplit( + fold=fold, + train_idx=train_idx, + test_idx=test_idx, + ) + ) + + start = stop + + return tuple(splits) + + +def assign_spatial_blocks( + x: Iterable[float], + y: Iterable[float], + block_size: float, + *, + origin_x: float | None = None, + origin_y: float | None = None, +) -> np.ndarray: + """ + Assign observations to regular square spatial blocks. + + Coordinates are assumed to be expressed in a metric projected CRS. + """ + x_arr = _as_finite_vector(x, "x") + y_arr = _as_finite_vector(y, "y") + + if x_arr.size != y_arr.size: + raise ValueError("x and y must have the same length.") + + if not np.isfinite(block_size) or block_size <= 0: + raise ValueError("block_size must be finite and greater than zero.") + + if origin_x is None: + origin_x = ( + np.floor(x_arr.min() / block_size) + * block_size + ) + + if origin_y is None: + origin_y = ( + np.floor(y_arr.min() / block_size) + * block_size + ) + + if not np.isfinite(origin_x) or not np.isfinite(origin_y): + raise ValueError("Block origins must be finite.") + + block_col = np.floor( + (x_arr - origin_x) / block_size + ).astype(int) + + block_row = np.floor( + (y_arr - origin_y) / block_size + ).astype(int) + + return np.asarray( + [ + f"c{col}_r{row}" + for col, row in zip( + block_col, + block_row, + strict=True, + ) + ], + dtype=str, + ) + + +def spatial_group_kfold_indices( + groups: Iterable[object], + n_splits: int = 5, +) -> tuple[FoldSplit, ...]: + """ + Create deterministic group-preserving spatial folds. + + Entire spatial blocks remain in either train or test for each fold, + preventing direct block leakage. + + Groups are assigned greedily to balance the number of observations + across folds. + """ + group_arr = np.asarray(list(groups)) + + if group_arr.ndim != 1: + raise ValueError("groups must be one-dimensional.") + + if group_arr.size == 0: + raise ValueError("groups cannot be empty.") + + unique_groups, counts = np.unique( + group_arr, + return_counts=True, + ) + + _validate_n_splits( + int(unique_groups.size), + n_splits, + ) + + order = sorted( + range(unique_groups.size), + key=lambda idx: ( + -int(counts[idx]), + str(unique_groups[idx]), + ), + ) + + fold_loads = np.zeros(n_splits, dtype=int) + group_to_fold: dict[object, int] = {} + + for group_idx in order: + fold = int(np.argmin(fold_loads)) + group = unique_groups[group_idx] + + group_to_fold[group] = fold + fold_loads[fold] += int(counts[group_idx]) + + sample_folds = np.asarray( + [ + group_to_fold[group] + for group in group_arr + ], + dtype=int, + ) + + all_indices = np.arange( + group_arr.size, + dtype=int, + ) + + splits: list[FoldSplit] = [] + + for fold in range(n_splits): + test_mask = sample_folds == fold + + splits.append( + FoldSplit( + fold=fold, + train_idx=all_indices[~test_mask], + test_idx=all_indices[test_mask], + ) + ) + + return tuple(splits) + + +def nearest_test_to_train_distance( + x: Iterable[float], + y: Iterable[float], + train_idx: Iterable[int], + test_idx: Iterable[int], + *, + chunk_size: int = 1024, +) -> np.ndarray: + """ + Compute the nearest training-point distance for each test observation. + + This diagnostic measures geometric train/test separation and is useful + for evaluating how restrictive a spatial validation design actually is. + """ + x_arr = _as_finite_vector(x, "x") + y_arr = _as_finite_vector(y, "y") + + if x_arr.size != y_arr.size: + raise ValueError("x and y must have the same length.") + + train = np.asarray(list(train_idx), dtype=int) + test = np.asarray(list(test_idx), dtype=int) + + if train.size == 0 or test.size == 0: + raise ValueError( + "train_idx and test_idx must both contain observations." + ) + + if chunk_size < 1: + raise ValueError("chunk_size must be at least 1.") + + if ( + train.min() < 0 + or test.min() < 0 + or train.max() >= x_arr.size + or test.max() >= x_arr.size + ): + raise IndexError( + "Split indices are outside the coordinate arrays." + ) + + result = np.empty(test.size, dtype=float) + + train_x = x_arr[train] + train_y = y_arr[train] + + for start in range(0, test.size, chunk_size): + stop = min( + start + chunk_size, + test.size, + ) + + test_x = x_arr[test[start:stop]][:, None] + test_y = y_arr[test[start:stop]][:, None] + + distances = np.hypot( + test_x - train_x[None, :], + test_y - train_y[None, :], + ) + + result[start:stop] = distances.min( + axis=1 + ) + + return result + + +def summarize_fold_geometry( + x: Iterable[float], + y: Iterable[float], + splits: Iterable[FoldSplit], + *, + groups: Iterable[object] | None = None, +) -> tuple[dict[str, float | int], ...]: + """ + Summarize geometric train/test separation for cross-validation folds. + """ + x_arr = _as_finite_vector(x, "x") + y_arr = _as_finite_vector(y, "y") + + if x_arr.size != y_arr.size: + raise ValueError("x and y must have the same length.") + + group_arr = ( + None + if groups is None + else np.asarray(list(groups)) + ) + + if ( + group_arr is not None + and group_arr.size != x_arr.size + ): + raise ValueError( + "groups must have the same length as x and y." + ) + + summaries: list[dict[str, float | int]] = [] + + for split in splits: + distances = nearest_test_to_train_distance( + x_arr, + y_arr, + split.train_idx, + split.test_idx, + ) + + group_overlap = 0 + + if group_arr is not None: + train_groups = set( + group_arr[split.train_idx].tolist() + ) + test_groups = set( + group_arr[split.test_idx].tolist() + ) + + group_overlap = len( + train_groups.intersection( + test_groups + ) + ) + + summaries.append( + { + "fold": int(split.fold), + "train_n": int(split.train_idx.size), + "test_n": int(split.test_idx.size), + "min_test_to_train_distance": float( + distances.min() + ), + "median_test_to_train_distance": float( + np.median(distances) + ), + "mean_test_to_train_distance": float( + distances.mean() + ), + "group_overlap": int(group_overlap), + } + ) + + return tuple(summaries) diff --git a/tests/test_validation.py b/tests/test_validation.py new file mode 100644 index 0000000..aa9fa72 --- /dev/null +++ b/tests/test_validation.py @@ -0,0 +1,200 @@ +import numpy as np +import pytest + +from geoai.validation import ( + assign_spatial_blocks, + nearest_test_to_train_distance, + random_kfold_indices, + spatial_group_kfold_indices, + summarize_fold_geometry, +) + + +def test_random_kfold_is_reproducible_and_complete(): + first = random_kfold_indices( + n_samples=11, + n_splits=3, + random_state=111, + ) + + second = random_kfold_indices( + n_samples=11, + n_splits=3, + random_state=111, + ) + + assert len(first) == 3 + + for split_a, split_b in zip( + first, + second, + strict=True, + ): + assert np.array_equal( + split_a.train_idx, + split_b.train_idx, + ) + assert np.array_equal( + split_a.test_idx, + split_b.test_idx, + ) + + assert set(split_a.train_idx).isdisjoint( + set(split_a.test_idx) + ) + + all_test = np.concatenate( + [split.test_idx for split in first] + ) + + assert sorted(all_test.tolist()) == list( + range(11) + ) + + fold_sizes = [ + split.test_idx.size + for split in first + ] + + assert max(fold_sizes) - min(fold_sizes) <= 1 + + +def test_assign_spatial_blocks_known_geometry(): + x = np.array( + [0.0, 9.9, 10.0, 19.9] + ) + y = np.array( + [0.0, 9.9, 10.0, 19.9] + ) + + groups = assign_spatial_blocks( + x, + y, + block_size=10.0, + origin_x=0.0, + origin_y=0.0, + ) + + assert groups.tolist() == [ + "c0_r0", + "c0_r0", + "c1_r1", + "c1_r1", + ] + + +def test_assign_spatial_blocks_rejects_invalid_size(): + with pytest.raises( + ValueError, + match="block_size", + ): + assign_spatial_blocks( + [0.0, 1.0], + [0.0, 1.0], + block_size=0.0, + ) + + +def test_spatial_group_kfold_prevents_group_leakage(): + groups = np.array( + [ + "A", "A", + "B", "B", + "C", "C", + "D", "D", + ] + ) + + splits = spatial_group_kfold_indices( + groups, + n_splits=4, + ) + + all_test = [] + + for split in splits: + train_groups = set( + groups[split.train_idx] + ) + test_groups = set( + groups[split.test_idx] + ) + + assert train_groups.isdisjoint( + test_groups + ) + + all_test.extend( + split.test_idx.tolist() + ) + + assert sorted(all_test) == list( + range(groups.size) + ) + + +def test_spatial_group_kfold_rejects_too_many_folds(): + groups = ["A", "A", "B", "B"] + + with pytest.raises( + ValueError, + match="n_splits", + ): + spatial_group_kfold_indices( + groups, + n_splits=3, + ) + + +def test_nearest_test_to_train_distance_known_geometry(): + x = np.array( + [0.0, 3.0, 10.0] + ) + y = np.zeros(3) + + distances = nearest_test_to_train_distance( + x, + y, + train_idx=[0, 2], + test_idx=[1], + ) + + assert distances.shape == (1,) + assert distances[0] == pytest.approx( + 3.0 + ) + + +def test_spatial_summary_reports_zero_group_overlap(): + x = np.array( + [0.0, 1.0, 10.0, 11.0] + ) + y = np.zeros(4) + + groups = np.array( + ["A", "A", "B", "B"] + ) + + splits = spatial_group_kfold_indices( + groups, + n_splits=2, + ) + + summaries = summarize_fold_geometry( + x, + y, + splits, + groups=groups, + ) + + assert len(summaries) == 2 + + assert all( + row["group_overlap"] == 0 + for row in summaries + ) + + assert all( + row["min_test_to_train_distance"] > 0 + for row in summaries + )