diff --git a/.claude/skills/ddrs-debugging-playbook/SKILL.md b/.claude/skills/ddrs-debugging-playbook/SKILL.md index 20890dc..a4b3594 100644 --- a/.claude/skills/ddrs-debugging-playbook/SKILL.md +++ b/.claude/skills/ddrs-debugging-playbook/SKILL.md @@ -73,6 +73,8 @@ Scan this table first. Each row points to a Part 2 entry with the full story and | Resumed run drifts from uninterrupted run | Expected: weights stored as f16 (CompactRecorder) | [T11](#t11-checkpoint-resume-issues) | | `ddrs run --strict` exits with code 4 | Source fingerprint drift vs `.ddrs/sources.lock` | [T12](#t12-source-lock-drift) | | Recoverability / identifiability experiment fails | Hotstart transient noise floor issue (Phase B not yet met) | [T13](#t13-leakance-identifiability-status) | +| `probe_zeta_gradient --mode teacher` killed with no error in its own log | 365-day chunk peaks ~65 GB RSS on the 64,892-reach eval network; kernel OOM kill | [T14](#t14-teacher-mode-oom) | +| Workflow fails `icechunk read failed ... object not found` deep into eval; store probes clean | Transient icechunk read failure, not a data hole | [T15](#t15-transient-icechunk-read-failure) | --- @@ -460,6 +462,39 @@ cat .ddrs/sources.lock # shows last-locked fingerprints --- +### T14: Teacher mode OOM + +**Story (2026-07-23).** The synthetic-n teacher run (`probe_zeta_gradient --mode teacher`, full 29-year window, 64,892-reach eval network, CPU backend) died 11 minutes after launch with NOTHING in its own log past the setup lines — no panic, no error. The kernel OOM killer had taken it at 54 GB anon RSS (213 GB total-vm) during its FIRST 365-day chunk; desktop apps (Slack/Hyprland/browser) held ~24 GB of the 93 GB machine and the teacher had the highest oom_score. + +**Discriminating test.** Log ends abruptly after `teacher: N plants, ...` with no `chunk k/n` lines and the process is gone: +```bash +journalctl -k --since | grep -iE 'oom|killed process' +# → "Out of memory: Killed process (probe_zeta_grad)" +``` + +**Memory profile (measured 2026-07-28):** RSS climbs steadily WITHIN a chunk (transient per-timestep allocations) and collapses back to ~4 GB at every chunk boundary. Peak scales with chunk length: ~65 GB at 365 days, ~45 GB at 180 days. + +**Fix:** `--chunk-days 180` (added 2026-07-28; default 365 = old behavior). Cost: disagg boundary-artifact density doubles (0.55% → 1.1% of days over 29 years) — still negligible. State continuity across chunks is exact either way. The 180-day teacher completed the full 59-chunk window in ~14 h wall. + +**Caveat:** `run_state_cache` still hardcodes 365; if you ever pair a state cache with a teacher run, their chunk lengths must match (state boundaries align). + +--- + +### T15: Transient icechunk read failure + +**Story (2026-07-28).** The synthetic-n `distributed` student completed all 5 training epochs, then its eval died at chunk 364/366 with `icechunk read failed at .../daily_dhbv_aorc2f_merit_unit_catchments.ic: object not found` (empty context, no panic). Looked like the store ends before 2010-09-30 — it doesn't. + +**Why it can't be a data hole:** these icechunk Q' stores are divide-major — `Qr` chunk shape `(200 divides, ALL 14,976 days)`. Any time-slice read touches every divide-block chunk object, so eval chunks 1–363 had already read the exact objects chunk 364 "couldn't find". A direct Python probe of the same date range read clean immediately after. Verdict: transient. + +**Triage:** +1. Probe the store at the failing range (from `~/projects/ddr` venv): `icechunk.Repository.open(icechunk.local_filesystem_storage())` → read the failing day-slice. Clean read ⇒ transient. +2. Check `ddrs import --dry-run` — reports the declared time axis and sample-read health. +3. Only if BOTH fail is it a real store problem. + +**Recovery:** training and eval are separate phases — a post-training eval failure leaves the epoch-5 checkpoint valid. Dump parameters from it (`dump_parameters --checkpoint /head`) and re-run eval-only later (legacy `eval` binary) if the diagnostics matter. Drivers chaining multiple runs should treat "workflow exited nonzero but final checkpoint exists" as continue-with-warning, not abort (see `output/synthetic_n/run_students_sequential.sh`). + +--- + ## Part 3 — Pre-flight checklist before any training run Use this before starting a new experiment to prevent the most common traps: diff --git a/.gitignore b/.gitignore index 40a696b..718c273 100644 --- a/.gitignore +++ b/.gitignore @@ -48,4 +48,5 @@ __pycache__/ .cargo/ .ddrs/ +.ddrs-synthetic-n-*/ ddrs.yaml diff --git a/config/experiments/synthetic_n_student_daily_lstm.yaml b/config/experiments/synthetic_n_student_daily_lstm.yaml new file mode 100644 index 0000000..7cf5b83 --- /dev/null +++ b/config/experiments/synthetic_n_student_daily_lstm.yaml @@ -0,0 +1,104 @@ +# synthetic_n_student_daily_lstm.yaml — synthetic-n recoverability student: +# GENERATED from lstm_daily_frozen_chunk1.yaml, observations repointed to the +# synthetic-n teacher's ground-truth store (output/synthetic_n/synthetic_obs_lm) +# — everything else (Q' source, disagg head, architecture) stays identical to +# the real campaign arm below. +# Spec: docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md +# Companion synthetic-n students: synthetic_n_student_{distributed,lumped,hourly_lstm}.yaml +# +# --- original lstm_daily_frozen_chunk1.yaml header, unmodified below --- +# lstm_daily_frozen_chunk1.yaml — full CONUS routing train against the daily +# CudaLSTM (NH) Q' forecast, updated to the capacity-boosted frozen disagg +# head (hidden 16, 2 KanLayers, grid 20, chunk_days=1, warm-started from +# capacity_chunk1.mpk, FROZEN) — supersedes the older +# equif_daily_lstm_disagg.yaml arm, which pre-dates the 2026-07-10/12 KAN +# disagg fixes and used a plain hidden_size:16 head with no pretraining. +# +# Both the KAN head and the router run on GPU (sparse_solver: cuda). +# Companion arm: lstm_hourly_native.yaml (hourly-native Q', no disagg head). + +mode: training +workflow: train-and-test +geodataset: merit +device: 0 +seed: 42 +np_seed: 42 + +data_sources: + attributes: /home/tbindas/projects/ddr/data/merit_global_attributes_v2.nc + conus_adjacency: /home/tbindas/projects/ddr/data/merit_conus_adjacency.zarr + gages_adjacency: /home/tbindas/projects/ddr/data/merit_gages_conus_adjacency.zarr + streamflow: /mnt/ssd1/data/icechunk/daily_lstm_merit_unit_catchments.ic + observations: /home/tbindas/projects/ddrs/output/synthetic_n/synthetic_obs_lm + gages: /home/tbindas/projects/ddr/references/gage_info/gages_3000.csv + aorc_precip: /mnt/ssd1/data/aorc/merit_unit_catchments.zarr + +experiment: + batch_size: 64 + start_time: 1981/10/01 + end_time: 1995/09/30 + epochs: 5 + rho: 90 + shuffle: true + warmup: 5 + learning_rate: + 1: 0.001 + 3: 0.0005 + grad_clip_max_norm: 1.0 + +kan_head: + hidden_size: 21 + num_hidden_layers: 2 + grid: 50 + k: 2 + input_var_names: + - SoilGrids1km_clay + - aridity + - meanelevation + - meanP + - NDVI + - meanslope + - log10_uparea + - SoilGrids1km_sand + - ETPOT_Hargr + - Porosity + learnable_parameters: + - n + - q_spatial + - p_spatial + # Capacity-boosted disagg head — architecture MUST match capacity_chunk1.mpk + # (pretrain_disagg_capacity --chunk-days 1: hidden 16, 2 layers, grid 20, k 3). + disaggregation: + hidden_size: 16 + num_hidden_layers: 2 + grid: 20 + k: 3 + boundary_blend: 0.0 + chunk_days: 1 + pretrained_checkpoint: /home/tbindas/projects/ddrs/output/disagg_pretrain/capacity_chunk1.mpk + freeze: true + +params: + parameter_ranges: + n: [0.015, 0.25] + q_spatial: [0.0, 1.0] + p_spatial: [1.0, 200.0] + attribute_minimums: + discharge: 1.0e-4 + slope: 1.0e-3 + velocity: 0.01 + depth: 0.01 + bottom_width: 0.01 + defaults: + p_spatial: 21.0 + log_space_parameters: + - p_spatial + sparse_solver: cuda + use_cuda_graphs: false + use_leakance: false + +testing: + start_time: 1995/10/01 + end_time: 2010/09/30 + batch_size: 15 + rho: null diff --git a/config/experiments/synthetic_n_student_distributed.yaml b/config/experiments/synthetic_n_student_distributed.yaml new file mode 100644 index 0000000..add9169 --- /dev/null +++ b/config/experiments/synthetic_n_student_distributed.yaml @@ -0,0 +1,105 @@ +# synthetic_n_student_distributed.yaml — synthetic-n recoverability student: +# GENERATED from aorc2f_distributed_frozen_chunk1.yaml, observations repointed +# to the synthetic-n teacher's ground-truth store (output/synthetic_n/ +# synthetic_obs_lm) — everything else (Q' source, disagg head, architecture) +# stays identical to the real campaign arm below. +# Spec: docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md +# Companion synthetic-n students: synthetic_n_student_{lumped,daily_lstm,hourly_lstm}.yaml +# +# --- original aorc2f_distributed_frozen_chunk1.yaml header, unmodified below --- +# aorc2f_distributed_frozen_chunk1.yaml — full CONUS routing train against the +# distributed+UH-routing dHBV AORC2F v2 Q' forecast (upstream checkpoint +# CONUS2717_AORC2F_v2 ep69 — a DDR/PyTorch model that produced this store's +# Q' data; ddrs only reads the resulting streamflow, it does not load that +# checkpoint). Same capacity-boosted frozen disagg head as +# kan_disagg_conus_frozen_chunk1.yaml (hidden 16, 2 KanLayers, grid 20, +# chunk_days=1, warm-started from capacity_chunk1.mpk, FROZEN). +# +# Both the KAN head and the router run on GPU (sparse_solver: cuda). +# Companion arm: aorc2f_lumped_frozen_chunk1.yaml (same settings, lumped Q'). + +mode: training +workflow: train-and-test +geodataset: merit +device: 0 +seed: 42 +np_seed: 42 + +data_sources: + attributes: /home/tbindas/projects/ddr/data/merit_global_attributes_v2.nc + conus_adjacency: /home/tbindas/projects/ddr/data/merit_conus_adjacency.zarr + gages_adjacency: /home/tbindas/projects/ddr/data/merit_gages_conus_adjacency.zarr + streamflow: /mnt/ssd1/data/icechunk/daily_dhbv_aorc2f_merit_unit_catchments.ic + observations: /home/tbindas/projects/ddrs/output/synthetic_n/synthetic_obs_lm + gages: /home/tbindas/projects/ddr/references/gage_info/gages_3000.csv + aorc_precip: /mnt/ssd1/data/aorc/merit_unit_catchments.zarr + +experiment: + batch_size: 64 + start_time: 1981/10/01 + end_time: 1995/09/30 + epochs: 5 + rho: 90 + shuffle: true + warmup: 5 + learning_rate: + 1: 0.001 + 3: 0.0005 + grad_clip_max_norm: 1.0 + +kan_head: + hidden_size: 21 + num_hidden_layers: 2 + grid: 50 + k: 2 + input_var_names: + - SoilGrids1km_clay + - aridity + - meanelevation + - meanP + - NDVI + - meanslope + - log10_uparea + - SoilGrids1km_sand + - ETPOT_Hargr + - Porosity + learnable_parameters: + - n + - q_spatial + - p_spatial + # Capacity-boosted disagg head — architecture MUST match capacity_chunk1.mpk + # (pretrain_disagg_capacity --chunk-days 1: hidden 16, 2 layers, grid 20, k 3). + disaggregation: + hidden_size: 16 + num_hidden_layers: 2 + grid: 20 + k: 3 + boundary_blend: 0.0 + chunk_days: 1 + pretrained_checkpoint: /home/tbindas/projects/ddrs/output/disagg_pretrain/capacity_chunk1.mpk + freeze: true + +params: + parameter_ranges: + n: [0.015, 0.25] + q_spatial: [0.0, 1.0] + p_spatial: [1.0, 200.0] + attribute_minimums: + discharge: 1.0e-4 + slope: 1.0e-3 + velocity: 0.01 + depth: 0.01 + bottom_width: 0.01 + defaults: + p_spatial: 21.0 + log_space_parameters: + - p_spatial + sparse_solver: cuda + use_cuda_graphs: false + use_leakance: false + +testing: + start_time: 1995/10/01 + end_time: 2010/09/30 + batch_size: 15 + rho: null diff --git a/config/experiments/synthetic_n_student_hourly_lstm.yaml b/config/experiments/synthetic_n_student_hourly_lstm.yaml new file mode 100644 index 0000000..fc75d40 --- /dev/null +++ b/config/experiments/synthetic_n_student_hourly_lstm.yaml @@ -0,0 +1,91 @@ +# synthetic_n_student_hourly_lstm.yaml — synthetic-n recoverability student: +# GENERATED from lstm_hourly_native.yaml, observations repointed to the +# synthetic-n teacher's ground-truth store (output/synthetic_n/synthetic_obs_lm) +# — everything else (Q' source, no-disagg-head architecture) stays identical +# to the real campaign arm below. +# Spec: docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md +# Companion synthetic-n students: synthetic_n_student_{distributed,lumped,daily_lstm}.yaml +# +# --- original lstm_hourly_native.yaml header, unmodified below --- +# lstm_hourly_native.yaml — full CONUS routing train against the hourly-native +# MTS-LSTM (NH) Q' forecast. No disaggregation block — the store is already +# hourly-native, and kan_head.disaggregation + an hourly-native source is a +# hard config-load error (src/data/dataset.rs::validate_disagg_vs_resolution). +# +# Both the KAN head and the router run on GPU (sparse_solver: cuda). +# Companion arm: lstm_daily_frozen_chunk1.yaml (daily Q', frozen disagg head). + +mode: training +workflow: train-and-test +geodataset: merit +device: 0 +seed: 42 +np_seed: 42 + +data_sources: + attributes: /home/tbindas/projects/ddr/data/merit_global_attributes_v2.nc + conus_adjacency: /home/tbindas/projects/ddr/data/merit_conus_adjacency.zarr + gages_adjacency: /home/tbindas/projects/ddr/data/merit_gages_conus_adjacency.zarr + streamflow: /mnt/ssd1/data/icechunk/hourly_lstm_merit_unit_catchments.ic + observations: /home/tbindas/projects/ddrs/output/synthetic_n/synthetic_obs_lm + gages: /home/tbindas/projects/ddr/references/gage_info/gages_3000.csv + aorc_precip: /mnt/ssd1/data/aorc/merit_unit_catchments.zarr + +experiment: + batch_size: 64 + start_time: 1981/10/01 + end_time: 1995/09/30 + epochs: 5 + rho: 90 + shuffle: true + warmup: 5 + learning_rate: + 1: 0.001 + 3: 0.0005 + grad_clip_max_norm: 1.0 + +kan_head: + hidden_size: 21 + num_hidden_layers: 2 + grid: 50 + k: 2 + input_var_names: + - SoilGrids1km_clay + - aridity + - meanelevation + - meanP + - NDVI + - meanslope + - log10_uparea + - SoilGrids1km_sand + - ETPOT_Hargr + - Porosity + learnable_parameters: + - n + - q_spatial + - p_spatial + +params: + parameter_ranges: + n: [0.015, 0.25] + q_spatial: [0.0, 1.0] + p_spatial: [1.0, 200.0] + attribute_minimums: + discharge: 1.0e-4 + slope: 1.0e-3 + velocity: 0.01 + depth: 0.01 + bottom_width: 0.01 + defaults: + p_spatial: 21.0 + log_space_parameters: + - p_spatial + sparse_solver: cuda + use_cuda_graphs: false + use_leakance: false + +testing: + start_time: 1995/10/01 + end_time: 2010/09/30 + batch_size: 15 + rho: null diff --git a/config/experiments/synthetic_n_student_lumped.yaml b/config/experiments/synthetic_n_student_lumped.yaml new file mode 100644 index 0000000..89b1acb --- /dev/null +++ b/config/experiments/synthetic_n_student_lumped.yaml @@ -0,0 +1,106 @@ +# synthetic_n_student_lumped.yaml — synthetic-n recoverability student: +# GENERATED from aorc2f_lumped_frozen_chunk1.yaml, observations repointed +# to the synthetic-n teacher's ground-truth store (output/synthetic_n/ +# synthetic_obs_lm) — everything else (Q' source, disagg head, architecture) +# stays identical to the real campaign arm below. +# Spec: docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md +# Companion synthetic-n students: synthetic_n_student_{distributed,daily_lstm,hourly_lstm}.yaml +# +# --- original aorc2f_lumped_frozen_chunk1.yaml header, unmodified below --- +# aorc2f_lumped_frozen_chunk1.yaml — full CONUS routing train against the +# lumped (AORC) dHBV AORC2F Q' forecast (upstream checkpoint +# CONUS2717_AORC2F_LUMPED ep63 — a DDR/PyTorch model that produced this +# store's Q' data; ddrs only reads the resulting streamflow, it does not +# load that checkpoint). Same capacity-boosted frozen disagg head as +# kan_disagg_conus_frozen_chunk1.yaml (hidden 16, 2 KanLayers, grid 20, +# chunk_days=1, warm-started from capacity_chunk1.mpk, FROZEN). +# +# Both the KAN head and the router run on GPU (sparse_solver: cuda). +# Companion arm: aorc2f_distributed_frozen_chunk1.yaml (same settings, +# distributed+UH-routing Q'). + +mode: training +workflow: train-and-test +geodataset: merit +device: 0 +seed: 42 +np_seed: 42 + +data_sources: + attributes: /home/tbindas/projects/ddr/data/merit_global_attributes_v2.nc + conus_adjacency: /home/tbindas/projects/ddr/data/merit_conus_adjacency.zarr + gages_adjacency: /home/tbindas/projects/ddr/data/merit_gages_conus_adjacency.zarr + streamflow: /mnt/ssd1/data/icechunk/daily_dhbv2_merit_unit_catchments.ic + observations: /home/tbindas/projects/ddrs/output/synthetic_n/synthetic_obs_lm + gages: /home/tbindas/projects/ddr/references/gage_info/gages_3000.csv + aorc_precip: /mnt/ssd1/data/aorc/merit_unit_catchments.zarr + +experiment: + batch_size: 64 + start_time: 1981/10/01 + end_time: 1995/09/30 + epochs: 5 + rho: 90 + shuffle: true + warmup: 5 + learning_rate: + 1: 0.001 + 3: 0.0005 + grad_clip_max_norm: 1.0 + +kan_head: + hidden_size: 21 + num_hidden_layers: 2 + grid: 50 + k: 2 + input_var_names: + - SoilGrids1km_clay + - aridity + - meanelevation + - meanP + - NDVI + - meanslope + - log10_uparea + - SoilGrids1km_sand + - ETPOT_Hargr + - Porosity + learnable_parameters: + - n + - q_spatial + - p_spatial + # Capacity-boosted disagg head — architecture MUST match capacity_chunk1.mpk + # (pretrain_disagg_capacity --chunk-days 1: hidden 16, 2 layers, grid 20, k 3). + disaggregation: + hidden_size: 16 + num_hidden_layers: 2 + grid: 20 + k: 3 + boundary_blend: 0.0 + chunk_days: 1 + pretrained_checkpoint: /home/tbindas/projects/ddrs/output/disagg_pretrain/capacity_chunk1.mpk + freeze: true + +params: + parameter_ranges: + n: [0.015, 0.25] + q_spatial: [0.0, 1.0] + p_spatial: [1.0, 200.0] + attribute_minimums: + discharge: 1.0e-4 + slope: 1.0e-3 + velocity: 0.01 + depth: 0.01 + bottom_width: 0.01 + defaults: + p_spatial: 21.0 + log_space_parameters: + - p_spatial + sparse_solver: cuda + use_cuda_graphs: false + use_leakance: false + +testing: + start_time: 1995/10/01 + end_time: 2010/09/30 + batch_size: 15 + rho: null diff --git a/config/experiments/synthetic_n_teacher.yaml b/config/experiments/synthetic_n_teacher.yaml new file mode 100644 index 0000000..9045982 --- /dev/null +++ b/config/experiments/synthetic_n_teacher.yaml @@ -0,0 +1,95 @@ +# synthetic_n_teacher.yaml — synthetic-n recoverability ground-truth generator. +# GENERATED from aorc2f_distributed_frozen_chunk1.yaml — teacher world: full +# simulation window, standard benchmark Q' store, no leakance. +# Spec: docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md + +mode: training +workflow: train-and-test +geodataset: merit +device: 0 +seed: 42 +np_seed: 42 + +data_sources: + attributes: /home/tbindas/projects/ddr/data/merit_global_attributes_v2.nc + conus_adjacency: /home/tbindas/projects/ddr/data/merit_conus_adjacency.zarr + gages_adjacency: /home/tbindas/projects/ddr/data/merit_gages_conus_adjacency.zarr + streamflow: /mnt/ssd1/data/icechunk/merit_dhbv2_UH_retrospective.ic + observations: /mnt/ssd1/data/icechunk/usgs_daily_observations + gages: /home/tbindas/projects/ddr/references/gage_info/gages_3000.csv + aorc_precip: /mnt/ssd1/data/aorc/merit_unit_catchments.zarr + +experiment: + batch_size: 64 + start_time: 1981/10/01 + end_time: 1995/09/30 + epochs: 5 + rho: 90 + shuffle: true + warmup: 5 + learning_rate: + 1: 0.001 + 3: 0.0005 + grad_clip_max_norm: 1.0 + +kan_head: + hidden_size: 21 + num_hidden_layers: 2 + grid: 50 + k: 2 + input_var_names: + - SoilGrids1km_clay + - aridity + - meanelevation + - meanP + - NDVI + - meanslope + - log10_uparea + - SoilGrids1km_sand + - ETPOT_Hargr + - Porosity + learnable_parameters: + - n + - q_spatial + - p_spatial + # Capacity-boosted disagg head — architecture MUST match capacity_chunk1.mpk + # (pretrain_disagg_capacity --chunk-days 1: hidden 16, 2 layers, grid 20, k 3). + disaggregation: + hidden_size: 16 + num_hidden_layers: 2 + grid: 20 + k: 3 + boundary_blend: 0.0 + chunk_days: 1 + pretrained_checkpoint: /home/tbindas/projects/ddrs/output/disagg_pretrain/capacity_chunk1.mpk + freeze: true + +params: + use_leakance: false + parameter_ranges: + n: [0.015, 0.25] + q_spatial: [0.0, 1.0] + p_spatial: [1.0, 200.0] + attribute_minimums: + discharge: 1.0e-4 + slope: 1.0e-3 + velocity: 0.01 + depth: 0.01 + bottom_width: 0.01 + defaults: + p_spatial: 21.0 + log_space_parameters: + - p_spatial + sparse_solver: cpu + use_cuda_graphs: false + +# 1-day padding each side of the union of both student axes (1981/10/01- +# 1995/09/30 train + 1995/10/01-2010/09/30 test), so tau-trim + the +# teacher's last-day drop produce synthetic obs covering EXACTLY +# 1981/10/01-2010/09/30 — matching recoverability_teacher.yaml's padding +# convention. +testing: + start_time: 1981/09/30 + end_time: 2010/10/01 + batch_size: 15 + rho: null diff --git a/docs/2026-07-22-synthetic-n-recoverability-findings.md b/docs/2026-07-22-synthetic-n-recoverability-findings.md new file mode 100644 index 0000000..2006904 --- /dev/null +++ b/docs/2026-07-22-synthetic-n-recoverability-findings.md @@ -0,0 +1,77 @@ +# Synthetic-n recoverability across real Q' sources — findings (INTERIM) + +**Status: INTERIM — 1 of 4 arms complete.** The experiment was paused on +2026-07-29 after arm 1 (`distributed`) when the machine was reallocated to new +unit-catchment runs. The pre-registered S1–S5 verdicts (design spec §3) require +all 4 arms and are **not yet computable**. This doc records execution facts and +the arm-1 preview so nothing is lost; it must be finalized when the remaining +arms (`lumped`, `daily_lstm`, `hourly_lstm`) complete. + +Spec: `docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md` +Plan: `docs/superpowers/plans/2026-07-22-synthetic-n-recoverability.md` +PR: https://github.com/taddyb/ddrs/pull/29 + +## What this tests + +Whether learned Manning's n absorbs Q'-source bias while channel geometry +(q_spatial/p_spatial) does not — in a world where the truth is KNOWN. A teacher +(standard benchmark Q' store + prescribed Leopold-Maddock n + consensus +geometry) generates noise-free synthetic gauge observations; 4 students train +against those observations, each forced by one of the campaign's real Q' +stores. Recovered n/q/p (via `dump_parameters`) is compared to the truth donor. + +## Execution notes + +| Step | Outcome | +|---|---| +| Teacher (Task 4 Step 5) | First launch 2026-07-23 **OOM-killed** at chunk 1/30: the 365-day chunk peaks ~65 GB RSS on the 64,892-reach network (debugging-playbook T14). Fixed by new `--chunk-days` flag; relaunched 2026-07-27 with 180-day chunks (peak ~45 GB, ~4 GB at boundaries). Completed 59/59 chunks in ~14 h wall: synthetic obs for 2,365 gauges × 10,592 days from 1981-10-01, 94.3% finite (NaN-padded before 1981-10-02). | +| Donor parity gate (Task 1) | `tests/teacher_donor_override_parity.rs` passes: own-donor teacher run within 6e-5 m³/s of no-donor (tolerance 1e-3). | +| Student `distributed` | Training complete (5 epochs, `epoch_5_mb_35`, ~7 h CPU). Eval died at chunk 364/366 on a **transient** icechunk `object not found` (playbook T15 — store probes clean; divide-major chunking means the same objects were read 363 times before). Eval diagnostics lost; `recovered_distributed.nc` dumped from the completed checkpoint. | +| Students `lumped`/`daily_lstm`/`hourly_lstm` | Launched sequentially (serialized per user request); **stopped at user request 2026-07-29** during `lumped` epoch 1 (machine reallocated). Resume: `output/synthetic_n/run_students_sequential.sh lumped daily_lstm hourly_lstm`. | +| Original campaign eval caveat | The Jul 16 `distributed` campaign arm's own eval crashed at chunk 4/366 (GPU cubecl OOM panic), so the full 1995–2010 eval window had never been exercised against the aorc2f store before this experiment. | + +## Arm-1 preview (distributed) — NOT a verdict + +Computed over all 346,321 CONUS reaches vs `truth_leopold_maddock.nc` +(notebook: `output/synthetic_n/plots/synthetic_n_recovery_distributed.ipynb`): + +| Quantity | Value | +|---|---| +| n median abs error | 0.0354 | +| corr(truth n, recovered n) | 0.736 | +| true n slope vs log10_uparea | −0.0421 | +| recovered n slope | −0.0193 (correct sign, attenuated ~54%) | +| q_spatial median abs error | 0.0274 | +| p_spatial median abs error | 5.95 | + +Reading: under the distributed (aorc2f) forcing, the student recovers the +Leopold-Maddock downstream-decreasing n structure with the correct sign but +under-estimates its magnitude; roughly a third of reaches carry |n error| > +0.05. Whether this error varies systematically ACROSS Q' sources (S1/S4) and +whether any source flips the slope sign (S2) is exactly what the remaining 3 +arms decide — no conclusion is drawn here. + +## Required caveats (design spec §6 concern 1, §1 naming note) + +1. **Disagg-head confound on S3.** Small/consistent geometry recovery error + across arms is NOT independent proof that geometry is physically + identifiable regardless of Q'-source bias: teacher and all 4 students share + the SAME frozen capacity-boosted chunk1 disagg head, so a latent disagg-head + effect on q/p would look identical to genuine geometry robustness. Any S3 + result must be reported as "consistent under a shared, frozen disagg head." + +2. **Campaign-naming provenance.** This experiment's 4 arms + (`aorc2f_distributed`/`aorc2f_lumped`/`daily_lstm`/`hourly_lstm`, from the + 2026-07-16 AORC2F/LSTM wave) are a DIFFERENT arm set from the + pre-registered LSTM-equifinality campaign's R1/R2/R3 naming (the paper's + `tab:arms`). The two numbering schemes must not bleed together in any table + or cross-reference. + +## Remaining work to finalize + +1. Resume and complete the 3 remaining students + dumps (~24 h CPU sequential). +2. Run `scripts/synthetic_n_recoverability_analysis.py` → S1–S5 verdicts + + `recoverability_rows.csv`. +3. Extend the recovery notebook to all 4 arms; decide Phase 2 (Gaussian-null + confirmatory run) per plan Task 7 Step 5. +4. Replace this doc's INTERIM header with the final verdicts. diff --git a/docs/superpowers/plans/2026-07-22-synthetic-n-recoverability.md b/docs/superpowers/plans/2026-07-22-synthetic-n-recoverability.md new file mode 100644 index 0000000..8a330ac --- /dev/null +++ b/docs/superpowers/plans/2026-07-22-synthetic-n-recoverability.md @@ -0,0 +1,1309 @@ +# Synthetic n-Recoverability Across Real Q' Sources Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Build a ground-truth-anchored synthetic-twin control that tests whether learned Manning's n absorbs Q'-source bias while channel geometry (q_spatial/p_spatial) does not, using this campaign's 4 real Q' stores as the forcing. + +**Architecture:** Extend the existing `probe_zeta_gradient --mode teacher` driver (already builds synthetic gauge observations from a chunked continuous forward pass) to also accept an n/q_spatial/p_spatial donor override — reusing the exact `load_comid_field`/`gather_by_comid`/`physical_to_normalized`/`RoutingParamOverride` machinery `--mode eval-loss`'s "full-swap" composition already uses. Generate a truth donor NetCDF (prescribed n + consensus geometry from this campaign's 4 already-converged checkpoints), route the standard benchmark Q' store through it to get noise-free synthetic gauge observations, then train 4 fresh students — one per real campaign Q' store — against those synthetic observations. Compare each student's recovered n/q_spatial/p_spatial (via the existing `dump_parameters` binary) against the known truth. + +**Tech Stack:** Rust (BURN 0.21), Python (`ddrs-py` venv: xarray, netCDF4, numpy, pandas), existing `ddrs` CLI binaries (`probe_zeta_gradient`, `dump_parameters`, `train`). + +Spec: `docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md` + +--- + +## File Structure + +| File | Responsibility | +|---|---| +| `src/bin/probe_zeta_gradient.rs` (modify `run_teacher`, `Cli`, module doc, the eval-loss-only CLI guard) | Teacher mode gains an optional `--donor-params-nc` n/q/p override; `--plant-file`/`--zeta-output`/`use_leakance` become independent of it, not required | +| `tests/teacher_donor_override_parity.rs` (new) | Parity gate: injecting a checkpoint's own dump as a full n/q/p donor must reproduce that checkpoint's un-overridden synthetic obs | +| `scripts/synthetic_n_consensus_geometry.py` (new) | Runs `dump_parameters` against the 4 real campaign checkpoints, computes per-COMID median q_spatial/p_spatial | +| `scripts/synthetic_n_truth_fields.py` (new) | Computes the Leopold-Maddock and Gaussian-noise truth-n fields from `log10_uparea`; combines with consensus geometry into two donor NetCDFs | +| `config/experiments/synthetic_n_teacher.yaml` (new) | Teacher config: standard benchmark Q' store, full 1981-2010 window | +| `config/experiments/synthetic_n_student_{distributed,lumped,daily_lstm,hourly_lstm}.yaml` (new, 4 files) | Student configs: exact copies of this campaign's own 4 arms, observations repointed to the synthetic obs store | +| `scripts/synthetic_n_recoverability_analysis.py` (new) | Computes S1-S5 pre-registered verdicts from the 4 students' `dump_parameters` output vs the truth NetCDF | + +No changes to `src/routing/`, `src/geometry.rs`, `src/sparse.rs`, or any `Backward` impl. + +--- + +### Task 1: Extend `probe_zeta_gradient --mode teacher` with an optional n/q/p donor override + +**Files:** +- Modify: `src/bin/probe_zeta_gradient.rs:35-42` (module doc, Stage 3 section) +- Modify: `src/bin/probe_zeta_gradient.rs:204,208,212,228-234` (Cli struct doc comments) +- Modify: `src/bin/probe_zeta_gradient.rs:337-351` (donor-flag mode guard) +- Modify: `src/bin/probe_zeta_gradient.rs:1058-1150` (`run_teacher` body) +- Test: `tests/teacher_donor_override_parity.rs` + +- [ ] **Step 1: Update the Stage 3 module doc comment** + +Replace lines 35-42: + +```rust +//! Stage 3 (`--mode teacher`): planted-leakance world — overrides the KAN +//! head's normalized leakance outputs at specified reaches with values from a +//! CSV, then runs the chunked eval loop and writes (a) synthetic daily gauge +//! observations as a zarr-v2 store and (b) a per-reach zeta answer key netCDF. +//! `--output` is not used in teacher mode. +//! cargo run --release --bin probe_zeta_gradient -- \ +//! --mode teacher \ +//! --config config/experiments/leakance_hourly_on.yaml \ +//! --checkpoint .ddrs/runs//checkpoints/epoch_5_mb_9 \ +//! --eval-days 1095 \ +//! --plant-file output/plant_sites.csv \ +//! --obs-output output/teacher_obs/ \ +//! --zeta-output output/teacher_zeta.nc +``` + +with: + +```rust +//! Stage 3 (`--mode teacher`): synthetic-twin ground-truth generator — runs +//! the chunked eval loop and writes synthetic daily gauge observations as a +//! zarr-v2 store. Two INDEPENDENT, orthogonal overrides may be combined or +//! used alone: +//! (a) planted-leakance world (`--plant-file` + `--zeta-output`) — overrides +//! the KAN head's normalized leakance outputs at specified reaches with +//! values from a CSV; also writes a per-reach zeta answer-key netCDF. +//! Requires `params.use_leakance: true`. +//! (b) routing-parameter donor world (`--donor-params-nc`, docs: +//! docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md) +//! — overrides ALL THREE of n/q_spatial/p_spatial from a +//! `dump_parameters::write_netcdf`-schema donor NetCDF (the same +//! mechanism `--mode eval-loss`'s "full-swap" composition uses). +//! `--output` is not used in teacher mode. +//! +//! Leakance-only (original usage, unchanged): +//! cargo run --release --bin probe_zeta_gradient -- \ +//! --mode teacher \ +//! --config config/experiments/leakance_hourly_on.yaml \ +//! --checkpoint .ddrs/runs//checkpoints/epoch_5_mb_9 \ +//! --eval-days 1095 \ +//! --plant-file output/plant_sites.csv \ +//! --obs-output output/teacher_obs/ \ +//! --zeta-output output/teacher_zeta.nc +//! +//! Routing-parameter donor only (no leakance, no --plant-file/--zeta-output): +//! cargo run --release --bin probe_zeta_gradient -- \ +//! --mode teacher --backend cpu \ +//! --config config/experiments/synthetic_n_teacher.yaml \ +//! --checkpoint .ddrs/runs/2026-07-16T02-22-14Z-train-and-test/checkpoints/epoch_5_mb_35 \ +//! --eval-days 999999 \ +//! --donor-params-nc output/synthetic_n/truth_leopold_maddock.nc \ +//! --obs-output output/synthetic_n/synthetic_obs/ +``` + +- [ ] **Step 2: Broaden the `--plant-file`/`--obs-output`/`--zeta-output`/`--donor-params-nc` doc comments** + +Replace (around line 202-212): + +```rust + /// teacher mode: plant CSV (comid,k_d_norm,d_gw_norm,factor_norm,...). + #[arg(long)] + plant_file: Option, + + /// teacher mode: directory for the synthetic-obs zarr-v2 store. + #[arg(long)] + obs_output: Option, + + /// teacher mode: answer-key netCDF (zeta accumulation over the window). + #[arg(long)] + zeta_output: Option, +``` + +with: + +```rust + /// teacher mode: plant CSV (comid,k_d_norm,d_gw_norm,factor_norm,...). + /// Optional — omit together with --zeta-output when only overriding + /// n/q_spatial/p_spatial via --donor-params-nc (no leakance planting). + #[arg(long)] + plant_file: Option, + + /// teacher mode: directory for the synthetic-obs zarr-v2 store. Always + /// required in teacher mode regardless of which override(s) are active. + #[arg(long)] + obs_output: Option, + + /// teacher mode: answer-key netCDF (zeta accumulation over the window). + /// Required IFF --plant-file is given (leakance-planting world only); + /// omit both together for a routing-parameter-donor-only teacher run. + #[arg(long)] + zeta_output: Option, +``` + +Replace the `donor_params_nc` doc comment (around line 228-234): + +```rust + /// eval-loss mode: donor NetCDF (dump_parameters::write_netcdf schema, + /// COMID-keyed, physical units) supplying n/q_spatial/p_spatial for any + /// composition other than "own". Required unless --compositions is "own" + /// only. + #[arg(long)] + donor_params_nc: Option, +``` + +with: + +```rust + /// eval-loss mode: donor NetCDF (dump_parameters::write_netcdf schema, + /// COMID-keyed, physical units) supplying n/q_spatial/p_spatial for any + /// composition other than "own". Required unless --compositions is "own" + /// only. + /// + /// teacher mode: same donor-NetCDF schema, but ALL THREE of + /// n/q_spatial/p_spatial are always overridden together (no partial + /// swap) — the synthetic-twin ground-truth generator (see + /// docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md). + /// Optional; independent of --plant-file/--zeta-output. + #[arg(long)] + donor_params_nc: Option, +``` + +- [ ] **Step 3: Allow `--donor-params-nc` in teacher mode** + +Modify the guard at lines 337-351 from: + +```rust + // --donor-params-nc/--compositions/--loss-output/--per-gauge-output are + // only valid in eval-loss mode. + if (cli.donor_params_nc.is_some() + || cli.compositions.is_some() + || cli.loss_output.is_some() + || cli.per_gauge_output.is_some()) + && mode != Mode::EvalLoss + { + return Err(format!( + "--donor-params-nc/--compositions/--loss-output/--per-gauge-output are only \ + valid in --mode eval-loss (got --mode {})", + cli.mode + ) + .into()); + } +``` + +to: + +```rust + // --compositions/--loss-output/--per-gauge-output are only valid in + // eval-loss mode. --donor-params-nc is ALSO valid in teacher mode (the + // synthetic-n routing-parameter donor override). + if (cli.compositions.is_some() || cli.loss_output.is_some() || cli.per_gauge_output.is_some()) + && mode != Mode::EvalLoss + { + return Err(format!( + "--compositions/--loss-output/--per-gauge-output are only \ + valid in --mode eval-loss (got --mode {})", + cli.mode + ) + .into()); + } + if cli.donor_params_nc.is_some() && mode != Mode::EvalLoss && mode != Mode::Teacher { + return Err(format!( + "--donor-params-nc is only valid in --mode eval-loss or --mode teacher (got --mode {})", + cli.mode + ) + .into()); + } +``` + +- [ ] **Step 4: Rewrite `run_teacher`'s setup section to make leakance optional** + +Replace lines 1058-1090 (function signature through `checkpoint` binding) from: + +```rust +fn run_teacher( + cfg: Config, + cli: Cli, + device: I::Device, +) -> Result<(), Box> { + // Large chunk size reduces disagg boundary-artifact density (left-clamp at chunk + // day 0 and precip right-clamp at chunk day C-1). With C=365 each artifact appears + // only ~14 times over 5115 teacher days (0.82%), vs 341 times with C=15 (20%). + // 70 GB RAM easily holds a 365-day AORC precip chunk (~2.3 GB). + const BATCH_SIZE_DAYS: usize = 365; + assert!(cfg.params.use_leakance, "teacher requires params.use_leakance: true"); + + let plants = parse_plant_file( + cli.plant_file.as_ref().ok_or("--plant-file is required in teacher mode")?, + )?; + let obs_dir = cli.obs_output.as_ref().ok_or("--obs-output is required in teacher mode")?; + if obs_dir.exists() && obs_dir.read_dir()?.next().is_some() { + return Err(format!( + "--obs-output {} already exists and is non-empty; remove it before \ + re-running teacher mode to prevent stale gauge data", + obs_dir.display() + ) + .into()); + } + let zeta_path = cli.zeta_output.as_ref().ok_or("--zeta-output is required in teacher mode")?; + if let Some(p) = zeta_path.parent() { + if !p.as_os_str().is_empty() && !p.exists() { + return Err( + format!("--zeta-output parent dir does not exist: {}", p.display()).into(), + ); + } + } + let checkpoint = cli.checkpoint.as_ref().ok_or("--checkpoint is required in teacher mode")?; +``` + +with: + +```rust +fn run_teacher( + cfg: Config, + cli: Cli, + device: I::Device, +) -> Result<(), Box> { + // Large chunk size reduces disagg boundary-artifact density (left-clamp at chunk + // day 0 and precip right-clamp at chunk day C-1). With C=365 each artifact appears + // only ~14 times over 5115 teacher days (0.82%), vs 341 times with C=15 (20%). + // 70 GB RAM easily holds a 365-day AORC precip chunk (~2.3 GB). + const BATCH_SIZE_DAYS: usize = 365; + + let plants = match &cli.plant_file { + Some(p) => parse_plant_file(p)?, + None => Vec::new(), + }; + let leakance_active = !plants.is_empty(); + if leakance_active { + assert!( + cfg.params.use_leakance, + "teacher requires params.use_leakance: true when --plant-file is given" + ); + } + + let obs_dir = cli.obs_output.as_ref().ok_or("--obs-output is required in teacher mode")?; + if obs_dir.exists() && obs_dir.read_dir()?.next().is_some() { + return Err(format!( + "--obs-output {} already exists and is non-empty; remove it before \ + re-running teacher mode to prevent stale gauge data", + obs_dir.display() + ) + .into()); + } + let zeta_path: Option = if leakance_active { + let p = cli + .zeta_output + .as_ref() + .ok_or("--zeta-output is required in teacher mode when --plant-file is given")?; + if let Some(parent) = p.parent() { + if !parent.as_os_str().is_empty() && !parent.exists() { + return Err( + format!("--zeta-output parent dir does not exist: {}", parent.display()) + .into(), + ); + } + } + Some(p.clone()) + } else { + None + }; + let checkpoint = cli.checkpoint.as_ref().ok_or("--checkpoint is required in teacher mode")?; +``` + +- [ ] **Step 5: Build the leakance override and the new param override conditionally** + +Find this block (a few lines after the network/plant-coverage checks, right before the chunked-forward loop): + +```rust + // Dense override vectors over the network's reach columns. + let comid_col: HashMap = + network_comids.iter().enumerate().map(|(i, &c)| (c, i)).collect(); + let n_reaches = network_comids.len(); + let mut ov = LeakanceOverride { + mask: vec![0.0; n_reaches], + k_d: vec![0.0; n_reaches], + d_gw: vec![0.0; n_reaches], + factor: vec![0.0; n_reaches], + }; + for &(comid, k, d, f) in &plants { + let col = comid_col[&comid]; + ov.mask[col] = 1.0; + ov.k_d[col] = k; + ov.d_gw[col] = d; + ov.factor[col] = f; + } +``` + +Replace with: + +```rust + // Dense override vectors over the network's reach columns. + let comid_col: HashMap = + network_comids.iter().enumerate().map(|(i, &c)| (c, i)).collect(); + let n_reaches = network_comids.len(); + + let leakance_ov: Option = if leakance_active { + let mut ov = LeakanceOverride { + mask: vec![0.0; n_reaches], + k_d: vec![0.0; n_reaches], + d_gw: vec![0.0; n_reaches], + factor: vec![0.0; n_reaches], + }; + for &(comid, k, d, f) in &plants { + let col = comid_col[&comid]; + ov.mask[col] = 1.0; + ov.k_d[col] = k; + ov.d_gw[col] = d; + ov.factor[col] = f; + } + Some(ov) + } else { + None + }; + + // Optional n/q_spatial/p_spatial donor override (the synthetic-n + // routing-parameter twin — docs/superpowers/specs/2026-07-22-synthetic-n- + // recoverability-design.md). Reuses the same --donor-params-nc / + // load_comid_field / gather_by_comid / physical_to_normalized machinery + // as --mode eval-loss's full-swap composition. + let param_ov: Option = match &cli.donor_params_nc { + Some(donor_path) => { + let log_space = + |name: &str| cfg.params.log_space_parameters.iter().any(|s| s == name); + let n_map = ddrs::data::load_comid_field(donor_path, "n")?; + let q_map = ddrs::data::load_comid_field(donor_path, "q_spatial")?; + let p_map = ddrs::data::load_comid_field(donor_path, "p_spatial")?; + let n_vals = gather_by_comid(&n_map, &network_comids)?; + let q_vals = gather_by_comid(&q_map, &network_comids)?; + let p_vals = gather_by_comid(&p_map, &network_comids)?; + Some(RoutingParamOverride { + n: Some(physical_to_normalized( + &n_vals, + cfg.params.parameter_ranges.n, + log_space("n"), + )), + q_spatial: Some(physical_to_normalized( + &q_vals, + cfg.params.parameter_ranges.q_spatial, + log_space("q_spatial"), + )), + p_spatial: Some(physical_to_normalized( + &p_vals, + cfg.params.parameter_ranges.p_spatial, + log_space("p_spatial"), + )), + }) + } + None => None, + }; +``` + +- [ ] **Step 6: Make zeta accumulation conditional and pass both overrides through** + +Find: + +```rust + let mut zeta_sink = ZetaSums::::new(); + let mut predictions_full = Array2::::zeros((n_all_gauges, n_hours)); +``` + +Replace with: + +```rust + let mut zeta_sink: Option> = leakance_active.then(ZetaSums::::new); + let mut predictions_full = Array2::::zeros((n_all_gauges, n_hours)); +``` + +Find the forward call inside the `while` loop: + +```rust + let runoff = forward_eval_reaches::( + &cfg, + &tensors, + &head, + &device, + false, + Some(&mut zeta_sink), + Some(&ov), + None, + ); +``` + +Replace with: + +```rust + let runoff = forward_eval_reaches::( + &cfg, + &tensors, + &head, + &device, + false, + zeta_sink.as_mut(), + leakance_ov.as_ref(), + param_ov.as_ref(), + ); +``` + +- [ ] **Step 7: Make the zeta answer-key write conditional** + +Find the block after the `while` loop (tau-trim/obs-write is unchanged above this): + +```rust + // Answer key: zeta means over the routed window. + let scale = 1.0_f32 / zeta_sink.steps as f32; + assert!(scale.is_finite() && scale > 0.0, "zeta accumulation empty — leakance inactive?"); + let mean_vec = |t: Option>| -> Vec { + (t.expect("zeta sums present") * scale).into_data().into_vec().unwrap() + }; + write_zeta_netcdf( + zeta_path, + &network_comids, + &mean_vec(zeta_sink.abs_sum), + &mean_vec(zeta_sink.net_sum), + &mean_vec(zeta_sink.depth_sum), + &mean_vec(zeta_sink.area_z_sum), + &mean_vec(zeta_sink.q_sum), + &format!("teacher:{}", checkpoint.display()), + ) + .map_err(|e| -> Box { e })?; + println!("answer key → {} ({} reaches)", zeta_path.display(), network_comids.len()); + Ok(()) +} +``` + +Replace with: + +```rust + // Answer key: zeta means over the routed window (only when leakance was + // planted — a routing-parameter-donor-only teacher run has no zeta term + // to report). + if let Some(sink) = zeta_sink { + let zeta_path = zeta_path.expect("zeta_path is set whenever leakance_active"); + let scale = 1.0_f32 / sink.steps as f32; + assert!(scale.is_finite() && scale > 0.0, "zeta accumulation empty — leakance inactive?"); + let mean_vec = |t: Option>| -> Vec { + (t.expect("zeta sums present") * scale).into_data().into_vec().unwrap() + }; + write_zeta_netcdf( + &zeta_path, + &network_comids, + &mean_vec(sink.abs_sum), + &mean_vec(sink.net_sum), + &mean_vec(sink.depth_sum), + &mean_vec(sink.area_z_sum), + &mean_vec(sink.q_sum), + &format!("teacher:{}", checkpoint.display()), + ) + .map_err(|e| -> Box { e })?; + println!("answer key → {} ({} reaches)", zeta_path.display(), network_comids.len()); + } else { + println!("no --plant-file given — skipping zeta answer-key write"); + } + Ok(()) +} +``` + +- [ ] **Step 8: Build and fix any compile errors** + +Run: `cargo build --release --bin probe_zeta_gradient` +Expected: clean build. If `ddrs::data::load_comid_field` isn't re-exported from the crate root used by this binary, check the existing `use` block at the top of the file (it already imports `ddrs::data::{load_comid_field, ...}` — line ~166) and call it as bare `load_comid_field(...)` instead of `ddrs::data::load_comid_field(...)` in Step 5. + +- [ ] **Step 9: Write the failing parity test** + +Create `tests/teacher_donor_override_parity.rs`: + +```rust +//! Parity gate for teacher mode's new n/q_spatial/p_spatial donor override +//! (docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md). +//! +//! Injecting a checkpoint's OWN dump_parameters output as the teacher's +//! donor field must reproduce the SAME synthetic gauge observations as +//! running teacher mode with no donor override at all — this exercises the +//! real donor-file I/O path (COMID keying, f32 round-trip, gather-by-comid) +//! that `RoutingParamOverride`'s unit tests in `src/training/forward.rs` +//! don't cover, mirroring `tests/eval_loss_own_parity.rs`'s pattern applied +//! to teacher mode. +//! +//! Skips gracefully if the real checkpoint/dump aren't present (machine-local, +//! gitignored) so CI on a clean checkout doesn't break. + +use std::path::{Path, PathBuf}; +use std::process::Command; + +const CONFIG: &str = "/home/tbindas/projects/ddrs/config/experiments/synthetic_n_teacher.yaml"; +const CHECKPOINT: &str = + "/home/tbindas/projects/ddrs/.ddrs/runs/2026-07-16T02-22-14Z-train-and-test/checkpoints/epoch_5_mb_35"; +const OWN_DUMP: &str = "/home/tbindas/projects/ddrs/output/synthetic_n/own_dump_for_parity_test.nc"; + +fn skip_if_missing(path: &str) -> Option { + let p = PathBuf::from(path); + p.exists().then_some(p) +} + +fn run_teacher(donor: Option<&Path>, obs_output: &Path) { + let mut cmd = Command::new(env!("CARGO_BIN_EXE_probe_zeta_gradient")); + cmd.args(["--mode", "teacher", "--backend", "cpu", "--config", CONFIG]) + .arg("--checkpoint") + .arg(CHECKPOINT) + .args(["--eval-days", "10"]) + .arg("--obs-output") + .arg(obs_output); + if let Some(d) = donor { + cmd.arg("--donor-params-nc").arg(d); + } + let status = cmd.status().expect("run probe_zeta_gradient"); + assert!(status.success(), "teacher mode run failed (donor={donor:?})"); +} + +#[test] +fn own_donor_reproduces_no_donor_synthetic_obs() { + let Some(config) = skip_if_missing(CONFIG) else { + eprintln!("skipping: {CONFIG} not present on this machine"); + return; + }; + let Some(checkpoint_head) = skip_if_missing(&format!("{CHECKPOINT}/head.mpk")) else { + eprintln!("skipping: {CHECKPOINT}/head.mpk not present on this machine"); + return; + }; + let Some(own_dump) = skip_if_missing(OWN_DUMP) else { + eprintln!( + "skipping: {OWN_DUMP} not present — generate via \ + `cargo run --release --bin dump_parameters -- --backend cpu \ + --config {CONFIG} --checkpoint {CHECKPOINT}/head --output {OWN_DUMP}`" + ); + return; + }; + drop((config, checkpoint_head)); + + let tmp = std::env::temp_dir().join(format!( + "teacher_donor_parity_{}", + std::process::id() + )); + let no_donor = tmp.join("no_donor"); + let with_donor = tmp.join("with_donor"); + std::fs::create_dir_all(&tmp).unwrap(); + + run_teacher(None, &no_donor); + run_teacher(Some(&own_dump), &with_donor); + + // Compare the raw zarr-v2 chunk bytes for a sample of gauges — the + // writer's chunk layout is deterministic given identical inputs, so + // byte-identical chunks prove the donor path reproduced the exact same + // routed discharge as the no-donor path. + let mut compared = 0; + for entry in std::fs::read_dir(&no_donor).unwrap() { + let entry = entry.unwrap(); + if !entry.path().is_dir() { + continue; + } + let gauge = entry.file_name(); + let a = std::fs::read(entry.path().join("0")).unwrap(); + let b = std::fs::read(with_donor.join(&gauge).join("0")).unwrap(); + assert_eq!(a, b, "gauge {gauge:?}: own-donor chunk diverged from no-donor chunk"); + compared += 1; + } + assert!(compared > 0, "no gauge chunks found to compare — obs writer produced nothing"); + eprintln!("compared {compared} gauges — own-donor teacher run byte-identical to no-donor"); + + std::fs::remove_dir_all(&tmp).ok(); +} +``` + +- [ ] **Step 10: Run the test to verify it currently skips (no fixtures yet) or fails** + +Run: `cargo test --test teacher_donor_override_parity -- --nocapture` +Expected: test passes trivially by skipping (prints "skipping: ... not present"), since `config/experiments/synthetic_n_teacher.yaml` doesn't exist yet (Task 4) and `OWN_DUMP` doesn't exist yet. This confirms the test compiles and the skip path works; the real assertion is exercised once Task 4's config and a checkpoint dump exist (re-run at the end of Task 4). + +- [ ] **Step 11: Commit** + +```bash +git add src/bin/probe_zeta_gradient.rs tests/teacher_donor_override_parity.rs +git commit -m "feat(probe): teacher mode gains an optional n/q/p donor override + +Reuses eval-loss mode's load_comid_field/gather_by_comid/RoutingParamOverride +machinery so teacher mode can generate synthetic-twin ground truth for the +routing parameters, not just leakance. --plant-file/--zeta-output/use_leakance +are now independent of the new --donor-params-nc path." +``` + +--- + +### Task 2: Consensus-geometry generation script + +**Files:** +- Create: `scripts/synthetic_n_consensus_geometry.py` + +- [ ] **Step 1: Write the script** + +```python +"""Consensus geometry for the synthetic-n recoverability experiment +(docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md). + +Runs `dump_parameters` against the 4 already-converged real-Q'-source +checkpoints from this campaign, then computes the per-COMID MEDIAN +q_spatial/p_spatial across them — the "most common trained value trend", +used as the FIXED geometry truth for every synthetic-n student. + +Run from ddrs-py's venv: + cd ddrs-py && uv run python ../scripts/synthetic_n_consensus_geometry.py +""" +from __future__ import annotations + +import subprocess +import sys +from pathlib import Path + +import numpy as np +import xarray as xr + +REPO = Path(__file__).resolve().parent.parent +OUT_DIR = REPO / "output/synthetic_n" +OUT_DIR.mkdir(parents=True, exist_ok=True) + +CHECKPOINTS = [ + { + "label": "aorc2f_distributed", + "config": REPO / ".ddrs/runs/2026-07-16T02-22-14Z-train-and-test/config.yaml", + "checkpoint": REPO / ".ddrs/runs/2026-07-16T02-22-14Z-train-and-test/checkpoints/epoch_5_mb_35/head", + }, + { + "label": "aorc2f_lumped", + "config": REPO / ".ddrs/runs/2026-07-16T02-23-20Z-train-and-test/config.yaml", + "checkpoint": REPO / ".ddrs/runs/2026-07-16T02-23-20Z-train-and-test/checkpoints/epoch_5_mb_35/head", + }, + { + "label": "daily_lstm", + "config": REPO / ".ddrs/runs/2026-07-16T11-31-50Z-train-and-test/config.yaml", + "checkpoint": REPO / ".ddrs/runs/2026-07-16T11-31-50Z-train-and-test/checkpoints/epoch_5_mb_35/head", + }, + { + "label": "hourly_lstm", + "config": REPO / ".ddrs/runs/2026-07-16T11-31-52Z-train-and-test/config.yaml", + "checkpoint": REPO / ".ddrs/runs/2026-07-16T11-31-52Z-train-and-test/checkpoints/epoch_5_mb_35/head", + }, +] + + +def dump_one(ckpt: dict) -> Path: + out = OUT_DIR / f"{ckpt['label']}_kan_parameters.nc" + if out.exists(): + print(f"{out} already exists, skipping dump_parameters re-run") + return out + cmd = [ + "cargo", "run", "--release", "--bin", "dump_parameters", "--", + "--backend", "cpu", + "--config", str(ckpt["config"]), + "--checkpoint", str(ckpt["checkpoint"]), + "--output", str(out), + ] + print("running:", " ".join(cmd)) + subprocess.run(cmd, cwd=REPO, check=True) + return out + + +def main() -> None: + dumps = [dump_one(c) for c in CHECKPOINTS] + + datasets = [xr.open_dataset(d) for d in dumps] + comids_0 = datasets[0]["COMID"].values + for d, ds in zip(dumps, datasets): + if not np.array_equal(np.sort(ds["COMID"].values), np.sort(comids_0)): + raise SystemExit( + f"{d}: COMID set differs from {dumps[0]} — cannot take a per-COMID " + "median across checkpoints with different networks" + ) + + # Re-index every dump to dumps[0]'s COMID order before stacking, since + # dump_parameters row order isn't guaranteed identical across runs. + order = comids_0 + q_stack = np.stack([ds.set_index(COMID="COMID").sel(COMID=order)["q_spatial"].values for ds in datasets]) + p_stack = np.stack([ds.set_index(COMID="COMID").sel(COMID=order)["p_spatial"].values for ds in datasets]) + + q_median = np.median(q_stack, axis=0).astype(np.float32) + p_median = np.median(p_stack, axis=0).astype(np.float32) + + out = OUT_DIR / "consensus_geometry.nc" + xr.Dataset( + { + "q_spatial": ("COMID", q_median), + "p_spatial": ("COMID", p_median), + }, + coords={"COMID": order}, + ).to_netcdf(out) + print(f"consensus geometry ({len(order)} reaches) -> {out}") + + +if __name__ == "__main__": + main() +``` + +- [ ] **Step 2: Run it** + +Run: `cd ddrs-py && uv run python ../scripts/synthetic_n_consensus_geometry.py` +Expected: prints 4 `cargo run --bin dump_parameters` invocations (each a single CPU forward pass, minutes not hours), then `consensus geometry ( reaches) -> .../output/synthetic_n/consensus_geometry.nc`. + +- [ ] **Step 3: Commit** + +```bash +git add scripts/synthetic_n_consensus_geometry.py +git commit -m "feat(scripts): consensus-geometry generator for synthetic-n experiment" +``` + +--- + +### Task 3: Truth-n field generation script + +**Files:** +- Create: `scripts/synthetic_n_truth_fields.py` + +- [ ] **Step 1: Write the script** + +```python +"""Prescribed truth-n fields for the synthetic-n recoverability experiment +(docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md §1). + +Combines each prescribed n field with the fixed consensus geometry +(scripts/synthetic_n_consensus_geometry.py) into a single donor NetCDF per +variant, in the dump_parameters::write_netcdf schema (COMID dim, f32 vars) +that probe_zeta_gradient's --mode teacher --donor-params-nc reads. + +Run from ddrs-py's venv, AFTER synthetic_n_consensus_geometry.py: + cd ddrs-py && uv run python ../scripts/synthetic_n_truth_fields.py +""" +from __future__ import annotations + +from pathlib import Path + +import numpy as np +import xarray as xr + +REPO = Path(__file__).resolve().parent.parent +OUT_DIR = REPO / "output/synthetic_n" +ATTRS = REPO.parent / "ddr/data/merit_global_attributes_v2.nc" + +N_LO, N_HI = 0.015, 0.15 +N_CENTER = 0.08 +SEED = 42 + + +def leopold_maddock_n(log10_uparea: np.ndarray) -> np.ndarray: + """Decreasing power law: n = clip(N_CENTER * (uparea/uparea_median)^-b, N_LO, N_HI). + + b is calibrated so the field spans roughly [N_LO, N_HI] across the real + CONUS log10_uparea distribution (see design spec §1 footnote — a tuning + detail, not a design fork). + """ + median = np.median(log10_uparea) + b = 0.15 + n = N_CENTER * 10.0 ** (-b * (log10_uparea - median)) + return np.clip(n, N_LO, N_HI).astype(np.float32) + + +def gaussian_noise_n(n_reaches: int) -> np.ndarray: + """IID Gaussian field, no spatial structure — the null control.""" + rng = np.random.default_rng(SEED) + spread = (N_HI - N_LO) / 4.0 # ~2 std devs to each bound from N_CENTER + n = rng.normal(loc=N_CENTER, scale=spread, size=n_reaches) + return np.clip(n, N_LO, N_HI).astype(np.float32) + + +def main() -> None: + geom = xr.open_dataset(OUT_DIR / "consensus_geometry.nc") + attrs = xr.open_dataset(ATTRS) + attrs_by_comid = attrs.set_index(COMID="COMID").sel(COMID=geom["COMID"].values) + log10_uparea = attrs_by_comid["log10_uparea"].values.astype(np.float64) + + variants = { + "truth_leopold_maddock.nc": leopold_maddock_n(log10_uparea), + "truth_gaussian.nc": gaussian_noise_n(len(geom["COMID"])), + } + + for filename, n_vals in variants.items(): + out = OUT_DIR / filename + xr.Dataset( + { + "n": ("COMID", n_vals), + "q_spatial": ("COMID", geom["q_spatial"].values), + "p_spatial": ("COMID", geom["p_spatial"].values), + }, + coords={"COMID": geom["COMID"].values}, + ).to_netcdf(out) + print( + f"{out}: n range [{n_vals.min():.4f}, {n_vals.max():.4f}], " + f"median {np.median(n_vals):.4f} ({len(n_vals)} reaches)" + ) + + +if __name__ == "__main__": + main() +``` + +- [ ] **Step 2: Run it** + +Run: `cd ddrs-py && uv run python ../scripts/synthetic_n_truth_fields.py` +Expected: two lines reporting `output/synthetic_n/truth_leopold_maddock.nc` and `output/synthetic_n/truth_gaussian.nc`, each with an n range inside `[0.015, 0.15]`. + +- [ ] **Step 3: Sanity-check the Leopold-Maddock slope sign** + +Run: +```bash +cd ddrs-py && uv run python -c " +import numpy as np, xarray as xr +from pathlib import Path +geom = xr.open_dataset('../output/synthetic_n/consensus_geometry.nc') +truth = xr.open_dataset('../output/synthetic_n/truth_leopold_maddock.nc') +attrs = xr.open_dataset('/home/tbindas/projects/ddr/data/merit_global_attributes_v2.nc') +a = attrs.set_index(COMID='COMID').sel(COMID=geom['COMID'].values) +slope = np.polyfit(a['log10_uparea'].values, truth['n'].values, 1)[0] +print('fitted slope (should be NEGATIVE — n decreases downstream):', slope) +assert slope < 0, 'Leopold-Maddock truth field has the wrong sign!' +" +``` +Expected: prints a negative slope value, assertion passes. + +- [ ] **Step 4: Commit** + +```bash +git add scripts/synthetic_n_truth_fields.py +git commit -m "feat(scripts): prescribed truth-n fields (Leopold-Maddock + Gaussian null)" +``` + +--- + +### Task 4: Teacher config and teacher run + +**Files:** +- Create: `config/experiments/synthetic_n_teacher.yaml` + +- [ ] **Step 1: Write the config** + +Base it on `config/experiments/aorc2f_distributed_frozen_chunk1.yaml` (read it first to copy `kan_head`/`params`/`experiment` blocks verbatim), changing only `data_sources.streamflow` to the standard benchmark store and widening `testing:` to span the full simulation window with 1-day padding on each side (matching the `recoverability_teacher.yaml` padding convention so tau-trim + last-day-drop produce exactly the 1981/10/01-2010/09/30 axis the students need): + +```yaml +# synthetic_n_teacher.yaml — synthetic-n recoverability ground-truth generator. +# GENERATED from aorc2f_distributed_frozen_chunk1.yaml — teacher world: full +# simulation window, standard benchmark Q' store, no leakance. +# Spec: docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md + +mode: training +workflow: train-and-test +geodataset: merit +seed: 42 +np_seed: 42 + +data_sources: + attributes: /home/tbindas/projects/ddr/data/merit_global_attributes_v2.nc + conus_adjacency: /home/tbindas/projects/ddr/data/merit_conus_adjacency.zarr + gages_adjacency: /home/tbindas/projects/ddr/data/merit_gages_conus_adjacency.zarr + streamflow: /mnt/ssd1/data/icechunk/merit_dhbv2_UH_retrospective.ic + observations: /mnt/ssd1/data/icechunk/usgs_daily_observations + gages: /home/tbindas/projects/ddr/references/gage_info/gages_3000.csv + aorc_precip: /mnt/ssd1/data/aorc/merit_unit_catchments.zarr + +experiment: + batch_size: 64 + start_time: 1981/10/01 + end_time: 1995/09/30 + epochs: 5 + rho: 90 + shuffle: true + warmup: 5 + learning_rate: + 1: 0.001 + 3: 0.0005 + grad_clip_max_norm: 1.0 + +kan_head: + hidden_size: 21 + num_hidden_layers: 2 + grid: 50 + k: 2 + input_var_names: + - SoilGrids1km_clay + - aridity + - meanelevation + - meanP + - NDVI + - meanslope + - log10_uparea + - SoilGrids1km_sand + - ETPOT_Hargr + - Porosity + learnable_parameters: + - n + - q_spatial + - p_spatial + disaggregation: + hidden_size: 16 + num_hidden_layers: 2 + grid: 20 + k: 3 + chunk_days: 1 + freeze: true + pretrained_checkpoint: /home/tbindas/projects/ddrs/output/disagg_pretrain/capacity_chunk1.mpk + +params: + use_leakance: false + parameter_ranges: + n: [0.015, 0.25] + q_spatial: [0.0, 1.0] + p_spatial: [1.0, 200.0] + attribute_minimums: + discharge: 1.0e-4 + slope: 1.0e-3 + velocity: 0.01 + depth: 0.01 + bottom_width: 0.01 + defaults: + p_spatial: 21.0 + log_space_parameters: + - p_spatial + sparse_solver: cpu + use_cuda_graphs: false + +# 1-day padding each side of the union of both student axes (1981/10/01- +# 1995/09/30 train + 1995/10/01-2010/09/30 test), so tau-trim + the +# teacher's last-day drop produce synthetic obs covering EXACTLY +# 1981/10/01-2010/09/30 — matching recoverability_teacher.yaml's padding +# convention. +testing: + start_time: 1981/09/30 + end_time: 2010/10/01 + batch_size: 15 + rho: null +``` + +Note: check the real `aorc2f_distributed_frozen_chunk1.yaml`'s `kan_head.disaggregation` block for the exact `num_hidden_layers`/`grid`/`k`/`chunk_days`/`pretrained_checkpoint` values before finalizing — copy them verbatim rather than retyping from memory, since a mismatch will fail config load against the frozen checkpoint's architecture. + +- [ ] **Step 2: Validate the config parses** + +Run: `cargo run --release --bin ddrs -- --config config/experiments/synthetic_n_teacher.yaml --workspace /tmp/synthetic_n_teacher_validate plan --workflow train-and-test` +Expected: exits 0 (or fails only on the GPU probe, which is irrelevant here — this step just validates YAML/schema, not that training will run). If it fails on schema, fix the config and retry. + +- [ ] **Step 3: Re-run the Task 1 parity test now that the config exists** + +Run: +```bash +cargo run --release --bin dump_parameters -- --backend cpu \ + --config config/experiments/synthetic_n_teacher.yaml \ + --checkpoint .ddrs/runs/2026-07-16T02-22-14Z-train-and-test/checkpoints/epoch_5_mb_35/head \ + --output output/synthetic_n/own_dump_for_parity_test.nc +cargo test --release --test teacher_donor_override_parity -- --nocapture +``` +Expected: `own_donor_reproduces_no_donor_synthetic_obs` runs for real this time (not skipped) and PASSES — "compared N gauges — own-donor teacher run byte-identical to no-donor". + +- [ ] **Step 4: Commit** + +```bash +git add config/experiments/synthetic_n_teacher.yaml +git commit -m "feat(config): synthetic-n teacher config (full-window, standard Q' store)" +``` + +- [ ] **Step 5: Launch the Phase-1 teacher run (Leopold-Maddock truth n)** + +This is a long-running full-CONUS 29-year continuous forward pass on CPU — launch in the background and monitor. + +Run: +```bash +mkdir -p output/synthetic_n/logs +nohup cargo run --release --bin probe_zeta_gradient -- \ + --mode teacher --backend cpu \ + --config config/experiments/synthetic_n_teacher.yaml \ + --checkpoint .ddrs/runs/2026-07-16T02-22-14Z-train-and-test/checkpoints/epoch_5_mb_35 \ + --eval-days 999999 \ + --donor-params-nc output/synthetic_n/truth_leopold_maddock.nc \ + --obs-output output/synthetic_n/synthetic_obs_lm \ + > output/synthetic_n/logs/teacher_lm.log 2>&1 & +``` +Expected: log shows `teacher: 0 plants, 2365 gauges, reaches, days` then periodic `chunk k/n_chunks_total` lines, ending with `synthetic obs → output/synthetic_n/synthetic_obs_lm (2365 gauges, days from 1981-10-01)` and `no --plant-file given — skipping zeta answer-key write`. Wall-time: expect several hours (the leakance recoverability teacher's 14-year window took ~2.6h CPU; this is a ~29-year window over the same chunking, so budget roughly double). + +- [ ] **Step 6: Verify the synthetic obs store** + +Run: +```bash +cd ddrs-py && uv run python -c " +import xarray as xr +import zarr +g = zarr.open_group('../output/synthetic_n/synthetic_obs_lm', mode='r') +print('gauges:', len(list(g.group_keys()))) +import numpy as np +sample = list(g.group_keys())[0] +arr = g[sample]['0'][:] +print(sample, 'len', len(arr), 'finite fraction', np.isfinite(arr).mean()) +" +``` +Expected: `gauges: 2365`, and the sample gauge array's finite fraction should be less than 1.0 (NaN-padded before 1981-10-01) but the tail should be finite daily values. + +--- + +### Task 5: Student configs + +**Files:** +- Create: `config/experiments/synthetic_n_student_distributed.yaml` +- Create: `config/experiments/synthetic_n_student_lumped.yaml` +- Create: `config/experiments/synthetic_n_student_daily_lstm.yaml` +- Create: `config/experiments/synthetic_n_student_hourly_lstm.yaml` + +- [ ] **Step 1: Create each student config as an exact copy of its real campaign counterpart** + +```bash +cp config/experiments/aorc2f_distributed_frozen_chunk1.yaml config/experiments/synthetic_n_student_distributed.yaml +cp config/experiments/aorc2f_lumped_frozen_chunk1.yaml config/experiments/synthetic_n_student_lumped.yaml +cp config/experiments/lstm_daily_frozen_chunk1.yaml config/experiments/synthetic_n_student_daily_lstm.yaml +cp config/experiments/lstm_hourly_native.yaml config/experiments/synthetic_n_student_hourly_lstm.yaml +``` + +- [ ] **Step 2: Repoint `data_sources.observations` in all 4 to the synthetic obs store** + +For each of the 4 new files, change the `data_sources.observations:` line (originally `/mnt/ssd1/data/icechunk/usgs_daily_observations`) to: + +```yaml + observations: /home/tbindas/projects/ddrs/output/synthetic_n/synthetic_obs_lm +``` + +Use `Edit` on each file (do not touch any other line — `streamflow`, `kan_head`, `params`, `experiment` stay exactly as the real campaign's own arms, since the whole point is that everything except the forcing and the observation target is identical across students). + +- [ ] **Step 3: Validate each config parses** + +```bash +for f in synthetic_n_student_distributed synthetic_n_student_lumped synthetic_n_student_daily_lstm synthetic_n_student_hourly_lstm; do + echo "=== $f ===" + cargo run --release --bin ddrs -- --config config/experiments/$f.yaml \ + --workspace /tmp/${f}_validate plan --workflow train-and-test || true +done +``` +Expected: each either exits 0 or fails only on the GPU-probe / real-data-source-availability step (irrelevant to config schema validity) — no YAML/schema errors. + +- [ ] **Step 4: Commit** + +```bash +git add config/experiments/synthetic_n_student_*.yaml +git commit -m "feat(config): 4 synthetic-n student configs (real Q' sources, synthetic obs)" +``` + +--- + +### Task 6: Launch the 4 students and dump their recovered parameters + +**Files:** none (execution only) + +- [ ] **Step 1: Launch all 4 students in parallel, isolated workspaces, CPU backend** + +```bash +mkdir -p output/synthetic_n/logs +for arm in distributed lumped daily_lstm hourly_lstm; do + mkdir -p .ddrs-synthetic-n-$arm + nohup cargo run --release --bin ddrs -- \ + --config config/experiments/synthetic_n_student_$arm.yaml \ + --workspace /home/tbindas/projects/ddrs/.ddrs-synthetic-n-$arm \ + run --workflow train-and-test --backend cpu \ + > output/synthetic_n/logs/student_$arm.log 2>&1 & +done +wait +``` +Expected: each log ends with a completed `train-and-test` workflow and a manifest reporting `epochs_completed: 5`. Wall-time comparable to this campaign's own CPU arms (hours; the lumped arm took ~8h26m end-to-end) — monitor via `tail -f output/synthetic_n/logs/student_*.log`. + +- [ ] **Step 2: Locate each student's final checkpoint and dump parameters** + +```bash +mkdir -p output/synthetic_n +for arm in distributed lumped daily_lstm hourly_lstm; do + RUN_ID=$(ls -t .ddrs-synthetic-n-$arm/runs/ | head -1) + CKPT=$(ls -d .ddrs-synthetic-n-$arm/runs/$RUN_ID/checkpoints/epoch_5_mb_* | sort -V | tail -1) + echo "$arm -> $CKPT" + cargo run --release --bin dump_parameters -- --backend cpu \ + --config config/experiments/synthetic_n_student_$arm.yaml \ + --checkpoint "$CKPT/head" \ + --output output/synthetic_n/recovered_$arm.nc +done +``` +Expected: 4 NetCDF files `output/synthetic_n/recovered_{distributed,lumped,daily_lstm,hourly_lstm}.nc`, each with `n`/`q_spatial`/`p_spatial` per COMID. + +--- + +### Task 7: Analysis script and findings + +**Files:** +- Create: `scripts/synthetic_n_recoverability_analysis.py` + +- [ ] **Step 1: Write the script** + +```python +"""Pre-registered verdicts S1-S5 for the synthetic-n recoverability +experiment (docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md §3). + +Run from ddrs-py's venv, after all 4 students' dump_parameters outputs exist: + cd ddrs-py && uv run python ../scripts/synthetic_n_recoverability_analysis.py +""" +from __future__ import annotations + +from pathlib import Path + +import numpy as np +import pandas as pd +import xarray as xr +from scipy.stats import pearsonr + +REPO = Path(__file__).resolve().parent.parent +OUT_DIR = REPO / "output/synthetic_n" +ATTRS = REPO.parent / "ddr/data/merit_global_attributes_v2.nc" + +ARMS = ["distributed", "lumped", "daily_lstm", "hourly_lstm"] + +# Mean daily Q' volume ratio of each real store vs the standard benchmark +# store, for S5 — filled in manually from `ddrs import --dry-run` / +# icechunk inspection once available; None disables S5 for that arm. S5 is +# WIRED IN below (pearsonr against n_errors) but only computed when at +# least 3 arms have a non-None ratio — with only 4 arms total, fewer points +# than that isn't a meaningful correlation, so it's reported as +# "not computed", never silently skipped without saying why. +VOLUME_RATIO_VS_TRUTH: dict[str, float | None] = { + "distributed": None, + "lumped": None, + "daily_lstm": None, + "hourly_lstm": None, +} + + +def median_abs_error(recovered: np.ndarray, truth: np.ndarray) -> float: + return float(np.median(np.abs(recovered - truth))) + + +def fitted_slope(log10_uparea: np.ndarray, n: np.ndarray) -> float: + return float(np.polyfit(log10_uparea, n, 1)[0]) + + +def main() -> None: + truth = xr.open_dataset(OUT_DIR / "truth_leopold_maddock.nc") + truth_comids = truth["COMID"].values + truth_n = truth["n"].values + truth_q = truth["q_spatial"].values + truth_p = truth["p_spatial"].values + + attrs = xr.open_dataset(ATTRS).set_index(COMID="COMID").sel(COMID=truth_comids) + log10_uparea = attrs["log10_uparea"].values.astype(np.float64) + true_slope = fitted_slope(log10_uparea, truth_n) + + rows = [] + n_errors, geom_errors = {}, {} + for arm in ARMS: + rec = xr.open_dataset(OUT_DIR / f"recovered_{arm}.nc").set_index(COMID="COMID").sel( + COMID=truth_comids + ) + n_err = median_abs_error(rec["n"].values, truth_n) + q_err = median_abs_error(rec["q_spatial"].values, truth_q) + p_err = median_abs_error(rec["p_spatial"].values, truth_p) + slope = fitted_slope(log10_uparea, rec["n"].values) + n_errors[arm] = n_err + geom_errors[arm] = (q_err + p_err) / 2.0 + rows.append( + { + "arm": arm, + "n_median_abs_error": n_err, + "q_median_abs_error": q_err, + "p_median_abs_error": p_err, + "recovered_n_slope": slope, + "true_n_slope": true_slope, + "slope_sign_flipped": bool(slope > 0 and true_slope < 0), + } + ) + + df = pd.DataFrame(rows) + csv_path = OUT_DIR / "recoverability_rows.csv" + df.to_csv(csv_path, index=False) + + n_spread = max(n_errors.values()) - min(n_errors.values()) + geom_spread = max(geom_errors.values()) - min(geom_errors.values()) + s4_ratio = n_spread / geom_spread if geom_spread > 0 else float("inf") + + any_flip = df["slope_sign_flipped"].any() + + # S5: pearsonr of n_errors against VOLUME_RATIO_VS_TRUTH, restricted to + # arms with a filled-in ratio. Needs >=3 points to be worth reporting at + # all (spec §3: "only 4 data points" — 2 points is a line, not a + # correlation). Prints an explicit reason when it can't run, rather than + # silently doing nothing. + filled = {a: r for a, r in VOLUME_RATIO_VS_TRUTH.items() if r is not None} + if len(filled) >= 3: + arms_with_ratio = list(filled.keys()) + s5_r, s5_p = pearsonr( + [n_errors[a] for a in arms_with_ratio], + [filled[a] for a in arms_with_ratio], + ) + s5_line = f" [S5] pearson r={s5_r:.3f} (p={s5_p:.3f}) over {len(filled)} arms: {filled}" + else: + s5_r = s5_p = None + s5_line = ( + f" [S5] not computed — only {len(filled)}/{len(ARMS)} arms have a filled-in " + "VOLUME_RATIO_VS_TRUTH (need >=3). Fill in the dict from `ddrs import --dry-run` " + "/ icechunk mean-daily-volume inspection per arm to enable this." + ) + + print(df.to_string(index=False)) + print() + print("========================================================================") + print("VERDICTS (bars pre-registered in the design spec)") + print("========================================================================") + print(f" [S1] n median-abs-error per arm: {n_errors}") + print(f" [S2] true slope={true_slope:.5f}; any arm sign-flipped positive: {any_flip}") + print(f" [S3] geometry median-abs-error per arm: {geom_errors}") + print(f" [S4 {'PASS' if s4_ratio >= 3 else 'FAIL'}] n-spread/geom-spread = {s4_ratio:.2f} (bar: >=3)") + print(s5_line) + print(f" HEADLINE: {'PASS' if (s4_ratio >= 3 and any_flip) else 'FAIL'} " + "(requires S4>=3x AND at least one slope sign flip; S5 is supporting evidence only)") + print() + print(f"per-arm rows -> {csv_path}") + + +if __name__ == "__main__": + main() +``` + +- [ ] **Step 2: Confirm `scipy` is available in `ddrs-py`, add it if not** + +Run: `cd ddrs-py && uv run python -c "import scipy; print(scipy.__version__)"` +Expected: prints a version. If it errors with `ModuleNotFoundError`, run `cd ddrs-py && uv add scipy` first, then retry. + +- [ ] **Step 3: Run it** + +Run: `cd ddrs-py && uv run python ../scripts/synthetic_n_recoverability_analysis.py` +Expected: a printed per-arm table, then the VERDICTS block (including the `[S5]` line — either a pearson r/p or the explicit "not computed" message), then `per-arm rows -> .../output/synthetic_n/recoverability_rows.csv`. + +- [ ] **Step 4: Write the findings doc** + +Create `docs/2026-07-22-synthetic-n-recoverability-findings.md` following this campaign's established findings-doc structure (see `docs/2026-07-16-aorc2f-wave1-findings.md` for the template: what this tests, execution notes, results table, interpretation). Populate it with the actual VERDICTS block output and the per-arm CSV, and state explicitly whether the headline S4/slope-flip bar passed. + +The findings doc MUST include these two notes explicitly (design spec §6 concern 1 and §1's naming note — do not silently drop either): + +1. **Disagg-head confound caveat on S3.** State plainly that geometry + (q_spatial/p_spatial) recovery error being small/consistent across arms + is NOT independent proof that geometry is physically identifiable + regardless of Q'-source bias — every arm (teacher and all 4 students) + shares the SAME frozen capacity-boosted chunk1 disagg head, so a latent + disagg-head effect on q/p would look identical to genuine geometry + robustness. This experiment's S3 result should be reported as + "consistent under a shared, frozen disagg head," not as "geometry is + identifiable in general." +2. **Naming/campaign-provenance note.** This experiment's 4 arms + (`aorc2f_distributed`/`aorc2f_lumped`/`daily_lstm`/`hourly_lstm`, from + the 2026-07-16 AORC2F/LSTM wave campaign) are a DIFFERENT arm set from + the pre-registered LSTM-equifinality campaign's R1/R2/R3 naming (the + paper's `tab:arms` table). State this explicitly and do not let the two + numbering schemes bleed together in any table or cross-reference. + +- [ ] **Step 5: Decide on Phase 2 (Gaussian-noise confirmatory run)** + +If the headline verdict PASSED (S4 ≥ 3× and at least one slope flip): identify the 2 arms with the largest `n_median_abs_error` from `recoverability_rows.csv`, then repeat Task 4 Step 5 - Task 6 for just those 2 arms using `--donor-params-nc output/synthetic_n/truth_gaussian.nc` and a fresh `--obs-output output/synthetic_n/synthetic_obs_gaussian`, producing `config/experiments/synthetic_n_student_{arm}_gaussian.yaml` variants (copy + repoint observations). Extend the analysis script with a `--truth gaussian` mode, or a second invocation pointed at the Gaussian truth/recovered files, before re-running Step 2 for those 2 arms only. + +If the headline verdict FAILED: do not run Phase 2 — document in the findings doc why (e.g. n_spread not distinguishable from geometry spread, or the sign never flips), and note this as informative for, but not conclusive against, the standing equifinality campaign's own registered verdict (per design spec §8 — this experiment does not amend that campaign's results). + +- [ ] **Step 6: Commit** + +```bash +git add scripts/synthetic_n_recoverability_analysis.py docs/2026-07-22-synthetic-n-recoverability-findings.md output/synthetic_n/recoverability_rows.csv +git commit -m "docs: synthetic-n recoverability findings across the 4 real Q' sources" +``` + +--- + +## Self-Review Notes + +**Spec coverage:** §2 architecture (teacher override, students, measurement) → Tasks 1, 4, 5, 6. §3 verdicts S1-S5 → Task 7. §4 components 1-7 → Tasks 1-7 map 1:1 except component 7 (findings report) folded into Task 7 Step 3. §5 execution sequence/staging → Tasks 4-7, with Phase 2 gated in Task 7 Step 4. §6 concerns (disagg-head mismatch, cold-start noise floor, 8-run cost, consensus-geometry provenance) → addressed structurally (Task 2 uses the 4 real checkpoints' own disagg-head architecture; Task 6 launches cold; Task 7 Step 4 stages Phase 2 conditionally) and should be called out explicitly in the Task 7 findings doc. §7 testing → Task 1's parity test; no `Backward`/`src/routing`/`src/sparse.rs` changes anywhere in this plan, so `compare_ddr_sandbox` is not re-run as a gate (nothing in its blast radius changed). + +**Placeholder scan:** no TBD/TODO. `VOLUME_RATIO_VS_TRUTH` in Task 7's script starts `None`-filled (the real per-arm volume ratios aren't known until someone inspects the icechunk stores), but S5 IS wired in — it computes `pearsonr` over whichever arms have a filled-in ratio once `>= 3` are present, and otherwise prints an explicit "not computed, need >=3, here's how to fill it in" line rather than silently doing nothing. (An earlier draft of this plan left the dict unread by `main()` — a real dead-code bug flagged in review — fixed here.) + +**Type consistency:** `RoutingParamOverride { n, q_spatial, p_spatial }` field names used identically in Task 1's Rust code and match the struct defined at `src/training/forward.rs:356-360`. `load_comid_field`/`gather_by_comid`/`physical_to_normalized` signatures used in Task 1 match their existing definitions read from `src/data/store/param_dump.rs:18` and `src/bin/probe_zeta_gradient.rs:1613`/`src/training/forward.rs:72`. Python scripts consistently use `COMID` as the NetCDF dim/coord name and `n`/`q_spatial`/`p_spatial` as var names across Tasks 2, 3, 6, 7. diff --git a/docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md b/docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md new file mode 100644 index 0000000..15bcba7 --- /dev/null +++ b/docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md @@ -0,0 +1,258 @@ +# Synthetic n-recoverability across real Q' sources — design + +Date: 2026-07-22 +Prior instruments: +`docs/2026-07-16-aorc2f-wave1-findings.md`, `docs/2026-07-16-wave2-cross-wave-findings.md` +(this campaign's 4 real-Q'-source arms), +`docs/2026-07-04-synthetic-recoverability-findings.md` + +`docs/superpowers/specs/2026-07-03-synthetic-recoverability-design.md` +(the leakance positive-control pattern this design generalizes), +`/tmp/experiment-handoff-lstm-equifinality-parameterization-patterns.md` +(the standing selective-equifinality hypothesis this experiment tests). + +## 1. Question + +The separate, pre-registered LSTM-equifinality campaign found — in REAL data, +with REAL (noisy, incomplete) USGS observations — that Manning's n diverges +substantially across differently-sourced Q' inputs (relative spread 0.4512, +the largest of any learned quantity) while channel geometry (q_spatial, +p_spatial) is comparatively stable, and that two of three arms recovered a +roughness-INCREASES-downstream slope opposite classical Leopold-Maddock +hydraulic geometry. That campaign's verdict was INCONCLUSIVE: real +observation noise and real physical heterogeneity across basins are +confounds that cannot be ruled out from real data alone. + +> **Can we build a ground-truth-anchored control: prescribe a KNOWN Manning's +> n field, hold geometry fixed to what real training already agrees on, route +> a known "true" Q' through the real MC solver to generate noise-free +> synthetic gauge observations, then train fresh KAN heads against those +> synthetic observations using each of this campaign's 4 REAL Q' stores as +> the forcing — and see whether recovered n diverges by Q'-source (while +> geometry does not), even though the true n is identical across all four?** + +If recovered n systematically deviates from the known truth in a way that +tracks each store's departure from the true Q' (while q_spatial/p_spatial +stay close to truth), that is a direct, ground-truth-anchored demonstration +of the bias-absorption mechanism — no real roughness observations needed, +because the roughness observations are built by construction. + +**Naming — do not conflate with the registered campaign.** This experiment's +4 arms are this AORC2F/LSTM wave campaign's own naming +(`aorc2f_distributed`/`aorc2f_lumped`/`daily_lstm`/`hourly_lstm`, from +`docs/2026-07-16-aorc2f-wave1-findings.md` and +`docs/2026-07-16-wave2-cross-wave-findings.md`) — a DIFFERENT arm set from +the pre-registered LSTM-equifinality campaign's R1/R2/R3 naming (the paper's +`tab:arms` table). Any findings doc or paper section drawing on this +experiment must keep the two naming schemes and the two campaigns' +provenance clearly separated; this experiment informs, but does not +replace, extend, or amend, the registered campaign's own R1-R3 results. + +Unlike the leakance recoverability experiment (which planted a *subtle*, +sub-percent per-reach flux perturbation that turned out to be invisible below +the windowed training objective's ~130× noise floor), this design swaps the +*entire* Q' forcing across arms — a global, large-magnitude (O(10-100%) at +many reaches) discharge difference, well above that floor. That prior +finding is noted as a risk to watch, not assumed away. + +## 2. Architecture + +``` + TRUTH INGREDIENTS (fixed, no training) + ──────────────────────────────────── + Q'_true = merit_dhbv2_UH_retrospective.ic + (the real USGS-validated standard benchmark store) + + geometry truth (q_spatial, p_spatial) = per-reach MEDIAN across the 4 + already-converged real checkpoints from this campaign: + .ddrs/runs/2026-07-16T02-22-14Z-train-and-test/checkpoints/epoch_5_mb_35 (AORC2F distributed) + .ddrs/runs/2026-07-16T02-23-20Z-train-and-test/checkpoints/epoch_5_mb_35 (AORC2F lumped) + .ddrs/runs/2026-07-16T11-31-50Z-train-and-test/checkpoints/epoch_5_mb_35 (daily-lstm) + .ddrs/runs/2026-07-16T11-31-52Z-train-and-test/checkpoints/epoch_5_mb_35 (hourly-lstm) + via dump_parameters on each, then per-COMID median. Data-driven + consensus of "whatever the most common trained value trend is" — + cancels any one arm's idiosyncratic noise, and is consistent + with the equifinality campaign's own finding that geometry is + the more identifiable quantity. + + n truth (prescribed, per-COMID, two variants): + Phase 1 (primary): Leopold-Maddock power law, + n = clip(0.08 * (uparea / uparea_median)^(-b), 0.015, 0.15), + DEcreasing downstream (classical hydraulic-geometry direction — + the opposite sign of the equifinality campaign's anomalous + trained-model finding). `b` is calibrated empirically against + the real `log10_uparea` distribution so the field spans + roughly the full [0.015, 0.15] range across CONUS (start from + b=0.15 and adjust once the truth-n script runs against the + actual attribute distribution) — this is a tuning detail, not + a design fork. + Phase 2 (confirmatory, run only if Phase 1 shows a clear signal): + Gaussian-noise field, mean 0.08, spread within [0.015, 0.15], + IID per reach — no spatial structure at all. Any recovered + structure in this case is pure training-side artifact. + + │ + ▼ + TEACHER (new eval-only mode, --backend cpu) + frozen consensus geometry + per-COMID n OVERRIDE + (new eval-path seam in src/training/forward.rs, + same pattern as LeakanceOverride but for `n`), + forced Q' = Q'_true, full simulation window + 1981/10/01-2010/09/30, no gradient computed + │ + ▼ + synthetic gauge observations (zarr-v2, REUSES + obs_writer.rs unchanged) at the 2,365 USGS gauge + locations, daily, noise-free + │ + ┌───────────────┬──────────┼──────────┬───────────────┐ + ▼ ▼ ▼ ▼ │ + student: student: student: student: │ + AORC2F AORC2F daily-lstm hourly-lstm │ + distributed lumped │ + (cold seed-42, --backend cpu, learns n/q_spatial/p_spatial │ + from attributes; forcing = each real campaign Q' store; │ + everything else = EXACT copy of this campaign's own configs, │ + only data_sources.observations repointed to the synthetic │ + store) │ + │ │ │ │ │ + └───────────────┴──────────┼──────────┴──────────────────┘ + ▼ + dump_parameters (--backend cpu) → recovered + n/q_spatial/p_spatial per COMID, per student + │ + ▼ + COMPARE vs known truth: + n → vs the prescribed truth field + q/p → vs the 4-checkpoint consensus median + per-reach error, drainage-area-binned slope fit, + cross-arm divergence (does n diverge by Q'-source + while q/p do not?) +``` + +## 3. Pre-registered verdicts + +Computed by the analysis script; thresholds fixed here, before any run. + +| # | Metric | Definition | Bar | +|---|---|---|---| +| S1 | **n recovery error** | per-arm median absolute error, recovered n vs truth n, all reaches | report per arm; compare across arms | +| S2 | **n slope fidelity** | per-arm fitted slope of recovered n vs log10(uparea), vs the true (negative) slope | slope flips sign (positive) ⇒ reproduces the equifinality anomaly | +| S3 | **Geometry recovery error** | per-arm median absolute error, recovered q_spatial/p_spatial vs the 4-checkpoint consensus median | should be small and CONSISTENT across arms | +| S4 | **Cross-arm divergence ratio** | (max−min across the 4 arms) of S1, divided by (max−min across the 4 arms) of S3 | ≥ 3× ⇒ n diverges by Q'-source substantially more than geometry does — headline PASS criterion | +| S5 | **Divergence-vs-bias correlation** | per-arm S1 vs a scalar measure of that arm's Q'-source departure from Q'_true (e.g. mean daily volume ratio) | positive correlation ⇒ divergence tracks bias magnitude, not just arbitrary arm-to-arm noise | + +**Headline: PASS iff S4 ≥ 3× AND S2 shows at least one arm's slope flipping +sign.** S5 is supporting evidence, not a hard bar (only 4 data points). + +## 4. Components to build + +1. **n-override eval-path seam** — new struct in `src/training/forward.rs`, + same shape as `LeakanceOverride` (per-COMID normalized-value substitution + before denormalization), scoped to `n` only. Eval-only; no `Backward` impl + touched (repo invariant 4 untouched — this mirrors the leakance override's + proven-safe pattern). +2. **Teacher mode** — reuses the chunked forward-eval loop + (`probe_zeta_gradient --mode teacher` is the direct template): loads the + consensus-geometry checkpoint, applies the n-override CSV, forces + `streamflow = merit_dhbv2_UH_retrospective.ic`, runs `--backend cpu` over + the full 1981/10/01-2010/09/30 window, writes synthetic gauge obs via the + unmodified `obs_writer.rs`. +3. **Consensus-geometry script** (Python, `ddrs-py`) — runs `dump_parameters` + (existing binary, `--backend cpu`) against each of the 4 real checkpoints' + `epoch_5_mb_35/head`, loads the 4 resulting NetCDFs, computes per-COMID + median `q_spatial`/`p_spatial`, writes a single consensus NetCDF/CSV. +4. **Truth-n generator script** (Python, `ddrs-py`) — computes the + Leopold-Maddock CSV and the Gaussian-noise CSV from + `merit_global_attributes_v2.nc`'s `log10_uparea` attribute. Zero repo + risk. +5. **4 student configs** — each is the campaign's own existing config + (`aorc2f_distributed_frozen_chunk1.yaml`, `aorc2f_lumped_frozen_chunk1.yaml`, + `lstm_daily_frozen_chunk1.yaml`, `lstm_hourly_native.yaml`) with only + `data_sources.observations` repointed to the synthetic obs store. Cold + seed-42 init (no `experiment.checkpoint`), `params.sparse_solver: cpu`, + `--backend cpu` at launch — matching this campaign's own convention. +6. **Analysis script** — `scripts/synthetic_n_recoverability_analysis.py`: + loads the 4 students' `dump_parameters` outputs, the truth-n CSV, and the + consensus-geometry NetCDF; computes S1-S5 exactly as §3 defines; prints a + VERDICTS block; writes per-reach rows CSV. +7. **Findings report** — `docs/2026-07-22-synthetic-n-recoverability-findings.md` + once run. + +## 5. Execution sequence and compute + +All CPU (`NdArray`, deterministic, `--backend cpu` everywhere per +explicit instruction). + +1. **Consensus geometry**: 4 `dump_parameters` calls (fast, single forward + pass each) + median script. +2. **Truth-n generation**: 2 scripts (Leopold-Maddock + Gaussian), no + training required. +3. **Teacher pass** (Phase 1, Leopold-Maddock n): one full-window forward-eval + over 1981/10/01-2010/09/30 → synthetic obs store. +4. **4 students in parallel** (Phase 1): full CONUS 5-epoch train-and-test, + `--backend cpu`, cold seed-42, comparable wall-time to this campaign's own + CPU arms (the lumped arm took ~8h26m end-to-end). +5. **Measurement**: `dump_parameters` on each student's final checkpoint + + analysis script. +6. **Phase 2 (contingent)**: if S4 ≥ 3× in Phase 1, re-run the teacher with + the Gaussian-noise n truth, then re-run only the 2 arms with the largest + Phase-1 n-recovery error, then re-measure. + +## 6. Concerns + +1. **Disagg-head architecture IS shared across the teacher and all 4 + students (the same frozen capacity-boosted chunk1 head, matching this + campaign's own configs) — but that shared-ness is itself an unverified + assumption, not a proven non-confound.** The claim "geometry + (q_spatial/p_spatial) is independent of the disagg head's daily→hourly + precip translation" is asserted here, not tested. Why it matters: S3 + (geometry recovery error) is the experiment's cross-arm CONSISTENCY + check — the headline S4 ratio depends on geometry error staying small + and stable while n's varies. Since every arm freezes the SAME disagg + head, a latent disagg-head effect on q/p would masquerade as "geometry + converges because it's physically identifiable" when the real cause is + "geometry converges because the disagg head never changes." This is NOT + fully closed by the current design — the findings doc (plan Task 7) must + carry an explicit sanity note flagging this as an open confound in S3's + interpretation, not a settled non-issue. +2. **Cold-start students could reintroduce the leakance experiment's ~130× + windowed-objective noise floor.** Why judged low-risk here: that floor + swamped a SMALL per-reach flux signal; a full Q'-source swap changes + discharge by O(10-100%) at many reaches, well above the floor. Flagged as + a risk to check in the findings (e.g. via each student's step-0 vs + converged loss), not assumed away. +3. **8 full-CONUS training runs (4 arms × 2 truth-n fields) is expensive.** + Mitigated by staging: Phase 2 only runs if Phase 1 shows a signal, and + only on the 2 most-divergent arms, cutting Phase 2 cost by half. +4. **Consensus geometry is itself derived from real, noisy-observation-trained + checkpoints**, not a "true" physical geometry. Why accepted: the + experiment's target claim is about n divergence RELATIVE to a held-fixed + geometry, not an absolute physical-truth claim about channel shape — using + the real training's own consensus is the least-arbitrary fixed reference + available, and ties the control directly to what real training already + agrees on. + +## 7. Testing + +- **n-override injection test**: a small losing/gaining chain routed with an + n-override CSV equals the same chain routed with n substituted manually + into the head output — byte-identical (mirrors the existing + `LeakanceOverride` injection test pattern). +- **Synthetic-obs roundtrip**: reuses the existing `obs_writer.rs` roundtrip + test infra unchanged (no new obs-writer code). +- **Guard suites stay green**: `compare_ddr_sandbox` ABSOLUTE MATCH (nothing + in `src/routing/`/`src/sparse.rs` touched). No autograd `Backward` impl + touched (repo invariant 4). + +## 8. Out of scope + +- Observation noise / robustness (synthetic obs are noise-free by design — + this tests parameter-recovery attribution, not real-world detectability). +- A hand-fit smooth trend for q_spatial/p_spatial truth (rejected in favor of + the per-reach consensus median — see §1 decision log / brainstorming + transcript). +- Any GPU runs. +- Promotion of any finding here into the standing, pre-registered + equifinality campaign's own verdict — this experiment is a separate, + non-registered synthetic control that INFORMS that campaign's open + question; it does not amend its registered results. diff --git a/output/synthetic_n/plots/geometry_recovery_distributed.png b/output/synthetic_n/plots/geometry_recovery_distributed.png new file mode 100644 index 0000000..c17d6b1 Binary files /dev/null and b/output/synthetic_n/plots/geometry_recovery_distributed.png differ diff --git a/output/synthetic_n/plots/map_n_error_distributed_conus.png b/output/synthetic_n/plots/map_n_error_distributed_conus.png new file mode 100644 index 0000000..ac47927 Binary files /dev/null and b/output/synthetic_n/plots/map_n_error_distributed_conus.png differ diff --git a/output/synthetic_n/plots/map_n_recovered_distributed_conus.png b/output/synthetic_n/plots/map_n_recovered_distributed_conus.png new file mode 100644 index 0000000..b9d0a8b Binary files /dev/null and b/output/synthetic_n/plots/map_n_recovered_distributed_conus.png differ diff --git a/output/synthetic_n/plots/map_n_truth_conus.png b/output/synthetic_n/plots/map_n_truth_conus.png new file mode 100644 index 0000000..4c941dd Binary files /dev/null and b/output/synthetic_n/plots/map_n_truth_conus.png differ diff --git a/output/synthetic_n/plots/n_hist_truth_vs_recovered_distributed.png b/output/synthetic_n/plots/n_hist_truth_vs_recovered_distributed.png new file mode 100644 index 0000000..0fbc5d0 Binary files /dev/null and b/output/synthetic_n/plots/n_hist_truth_vs_recovered_distributed.png differ diff --git a/output/synthetic_n/plots/n_recovery_hexbin_distributed.png b/output/synthetic_n/plots/n_recovery_hexbin_distributed.png new file mode 100644 index 0000000..757d1f1 Binary files /dev/null and b/output/synthetic_n/plots/n_recovery_hexbin_distributed.png differ diff --git a/output/synthetic_n/plots/n_slope_vs_uparea_distributed.png b/output/synthetic_n/plots/n_slope_vs_uparea_distributed.png new file mode 100644 index 0000000..86f4ca0 Binary files /dev/null and b/output/synthetic_n/plots/n_slope_vs_uparea_distributed.png differ diff --git a/output/synthetic_n/plots/synthetic_n_recovery_distributed.ipynb b/output/synthetic_n/plots/synthetic_n_recovery_distributed.ipynb new file mode 100644 index 0000000..5705f87 --- /dev/null +++ b/output/synthetic_n/plots/synthetic_n_recovery_distributed.ipynb @@ -0,0 +1,374 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "16450012", + "metadata": {}, + "source": [ + "# Synthetic-n recoverability — arm 1 (`distributed`) vs Leopold-Maddock truth\n", + "\n", + "Generated 2026-07-29 by the ddrs-eval-plots skill.\n", + "\n", + "**Inputs**\n", + "- Truth donor: `output/synthetic_n/truth_leopold_maddock.nc` (prescribed n + consensus geometry)\n", + "- Recovered: `output/synthetic_n/recovered_distributed.nc` (student checkpoint `.ddrs-synthetic-n-distributed/runs/2026-07-28T16-12-57Z-train-and-test/checkpoints/epoch_5_mb_35`, trained on the aorc2f distributed Q' store against synthetic obs)\n", + "- Attributes: `~/projects/ddr/data/merit_global_attributes_v2.nc` (`log10_uparea`)\n", + "- Fabric: `~/projects/ddr/data/merit/cat_pfaf_7_MERIT_Hydro_v07_Basins_v01_bugfix1.shp`\n", + "\n", + "**Caveat:** arm 1 of 4 — S1–S5 verdicts require all arms. Preview only." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "38cf3cab", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-29T00:12:38.723548Z", + "iopub.status.busy": "2026-07-29T00:12:38.723472Z", + "iopub.status.idle": "2026-07-29T00:12:42.238045Z", + "shell.execute_reply": "2026-07-29T00:12:42.237634Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "346,321 COMIDs aligned\n" + ] + } + ], + "source": [ + "from pathlib import Path\n", + "import geopandas as gpd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import xarray as xr\n", + "from mpl_toolkits.axes_grid1 import make_axes_locatable\n", + "\n", + "REPO = Path(\"/home/tbindas/projects/ddrs\")\n", + "OUT = REPO / \"output/synthetic_n\"\n", + "PLOT_DIR = OUT / \"plots\"\n", + "PLOT_DIR.mkdir(exist_ok=True)\n", + "ATTRS_NC = Path(\"/home/tbindas/projects/ddr/data/merit_global_attributes_v2.nc\")\n", + "SHAPEFILE = Path(\"/home/tbindas/projects/ddr/data/merit/cat_pfaf_7_MERIT_Hydro_v07_Basins_v01_bugfix1.shp\")\n", + "ARM = \"distributed\"\n", + "\n", + "truth = xr.open_dataset(OUT / \"truth_leopold_maddock.nc\")\n", + "tc = truth[\"COMID\"].values\n", + "rec = xr.open_dataset(OUT / f\"recovered_{ARM}.nc\").set_index(COMID=\"COMID\").sel(COMID=tc)\n", + "attrs = xr.open_dataset(ATTRS_NC).set_index(COMID=\"COMID\").sel(COMID=tc)\n", + "lup = attrs[\"log10_uparea\"].values.astype(np.float64)\n", + "tn, rn = truth[\"n\"].values, rec[\"n\"].values\n", + "print(f\"{len(tc):,} COMIDs aligned\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4082b2d4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-29T00:12:42.239184Z", + "iopub.status.busy": "2026-07-29T00:12:42.239028Z", + "iopub.status.idle": "2026-07-29T00:12:42.684027Z", + "shell.execute_reply": "2026-07-29T00:12:42.683749Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saved /home/tbindas/projects/ddrs/output/synthetic_n/plots/n_recovery_hexbin_distributed.png\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# --- Recovery hexbin: truth n vs recovered n -------------------------------\n", + "corr = np.corrcoef(tn, rn)[0, 1]\n", + "mae = np.median(np.abs(rn - tn))\n", + "fig, ax = plt.subplots(figsize=(8, 7), dpi=150)\n", + "hb = ax.hexbin(tn, rn, gridsize=70, cmap=\"viridis\", mincnt=1, bins=\"log\")\n", + "fig.colorbar(hb, ax=ax, label=\"reach count per hex (log)\")\n", + "lims = (0.0, 0.26)\n", + "ax.plot(lims, lims, \"k--\", lw=1.2, label=\"1:1\")\n", + "ax.set_xlim(0.0, 0.16); ax.set_ylim(lims)\n", + "ax.set_xlabel(\"truth n (Leopold-Maddock, m$^{-1/3}$ s)\")\n", + "ax.set_ylabel(f\"recovered n ({ARM} student)\")\n", + "ax.set_title(f\"n recovery — {ARM} (corr={corr:.3f}, median|err|={mae:.4f})\")\n", + "ax.legend(loc=\"upper left\")\n", + "ax.grid(alpha=0.3)\n", + "out = PLOT_DIR / f\"n_recovery_hexbin_{ARM}.png\"\n", + "fig.savefig(out, dpi=300, bbox_inches=\"tight\", facecolor=\"white\")\n", + "print(f\"saved {out}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f25c59f0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-29T00:12:42.685019Z", + "iopub.status.busy": "2026-07-29T00:12:42.684940Z", + "iopub.status.idle": "2026-07-29T00:12:43.094651Z", + "shell.execute_reply": "2026-07-29T00:12:43.094316Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saved /home/tbindas/projects/ddrs/output/synthetic_n/plots/n_slope_vs_uparea_distributed.png\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# --- n vs log10(uparea): the Leopold-Maddock slope test --------------------\n", + "t_slope, t_int = np.polyfit(lup, tn, 1)\n", + "r_slope, r_int = np.polyfit(lup, rn, 1)\n", + "fig, ax = plt.subplots(figsize=(10, 6), dpi=150)\n", + "hb = ax.hexbin(lup, rn, gridsize=80, cmap=\"viridis\", mincnt=1, bins=\"log\")\n", + "fig.colorbar(hb, ax=ax, label=\"reach count per hex (log)\")\n", + "bin_edges = np.linspace(lup.min(), lup.max(), 21)\n", + "bin_idx = np.digitize(lup, bin_edges) - 1\n", + "bc = 0.5 * (bin_edges[:-1] + bin_edges[1:])\n", + "med_t = np.array([np.nanmedian(tn[bin_idx == b]) if np.any(bin_idx == b) else np.nan for b in range(20)])\n", + "med_r = np.array([np.nanmedian(rn[bin_idx == b]) if np.any(bin_idx == b) else np.nan for b in range(20)])\n", + "ax.plot(bc, med_t, color=\"black\", lw=2.5, label=f\"truth median (slope {t_slope:+.4f})\")\n", + "ax.plot(bc, med_r, color=\"#ff4500\", lw=2.5, label=f\"recovered median (slope {r_slope:+.4f})\")\n", + "ax.set_xlabel(r\"$\\log_{10}$(drainage area, km$^2$)\")\n", + "ax.set_ylabel(\"Manning's n (m$^{-1/3}$ s)\")\n", + "ax.set_ylim(0.0, 0.26)\n", + "ax.set_title(f\"n vs drainage area — {ARM} student vs Leopold-Maddock truth\")\n", + "ax.legend(loc=\"upper right\", frameon=True)\n", + "ax.grid(alpha=0.3)\n", + "out = PLOT_DIR / f\"n_slope_vs_uparea_{ARM}.png\"\n", + "fig.savefig(out, dpi=300, bbox_inches=\"tight\", facecolor=\"white\")\n", + "print(f\"saved {out}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a0a8843a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-29T00:12:43.095590Z", + "iopub.status.busy": "2026-07-29T00:12:43.095505Z", + "iopub.status.idle": "2026-07-29T00:12:43.319056Z", + "shell.execute_reply": "2026-07-29T00:12:43.318741Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saved /home/tbindas/projects/ddrs/output/synthetic_n/plots/n_hist_truth_vs_recovered_distributed.png\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABRgAAALHCAYAAADl1y5pAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAXEgAAFxIBZ5/SUgAAlLNJREFUeJzs3XlcFWX///H3AQWRVVlcE8w1KTWX0tTEcitzy/ymZblklneL5l1qd1pulZV3SprVbYuaqXdqWObS4paVS2lpoVnulhvghoAgnPn94e+cW+KAh2HgsLyejwePYmauaz4zZzgH3l4zl80wDEMAAAAAAAAAYIKXpwsAAAAAAAAAUHIRMAIAAAAAAAAwjYARAAAAAAAAgGkEjAAAAAAAAABMI2AEAAAAAAAAYBoBIwAAAAAAAADTCBgBAAAAAAAAmEbACAAAAAAAAMA0AkYAAAAAAAAAphEwAgAAAAAAADCNgBEAAAAAAACAaQSMAAAAAAAAAEwjYAQAAAAAAABgGgEjAAAAAAAAANMIGAEAxVZMTIxsNpsmTJiQY11UVJRsNpvmzp1b5HW5Y9CgQbLZbBo0aFCOdXkdV3Fx6NAh2Ww22Ww2HTp0yNPlQHK+Hhs2bPB0KYBpEyZMkM1mU0xMjKdLKTQl+f0/r9cnr+MqSzgPAOBaOU8XAABAcTBjxgydPXtWvXr1UtOmTT1dTqFy/GE7aNAgRUVFebQWT5g7d64OHTqkmJiYYhFyFLd6AJQcZen9oyx9TgNASUTACAAokerUqaMKFSooODjYkv5mzJihw4cPKyoqypI/XKpVq6YGDRqoWrVqBS/OYhMnTpR0eSRNbgFj+fLl1aBBA+f/lyZz587Vxo0bJalY/EFe3OoBUHhq1aqlBg0aKCwszJL+rH7/CAsLU4MGDVSrVq0C92U1qz+nAQDWImAEAJRIa9eu9XQJeXr55Zf18ssve7oM02rUqKHffvvN02UAQKkyf/58T5eQp8cff1yPP/64p8sAAJRAPIMRAAAAAAAAgGkEjAAAl658EL1hGJozZ45uvvlmBQUFKTAwUK1bt9aCBQsKtI+srCzNnDlTzZo1k7+/vypXrqyYmBgtXbr0qm3zmuQlLS1N06ZNU+vWrVWpUiWVL19e4eHhatSokQYOHKhly5Y5t3U80P7w4cOSpMGDBzsn03B8Ofx94pP9+/dr2LBhql27tnx9fbPdbuzuQ+AzMjI0depUNW7cWP7+/qpUqZI6deqk1atX59rGnck+XE0k4KjJoUOHDtmO88r63Znk5dy5c5o0aZKaNWumoKAg+fn5qV69eho+fLgOHDjgVv3JyckaN26cGjZsKD8/P4WGhuquu+7S1q1bc21v1ty5c2Wz2Zy3E06cODHHa33lsV5Z56lTpzRq1CjVr19fFStWzHYe3Zm0wdXECfmt50pWnrfp06fLZrOpSpUqyszMzHU7wzCcP3eTJ0/Otu63337TsGHDnOenQoUKuuaaa9SqVSv961//yvdo2A0bNmT7+fvpp590//33q2bNmipfvnyOW0EzMjI0e/ZsdejQQWFhYfLx8VHVqlXVs2fPPH+WHLZu3arBgwerbt26qlixooKCgtSoUSMNGTJEX3zxhcs2+b3+4+LiZLPZ5OPjo6SkpDzrufXWW2Wz2fTQQw/lWGe32/XRRx/pzjvvVJUqVeTj46Pw8HB17txZixYtkmEYLvu88j3zwoULev7553XDDTcoMDDQ5bX23XffacCAAYqMjHQ+juKmm27SK6+8ogsXLuRZ/+rVq9WpUyeFhIQoICBATZo00auvvqpLly7l2a4k+eijj9SmTRsFBgYqODhYN998s/7zn//kev4d8nq/yMzM1H/+8x/FxMQoLCxM5cuXV2hoqBo0aKB7771X7733nnPbwno/c3cSHsMw9Pbbb+umm25SUFCQgoKC1LZtWy1cuDDXNu5MzubqszM/n9NXWrlypfr06aMaNWrI19dXlSpV0q233qq33npLGRkZeR6f2dcXAMo0AwAAF9q3b29IMsaNG2f07NnTkGSUK1fOCAoKMiQ5v55//nlT/V+8eNHo0qWLsx8vLy8jJCTEsNlshiRjzJgxzhpeeOGFHO0jIyMNScYHH3yQbfn58+eNJk2aOPu12WxGSEiIUa5cOeeyyMhI5/avvfaaUaVKFcPLy8uQZAQFBRlVqlTJ9uVw8OBBZx8fffSRERAQYEgyKlasaPj7+2frd+DAgYYkY+DAgbme22effdZo166d89yGhIRkO7eujtswDOf69evX53p+XZ27J5980qhSpYqzfaVKlbIdZ4sWLVwe68GDB3P0/+uvvxo1a9Z0blOhQgUjMDDQ+b2vr6+xdOnSPOtfuHChUbduXWf7ihUrOtf5+PgYX3zxhcv2L7zwQp615Wbx4sVGlSpVjPLlyxuSDH9//xyv9ZEjR3LUOWfOHOd5u/I48zrXudXcvn37Atdj9rzl5sSJE4a3t7chyfj8889z3W7Dhg3On6krz/uXX35p+Pr6OmsoX76829dybtavX+9su3TpUuc5CgoKMipUqJDtPB46dMiIjo7O9jMfHBycbf+PPvqoy/1kZmYaTz75ZLZt/f39jUqVKjnfi4KDg3O0M3P9p6enG5UrVzYkGbNmzcr12A8ePOjc94YNG7KtS0pKMm699dZs9f79WHv06GGkp6fn6Nfxnjlt2jSjfv36zuvF8Vo5XtOsrKwc5yQgIMB5jUgyGjRoYBw6dMhl/Vf+fErK9v576623Gs8++2yOn4WSxG63G4MHD852vVWqVMn5GdKvXz+33v///jORmZlpdOrUKcdre+XP1pXvO4X1fubqvcrhyuO69957nZ/dV/68SDIGDx5s2O32HO1z+9zObR8O+fmcNgzDSE1NNe65555s5y0oKChbja1atTJOnz6dY/8FfX0BoCwjYAQAuOT4I6hSpUpGcHCwMXfuXCM1NdUwDMM4evSo0b17d+cfF7///nu++3/qqaecv7xPmTLFOHfunGEYhnHy5Elj+PDh2f5wzk/AOHnyZEOSUblyZWPZsmXGxYsXDcO4/EfzX3/9ZcyfP994+OGH3e7vSleGbgEBAcbNN99s/PDDD871e/fudf6/O39gOv54fPvtt420tDTDMAzjyJEj2f4w+vTTT3O0Nxsw5qd9XgHj+fPnjdq1axuSjBo1ahgrV640srKyDMMwjJ9//tlo1aqVM2T5+eefc91/pUqVjEaNGhnr1q0zsrKyDLvdbmzbts1o0KCBIV0Ogh39XslswOjgTiB4ZZ0BAQFGgwYNjLVr1zrrufK1Nhswmq3H7HnLyx133GFIMu69995ct3nooYecIdGV6tSpY0gyOnfubPzyyy/O5Wlpacavv/5qTJw4Mc+fK1euDBgDAgKMO++809izZ49zveM958KFC0bDhg0NSUZMTIyxYcMG58/82bNnjddff935DwEzZszIsZ/Ro0c79zNkyJBsr+vZs2eN5cuX5zgnBbn+He9tN998c67H7ngPi4qKyhbSZGZmOq+Vpk2bGitWrDBSUlKc52HevHlGRESEIckYOXJkjn4d73EBAQFG1apVjbi4OCMjI8MwjMvv6Y6+xo0bZ0gyIiIijDfffNNISkoyDMMwMjIyjPXr1xs33nijIclo1qxZjuvs008/dZ7Pvn37OgOu1NRU480338wWaJbUgDE2NtZ5jI8//riRkJBgGMbl62XChAnOf9TKb8D44YcfOkO/d99910hOTjYM43LgdfLkSeOTTz4x7rnnHrf7+zt338/cCRiDg4MNm81mTJ482fnZferUKePxxx937ic2NjZHe7MBY37aG4ZhDBgwwJBkXHvttcZHH33krDEtLc349NNPjWuvvdaQZPTq1StH24K+vgBQlhEwAgBccvzRIslYt25djvUXL140qlevbkgypkyZkq++//rrL+eIlvHjx7vcpn///s795ydgdAQlL730Ur5qym/AGBkZ6fwD0BV3AkZJxnvvvZdjfVZWlnOUUnR0dI71ng4Yp06dakiXR6pdGSg5nD9/3oiKijIkGd26dct1/+Hh4cbJkydzrN+1a5dzm2+//TbH+qIOGIOCgoyjR48WqD8rA0az5y0vixYtcoYbjj/Gr5SWluYM/N99913n8pMnTzr3eezYsXztMy9XBow33XSTkZmZ6XK7SZMmOc+rIyz7u08++cSQZISFhRmXLl1yLt+7d69zVNLo0aPdrq0g1//mzZudx3VlqHMlx+jCcePGZVs+f/58Q5LRsGFD4+zZsy7b/vjjj4bNZjN8fHxyXCOO9zhvb29jx44dLtsfPHjQ8Pb2Nvz8/Fz+44Dj+ByjN+Pi4rKta9SokfP1cBVyv/32287jL4kBY1pamnMU6gMPPOBym7FjxzqPMT8BoyN8HjZsWL5qsvr9zJ2AMa/Pbke4V7lyZec/nDkURcD4zTffOAPyK0dwXuno0aOGv7+/Icn46aefnMuteH0BoCzjGYwAgDy1adNGHTp0yLHc19dXXbp0kSTt2rUrX30uXbpUmZmZ8vPz09NPP+1ym7yeZ5eXkJAQSdLx48dNtXfX448/roCAgAL1cc0112jw4ME5lnt5eWncuHGSpPj4eP3yyy8F2o/V/vvf/0qS7rnnHl1//fU51gcGBmr06NGSLj+L7dy5cy77GTZsmCIiInIsv+GGG1S7dm1Jrq8tx3NBjf//TMDC9sADD6hmzZqFvh93mT1veenZs6eCgoJ08eJFLVmyJMf6zz77TOfOnVOFChV0zz33OJcHBgbKy+vyr5OF9TP3zDPPyNvb2+U6xzPpRo0apfLly7vcplevXgoKClJiYqK2b9/uXD5v3jzZ7XaFhoZq4sSJbtdTkOu/VatWqlevniTpww8/zNF227Zt+v333yVdvu5cHevw4cMVHBzssrbmzZsrOjpaGRkZWr9+vcttunbtqhtvvNHlurlz5yorK0tdu3ZVkyZNXG4TGBioXr16SVK251Pu2rVLu3fvliSNGzfOeV1c6eGHH1aNGjVc9lsSfPnllzp9+rQk6fnnn3e5zdixY1WhQoV89+347Dpx4oTp+txhxftZXp/djvNy+vRpffXVVwXajxmOn5P7779f11xzjcttatas6fy95spruDBfXwAoCwgYAQB5uvnmm3NdV716dUly/kLurh9//FGS1KJFCwUFBbncpn79+qb+EL3rrrskSbNmzVL//v21fPlyJSYm5rufq2nTpk2B+3A87N+Vdu3aqVy5cpL+d76Kg4yMDGd41bFjx1y369Spk6TLE1Ls2LHD5TaFcW0VBiteaysVxnnz8/NzBoeugi/Hsp49e2YLt/z8/HT77bdLuhxcPf/889q6detVJ1DIj9zO/19//eWc9OGhhx5S1apVXX5Vq1bNOSmJY3tJ+v777yVdvlbdDQysuP4dweGCBQtyTBjhOM8333yz6tev71yelZWlLVu2SLocsOd2rFWrVtXevXtzHOuV8rqev/vuO0mXg5a89vHBBx/k2IfjfapcuXJq166dy/69vLyuOnlIceY4xmuuuUZ169Z1uU1wcLCaN2+e777vvPNO2Ww2ffbZZ7rjjju0aNEiHTt2rED1umLF+1len9316tVzBpie+OxyXMPvvfdentfw119/Lcn1NVwYry8AlAXlPF0AAKB4CwwMzHWdIwDL78ygp06dkqSrBog1a9bUX3/9la++77vvPm3btk0zZ87U4sWLtXjxYklS3bp11blzZw0ZMsSSPw5cjSDLr7yOv0KFCgoNDdXJkyed56s4OH36tLKysiTlXf+VI2Ryq78wrq3CYMVrbaXCOm8PPvig3n//fX3zzTc6fPiwIiMjJUkJCQlas2aNc5u/e/fdd9WjRw/t3LlTkydP1uTJk+Xj46OWLVuqZ8+eeuihh1S5cuV81+OQ2/m/Mnxx9x8RUlNTnf/vGCnmOE53WHH9P/DAA3rhhRd06NAhffvtt84w7tKlS873q7+f59OnTys9PV2SdObMGbdqvfJYr5TX9ew4pykpKUpJScnXPhzHGRYWJl9f31zbmB09d/fddztDYSvdcsst+uSTT9zaNj+fXfnVtm1bvfLKKxo3bpzWrFnj/JmrWbOmOnbsqAcffNDl3QT5VdifXY71f/75p0c+uxzX8Pnz53X+/Pmrbu/qGi6M1xcAygJGMAIASp0ZM2Zo7969eumll3THHXcoJCRE+/bt0+zZs9WiRQuNHDmywPvI7ZZNlD5l5bW+9dZbFRkZKcMwtGDBAufyxYsXKzMzU1WqVFHnzp1ztKtVq5Z27NihNWvW6Mknn1Tz5s1lt9v13XffafTo0apbt67WrVtnuq7czr8j6JOkPXv2OG+bz+tr0KBBzja5jR4ubFFRUc5Qcf78+c7la9asUWJionx8fHTvvfdma3Plsa5evdqtY83tMRN5Xc+O/YwZM8atfWzYsMHkWci/06dP6+TJk5Z/FYdR0g7PPPOMDh48qOnTp6tXr16KiIjQn3/+qblz5+q2225T3759C/yPLqX9/cxxDb/11ltuXcNz5871bMEAUIoQMAIAipxjBMXVRifmd/TilerWratnn31Wq1atUlJSkjZv3ux8blhsbKw+++wz031bJa/jS09PV1JSkqScI04cfyBevHgx1/a5PfewoCpXruzc/59//pnrdleuK24jAK3mGDXoidfDSjabTQMGDJCU/TZpx//379/feax/5+XlpS5duig2NlY//vijTp8+rY8++ki1atXSmTNndN9991l627QkVa1a1fn/ud0O7E77/LS16vp33Ca9ZMkS53XjOM933nmnQkNDs20fGhrqPPdmjtVdZs6Jg+M4ExMT83ytzb6vb9iwwa3AKL9f+QlJi+Kzq3r16ho5cqTi4uJ08uRJ7dq1S0OHDpV0+fnFb731lum+reLu8f/92i+K90orruHCfH0BoDQjYAQAFLkWLVpIuvy8I8ez0f7ujz/+yPMP+Pzw8vJSq1attHTpUtWqVUuScjx83jEhwd+fiVaYNm7cmOv+Nm3apMzMTEn/O18OlSpVkiQdPXrUZdvk5GTt2bMn1/06Rm6ZOVYfHx81btxYkrR27dpct3M838rLy0vNmjXL934Kk9Wv9dVeD0naunVrkdVTEI5bc/fu3asffvjB+d8r17kjMDBQ9913n3PChZMnT1o+WVFUVJTzVsYVK1bku/0tt9wi6fJ7QV6Bx5Wsuv779u2rChUq6Ny5c1qxYoXzv5Lr81y+fHnddNNNkswdq7scz+f7+uuv3T4nDo73qczMTG3atMnlNna7vUhHPVrNcYxHjx7V/v37XW5z/vz5bJMJFdQNN9ygOXPmOF+b4vDZlddn9759+5yf3fn97LLb7Xk+t9GdY3Wcp88//zzXbXLjidcXAEoTAkYAQJHr06ePvL29lZaWpmnTprncZtKkSab6djynzBVvb2/5+PhIUo4ZTh0PrD979qyp/Zpx5MgRzZs3L8dyu92ul156SZLUqFEj3XDDDdnWO2Z3XbZsmct+p02blud5KOix9uvXT9Ll0TS//vprjvUXLlzQq6++KunyaKzcZrz1FKtfa8fr8cUXX7h8bt26deu0efPmIqunIOrXr++cRGb+/PnOUXXXX3+9y5mHrzYq0c/Pz/n/rmYVLqiHH35Y0uUJHX766ac8t/37rbCDBg2St7e3kpKS9MILL7i9Tyuu/+DgYPXs2VPS5fPsGMlYuXJldevWzeV+hw0bJklatWqVVq1alWeNZm/7HTJkiMqVK6fExMSrnpOMjIxsIVPjxo113XXXSZJefPFF2e32HG3ef/99y/7hyBM6derkDMkmT57scptXX31VaWlp+e47r/ds6X8/S8Xhsyuvz+4pU6ZIujza1zHZkYPjvTIuLs5lSDhv3rw8rw93jtXxc/Lrr79edbRnSkpKtvewwnx9AaAsIGAEABS5GjVq6LHHHpN0+Zf4l19+WcnJyZIuTyjx+OOPa8GCBaaCqZtvvllPPvmkNmzYkC3sOXbsmJ544gnt27dP0uU//K90/fXXS7ocGrg7iUJBBQcHa/jw4ZozZ45ztNDRo0fVv39/rV+/XtL//li7Uv/+/SVdDrReeOEF54PsExMT9a9//UtTpkxRSEhIrvt1HOtHH32U60QQeRk+fLhq166tS5cu6Y477tDq1audYcIvv/yiLl266ODBg/L19XVZf0FNmDBBNptNNptNhw4dynd7x/GvWrXKklvd/u///k9eXl5KSkpS//79nX8gp6Wlad68eerdu3eek5xYXU9BOW7fXbx4sfNZjI5lf/f999+rcePGmj59uvbs2eO8DgzD0Pfff6/hw4dLujwpgmPkn5X++c9/6oYbbtDFixfVoUMHzZo1y/loAelyELF69Wo9+OCDOWY2rlu3rp555hlJl0ODoUOH6o8//nCuP3/+vP773/+qd+/e2dpZdf07zumaNWs0a9YsSdK9997r/EeQvxswYIA6duwowzDUu3dvTZkyJdtENykpKVq/fr0ee+wxXXvttVc9d67UqVNH48ePl3T5nDz44IPZQtTMzEz9/PPPmjRpkurWrauff/45W/sXX3xRkrR+/Xrdd999zp+Fixcv6u2339bjjz+e53tTcefn5+c8P/PmzdPIkSOd19v58+c1efJkvfTSS6aOsVevXhoyZIhWr16dLUA7ffq0pkyZ4hwx+/cA2hPvH8HBwTk+uxMTEzVixAjnP5qNHz8+x+zsjs+uPXv2aNiwYdnO3fTp0/Xoo4+69V6Z1+d0+/btNXjwYEnSY489pqeeekoHDhxwrk9PT9eWLVs0evRoRUZGZpuIpjBfXwAoEwwAAFxo3769Icl44YUXct3mhRdeMCQZ7du3z3f/aWlpRseOHQ1JhiTD29vbqFSpkmGz2QxJxpgxY/KsITIy0pBkfPDBBy6XSzJsNpsREhJi+Pv7O5dJMp566qkc/W3cuNG5b29vb6NatWpGZGSkERkZ6dzm4MGDzj4OHjyY5/ENHDjQkGQMHDgwxzrHcT377LNG27ZtDUlG+fLljUqVKmWrc9y4cS77zszMNDp06JDtOB3nzmazGa+99lqe5+7DDz90ti1fvrxRo0YNIzIy0mjTpo3bx/rLL78YNWrUcG5ToUIFIygoyPm9r6+vsWTJEpf1O7ZZv359rucvr/od1507r4Mrv//+u1GhQgVDkuHl5WVUqVLF+VofPXo0X3U6PP/889leu+DgYKNcuXKGJKNXr17GuHHjcv1ZsbIed35uryYxMdHw8fFx7s/Ly8v466+/XG67fv36bMddvnx5IzQ01HnskoygoCDjm2++yVcNV/Z7NX/99ZfRqlWrHD/3V16Pkoy6devmaJuZmWk89thj2bYLCAjI9l4UHByco11Brn+HS5cuGVWqVMm2782bN+fZ5ty5c8Zdd92VrU1QUJAREhLirFeSUa5cuRxtc3vP/Du73W6MHz8+W39+fn5GaGio4e3tnW3f3377bY72zz33XLZtKlWq5Lwe2rVrZzz77LOmPzeKg6ysLOOBBx7I9vNRqVIl57np16+fW+//f/8ZdSy/8nX9+zV8zz33GFlZWdnaWf1+ltfn+pXHde+997r87JZkPPjggznqdLjy3EkyQkJCDC8vL0OS8cQTT+R57tz5nDYMw0hPTzeGDh3q8ufasS/H159//pmtbUFfXwAoyxjBCADwiAoVKmj16tWKjY1V06ZN5ePjI8Mw1K5dO3388ceaOnWqqX4XL16siRMn6vbbb1ft2rWVkZGhS5cuKTIyUvfee6/Wrl2r119/PUe7W2+9VStXrlTHjh0VEhKikydP6vDhw4U6oYKPj4/Wrl2rl156SQ0aNFB6erqCg4N1++23a+XKlbneouXt7a2VK1dq4sSJatiwoXx8fGSz2dS5c2d99dVXevrpp/Pc74ABA/Thhx+qbdu2qlixoo4fP67Dhw/n69bF66+/XvHx8ZowYYKaNm2qcuXKKT09XXXq1NGjjz6q+Ph43XPPPfk6H0WlXr16Wr9+vXr06KHw8HAlJSU5X2vHcy/za+LEifrwww/VqlUr+fv7KysrS02bNtXbb7+tTz75JM+ZWwujnoIIDQ3NNsL39ttvV/Xq1V1u27JlS3388ccaPny4mjdvrrCwMJ0/f14VKlRQ06ZNNXr0aO3ZsyfH6EErVa9eXd9++60WLVqkHj16qFq1akpNTVVGRoaioqLUvXt3zZgxQ998802Ott7e3po1a5a+/fZb3X///apVq5YuXbokwzDUqFEjPfTQQy4fRWDF9V+uXDnniC7p8nXQqlWrPNsEBQVpxYoVWrVqle69917VqlVL6enpSk1NVY0aNdS5c2e9/PLL2rt3r5tnLyebzaZJkyZp165d+sc//qHrrrtO3t7eOnfunCpVqqRbbrlFzzzzjL7//nvn8+6uNGXKFH3++ee67bbbFBQUpPT0dF133XWaOnWq1q5dm+sIzZLCy8tL8+fP1/z589WqVSv5+fkpMzNTzZo109tvv62FCxea6nfmzJl65ZVXdOedd6pevXoyDENpaWmqXr26evTooWXLlmnJkiU5bpH21PvHokWLNHv2bN14443KzMyUv7+/Wrdurfnz52vevHm5PhJh7ty5zs99Pz8/2e12tWnTRh9//LHeeOONPPfp7ue0j4+P5syZo++//16DBg1SnTp1lJWVpQsXLigiIkIxMTF6/vnntWvXLudzXB0K6/UFgLLAZhjF4IniAAAAAAAAAEokRjACAAAAAAAAMI2AEQAAAAAAAIBpBIwAAAAAAAAATCNgBAAAAAAAAGAaASMAAAAAAAAA0wgYAQAAAAAAAJhGwAgAAAAAAADANAJGAAAAAAAAAKYRMAIAAAAAAAAwjYARAAAAAAAAgGnlPF0Acle1alWlpKSoVq1ani4FAAAAAAAAHnbkyBH5+/vrxIkTni4lG0YwFmMpKSm6dOmSp8sAAAAAAABAMXDp0iWlpKR4uowcGMFYjDlGLsbHx3u4EgAAAAAAAHhadHS0p0twiRGMAAAAAAAAAEwjYAQAAAAAAABgGgEjAAAAAAAAANMIGAEAAAAAAACYRsAIAAAAAAAAwDQCRgAAAAAAAACmETACAAAAAAAAMK2cpwsAAAAAAJROhmHIMAxPlwEAxY7NZpPNZvN0GZYhYAQAAAAAWCYrK0tJSUlKTk5WRkaGp8sBgGLLx8dHgYGBCg0Nlbe3t6fLKRACRgAAAACAJbKysnTkyBFdvHjR06UAQLGXkZGhpKQkpaSkqFatWiU6ZCRgBAAAAABYIikpSRcvXpS3t7eqVKkif39/eXnx6H8A+Du73a6UlBSdPHlSFy9eVFJSkiIiIjxdlmkEjAAAAAAASyQnJ0uSqlSpouDgYA9XAwDFl5eXl/N98tixY0pOTi7RASP/lAQAAAAAKDDDMJzPXPT39/dwNQBQMjjeLzMyMkr0pFgEjAAAAACAArvyD2NuiwYA91z5fknACAAAAAAAAKBMImAEAAAAAAAAYBqTvAAAAAAACpXdbldSUpKnyzAlNDSUW74B4CoIGAEAAAAAhSopKanEzo566tQphYeHe7oMSx06dEi1a9dW+/bttWHDBk+XA6AU4J9hAAAAAAAoBIcOHZLNZlNMTEyR7nfDhg2y2WwaNGhQke4XQNlFwAgAAAAAAADANAJGAAAAAAAAAKYRMAIAAAAAitzu3bt16tSpYvW1e/duy45vwoQJql27tiRp48aNstlszq8rb1222WyKiopSRkaGJk2apIYNG8rX11e9evVy9mOz2TR37lyX+4mKipLNZnN+P2jQIHXo0EGSNG/evGz7nTBhQo72aWlpGjt2rCIjI+Xr66u6devqlVdekWEYbh/r3Llznf0fOXJE9913n8LDw+Xn56cWLVpoxYoVbvcFoGRikhcAAAAAQJELCwsrdZOnXKlp06bq06ePli1bpipVqqhr167OdW3bts22rd1uV69evfTNN9+offv2aty4sUJDQ03tt23btjpx4oS++OIL1alTJ9u+mjZtmm3bjIwMde7cWbt371ZMTIxSUlK0ceNGjR07VsnJyZoyZUq+9n3o0CG1bNlSgYGBuv3223XkyBFt3rxZvXr10urVq9W5c2dTxwSg+CNgBAAAAADAYr169VLTpk21bNkyNWzYMNcRiJJ09OhR+fr6au/evapRo0aB9jt06FDVrVtXX3zxhdq2bZvnfjdv3qz27dvr4MGDCgoKkiT9+OOPatWqlaZPn66xY8cqICDA7X3PmzdP//znP/Xqq6/Ky+vyDZMzZszQU089pSlTphAwAqUYt0gDAAAAAOBhL7/8coHDxfzy8vLSO++84wwXJalFixa64447lJqaqh9//DFf/dWuXVsvvfSSM1yUpMcff1yVKlXSli1blJGRYVntAIoXAkYAAAAAADzIZrOpe/fuRb7fyMhINWjQIMfy+vXrS5KOHz+er/5iYmLk4+OTbVm5cuVUu3ZtXbp0SUlJSeaLBVCscYs0AAAAiszi5+JMt+33Ym8LKwGA4iMiIkK+vr5Fvt+aNWu6XB4YGChJSk9P92h/AEoOAkYAAADkS0FCQgBAThUqVDDd1m63m2575a3MVrC6PwAlBz/9AAAAAAAUU45bji9cuJBjXVZWlk6cOFHUJQFADgSMAAAAAAAUAkc4mJmZabqPatWqSZJ+//33HOvWr1+vS5cuFcp+ASA/uEUaAAAAAFDkEhMTPV1CDlbXFBYWpvLly2v//v3KysqSt7d3vvu49dZbJUkLFizQqFGjFBUVJUk6ePCgnnzySZdtqlevLknau3evucIBIJ8IGAEAAAAARa5Ro0aeLqHQ+fj4qGvXrlqxYoWaNGmiZs2aycfHR23atNHgwYPd6qNOnTp68MEHNX/+fDVt2lS33nqrUlNTtWXLFt15551KTU3V4cOHs7WJiopS48aN9eOPP+qmm25SdHS0vL291aNHD/Xo0aMwDhVAGcct0gAAAAAAFJJ3331XDzzwgJKSkrRw4UK999572rhxY776mDNnjsaOHaugoCB98cUXOnTokJ599lktWrQo1zbLli1Tr169dODAAc2fP1/vvfeeduzYUdDDAQCXbIZhGJ4uAq5FR0dLkuLj4z1cCQAAwP94ahbpfi/29sh+AbjHbrc7b8lt0KBBthmFExISFBER4anSCuTUqVMKDw/3dBkASqm83jtdKa5ZESMYAQAAAAAAAJhWYp/BuH37dn311Vfatm2btm3bpr/++kuSlNuATJvNdtU+O3TooHXr1rm1/0GDBmnevHm5rn/rrbf06KOPutUXAACAJ3hqJCKAsic0NFSnTp3ydBmmhIaGeroEACj2SmzAOHnyZH366adubz9w4MBc161cuVKJiYlq165dvuvo0qWLqlatmmN5gwYN8t0XAAAAAJRGXl5e3GYMAKVYiQ0YW7durcaNG6tly5Zq2bKloqKilJ6enuv2c+fOdbn87NmzWrx4sSRpwIAB+a5j7NixiomJyXc7AAAAAAAAoDQosQHjmDFjLOlnyZIlSk9PV6tWrVSvXj1L+gQAAAAAAADKijI/ycuCBQskSQ888ICHKwEAAAAAAABKnhI7gtEKR44c0aZNm1S+fHnde++9pvr45JNPtGzZMmVlZal27drq3r27GjZsaHGlAAAAAAAAQPFUpgPGjz76SIZh6I477jA9M9jMmTOzfT9mzBgNHz5csbGxKlfOvdMbHR3tcvn+/fsVFRWlxMREU7UBAADkxSvQ0xXkD78TAcWb3W5XZmamvL29denSJXl5lfkb5gDgqux2uwzDUFZWlhITE6/63pmVlSVvb+8iqs59ZfodvyC3R9944416++239fvvvys1NVUHDhzQm2++qZCQEM2ePVvPPPOM1eUCAAAAAAAAxY7NMAzD00VYoUKFCkpPT5e7h7Njxw41b95cISEhOnHihHx9fS2pIz4+Xs2aNZPdbteBAwd0zTXXmO7LMbIxPj7ektoAAACutPi5OE+XkC/9Xuzt6RIA5MFut2vv3r2SpAYNGjCCEQDckN/3zuKaFZXZd3zH6MW+fftaFi5Kl1/oHj16KDMzU2vXrrWsXwAAAAAAAKA4KpMBY1ZWlhYvXixJGjBggOX916tXT5J0/Phxy/sGAAAAAAAAipMyGTCuXbtWx48fV2RkpNq1a2d5/2fOnJEk+fv7W943AAAAAAAAUJyUyYDRcXv0gAEDZLPZLO07PT1dK1eulCQ1a9bM0r4BAAAAAACA4qbMBYypqamKi7v8QPOrzR69bds2NWzYULfffnu25b/99ps+/PBDpaenZ1uekJCgfv366ejRo2rSpInatGljbfEAAAAAAMAUm82mqKgoT5eh+fPny2azOQcnuWPDhg2y2WwaNGhQtuUTJkyQzWbT3LlzrS0yn1yd29xqLg1yO7aRI0fKz89PR44c8UxhHlTO0wWYtXLlSk2ePNn5fUZGhiSpVatWzmXjx49Xt27dsrVbvny5Lly4oJYtW6pBgwZ57iM1NVV79+7VxYsXsy0/ceKEHnzwQY0YMUItWrRQeHi4jh07pu3btys5OVk1a9bUxx9/bPnoSAAAAAAo6UrKDPbMXI/CcPHiRY0bN04tW7bMkVd4SlRUlA4fPizDMDxdimnF5RjGjBmjd955R+PGjdP8+fM9WktRK7EBY0JCgrZu3Zpj+ZXLEhIScqy/8vZos+rXr6+RI0dqy5Yt+uWXX5SUlCRfX1/Vr19f3bt314gRI1SpUiXT/QMAAAAAgNLnrbfe0tGjRxUbG2tJf48//rj69eunatWqWdKfWXv27FH58uU9WkNxUK1aNQ0cOFD/+c9/NHbsWDVq1MjTJRWZEhswDho0yNQw21WrVrm9bUxMjMv0u3r16po+fXq+9w0AAAAAAMqut956S5UrV9Zdd91lSX9hYWEKCwuzpK+CaNiwoadLKDYGDBigd955R2+//bbeeOMNT5dTZMrcMxgBAAAAACgKhw4dks1mU0xMjM6fP69Ro0apdu3aKl++vEaOHOnc7vTp03r22WfVqFEj+fn5KTg4WLfddps+//zzXPs+evSonnzySdWvX19+fn6qXLmyWrRooYkTJ+r8+fPZtk1NTdXkyZN1/fXXO/u/9dZbtXjx4mzbXbp0SWFhYapQoYLOnj3rcr+//PKLbDaby0lN16xZo27duik8PFy+vr669tprNWrUKCUlJeXYdtCgQbLZbNqwYYO++OILdejQQSEhIbLZbNn2nZ8+Hefy8ccfV/Xq1VWhQgU1atRIsbGxpm6djYmJkc1m06FDh7R8+XK1atVK/v7+qly5svr3768///wzX/1t3LhRf/zxh/r06ZPraL/4+Hj16tVLlSpVUmBgoNq1a6c1a9bk2mduz2C8cOGCXn75ZTVp0kTBwcEKCAhQnTp11LdvX33xxReS/vccwcOHD0u6/BxFx9eVz1O88jwsXLhQrVq1UmBgoEJCQpzbXO35lsePH9egQYNUpUoV+fn5qVmzZi5vIb7yZ8ad43X3GCQpMzNTb731llq3bq2goCD5+fmpadOmmjFjhjIzM13uL7+vhyS1adNGtWrV0oIFC3I8cq80K7EjGAEAAAAAKAnS0tLUvn17HT58WO3bt1ezZs2cj9X6/fff1bFjRx09elRRUVHq0qWLkpOTtWXLFnXv3l2vvfaann766Wz9bdq0ST169NDZs2cVFRWl7t27Ky0tTb/99psmTJignj17qmnTppKk5ORkdejQQdu3b1d4eLjuuusupaSkaN26ddq0aZM2b97svF23fPny6tu3r95++20tW7ZMDz30UI5j+eijjyTlfOzY2LFj9corr8jHx0ctW7ZUtWrVtHPnTk2fPl2fffaZvvvuO1WpUiVHfwsXLtS7776rFi1a6I477tD+/fud8xnkt88zZ86obdu22rNnj6pWraqePXvq9OnTevrpp7Vv3z6Tr540e/Zsvf7662rXrp3uvPNObd26VYsXL9b27du1c+dO+fn5udWPIzDOLTz78ccf1aFDB124cEHXX3+9rr/+ev3xxx+68847NXz4cLfrzcrKUseOHbV161aFhYUpJiZGFSpU0J9//qlVq1bJ399fXbp0UdWqVTVw4EAtXbpUKSkpGjhwoLMPV6MiX375Zb377rtq06aN7rrrLh09etStek6fPq1WrVopPT1dMTExOnPmjNavX6+BAwfqwIEDmjBhgtvH9nfuHkNaWpq6deum9evXq3LlymrVqpUqVKigrVu36qmnntL69esVFxcnL6//jcMz+3rYbDa1b99eH374ob7//nvddtttpo+vJCFgBAAAAACgEG3btk2tW7fWgQMHso36ysrK0j333KOjR4/q1Vdf1T//+U9nwLFv3z517txZY8eOVdeuXXX99ddLuhzW9OnTR2fPntVrr72mUaNGZQtFNm/erOrVqzu//9e//qXt27erQ4cO+vTTTxUYGChJ+u2339S+fXu98cYb6tSpk/OW3fvvv19vv/22Fi5cmCNgNAxDixYtkpeXl/r16+dcvmTJEr3yyiu6/vrrFRcXp7p16zq3nzBhgiZNmqQRI0bkGDEpSXPmzNHixYt17733Zltups9//etf2rNnj7p27aply5apYsWKzvN/++23u/NSufTmm29q06ZNat26taTLI0I7deqk77//XosWLdKQIUPc6mfTpk2SpJYtW+ZYZxiGBg4cqAsXLuj555/XxIkTnetmz56txx57zO16v/nmG23dulUtW7bUN998owoVKjjXnT9/Xn/88Yeky7c1z507Vxs2bFBKSspVZ6KeP3++1q1bp/bt27tdiyStWLFCnTp1UlxcnPz9/SVJP/zwg2677TZNnjxZPXr0cDki1h3uHsPTTz+t9evX695779U777yj4OBgSZcD+H79+umzzz7Tf/7zHz366KOSCv563HTTTfrwww+1cePGMhMwcos0AAAAAACF7I033sgWLkqXg5dffvlFffr00TPPPJMtKKxbt67+/e9/KysrS3PmzHEuf/fdd5WQkKCuXbvq6aefztZGklq3bq2IiAhJUkpKit577z15eXlp9uzZznBRuhzMjBs3TpKyTTjSpk0bRUVFacOGDTp27Fi2vjdt2qQjR46oQ4cO2ULMF198UZK0aNEiZxAoXR7JNWHCBDVt2lRLly5VYmJijvPSrVu3HOGimT5TUlI0b948eXl5adasWc5wUboc9uQnoPu7p556yhkuSlLFihU1atQoSZfDPHft2rVLXl5e2Y7HYcOGDdq9e7euvfZaPf/889nW/eMf/9DNN9/s9n4cE962adMmW7goSUFBQWrevLnbfV3poYceyne4KEleXl6aOXOmM1yULoesjz32mOx2u2bPnm2qHnedOnVKc+bM0TXXXKMPPvjAGS5KUmBgoN577z35+Pjorbfeci4v6OvheCblzz//bN2BFHMEjAAAAAAAFKJq1aqpRYsWOZZ/+eWXkqS7777bZbt27dpJujwCz+Hrr7+WJD3yyCNX3e/27duVlpamZs2auZyE44EHHpAkfffdd7Lb7ZIuB3j33Xef7HZ7jhGHrm6PPnXqlHbu3Kl69eo5R1leyWazqU2bNsrKytL27dtzrO/Ro0eOZWb6dBxrixYtVKdOnRxt+vfvn2OZuzp37pxjWf369SVdfragOy5cuKC0tDTncyb/zjG68Z577pG3t3eO9fmpv2nTpvLy8tIHH3ygOXPm5Pq8yvxy9Vq5W0+DBg1yLHcck+PYC8uGDRt06dIlde3a1eXt7FWrVlW9evX0yy+/KC0tLVtNZl+PypUrS/pf2FsWEDACAAAAAFCIatWq5XL5oUOHJF2+LfnKySkcX+Hh4ZKUbeSf47l3rkK0v3OMQMxt8o2QkBAFBwcrLS1NZ86ccS6///77Jf0vUJSkjIwMLVmyRBUqVMgWiDqO4Y8//nB5DDabTW+++WaO43BwdW7M9Ok41sjISJfHmtcEJFdTs2bNHMsco0HT09Pd6uPcuXPZ2v2dlfXXr19fr776qlJTUzVs2DBFRESoSZMmGjVqlHbt2uV2P3+X23V8NVc7pr+PlLWa43qaM2dOrtdTfHy8DMPQ6dOns9Vk9vUICgqSpFwnSyqNeAYjAAAAAACF6O+3qTo4Rg127drV5QQoDq4m3LCKq9F0jRo10o033qgdO3Zo7969atCggVavXq0zZ86ob9++zvBE+t8xVK1aVV26dMlzX67CGlfnpqB9Wu3vt6GbceUz/4rCP//5T/3f//2fli9frq+++kqbNm3S9OnTNWPGDE2fPl0jRozId5+5XcdFyXFtmGnTtGlTNWnSJM9tfX19TdX1d45A+e+PRSjNCBgBAAAAAPAAx8i4oUOHqk+fPm61ueaaa/Tbb79p//79uuGGG/Lc1vGcxMOHD7tcf+7cOZ09e1Z+fn7OWa0d7r//fv3000/66KOPNGnSpFxnj3YcQ1hY2FUnCXGXmT6rVasmKfdjzW15UQkICJCfn5/Onj0ru92eI7QsjPqvueYaPfHEE3riiSeUmZmpxYsXa/DgwRo9erQefPDBHK95YbnaMV35PE8fHx9Jl28pd8Xdmauv5Lie2rZtq5kzZ7rVpqCvh2NEsGMUclnALdIAAAAAAHhAp06dJElxcXFut+nYsaMk6T//+c9Vt23evLn8/Py0fft258zBV1qwYIGky5OB/D3w6t+/v7y8vLRo0SKdP39eK1asUOXKlXXHHXdk265mzZpq2LChdu/erd9//93t48iLmT6vPNYDBw7kWO9qBuui1qRJE9ntdu3bty/HOsfzNpctW+ZylF5B6y9XrpwGDBigli1bKiMjI9v14Aj1MjMzC7SP3Pz8888urz/HMbVt29a5LCwsTOXKldPBgwdz1HPp0iVt3LjR5T7yOoYOHTrI29tbn3/+uS5duuRWzQV9Pfbs2SPp8qjJsoKAEQAAAAAAD+jTp48aNWqkjz76SJMnT87xPD/DMPTdd9/pu+++cy4bOnSowsLCtHr1as2YMUOGYWRrs2XLFp06dUqS5O/vryFDhshut+uxxx5TSkqKc7vff/9dU6ZMkSQ9+eSTOWqrXr26OnTooH379mnMmDG6ePGi+vbtq/Lly+fYdvz48bLb7erTp4/LWXOTkpKyzYTtjvz2GRAQoAceeEBZWVl64oknnJN1SNKPP/6oWbNm5Wv/hcERWv3www851sXExKhhw4bav3+/83VxeOedd7R582a397N+/Xp9/fXXOYKxgwcPas+ePbLZbNmeK+kYQbh3716395EfdrtdTzzxhFJTU53Ltm/frlmzZslms2n48OHO5T4+PmrdurVOnz7tfM6mdDk4/Oc//6mDBw+63Edex1CjRg0NGTJEhw4dUv/+/XXy5Mkc2+zbt0/Lli1zfl/Q18MxMZOZWbdLKm6RBgAAQImw+Dn3R/hcqd+LvS2uBACsUa5cOS1fvlxdunTR888/r1mzZqlx48aKiIhQYmKifv75Z506dUrTp09XmzZtJF2enXbJkiXq0aOHnnrqKb3xxhtq2bKl0tLStGfPHu3bt08//fSTIiIiJEkvv/yytmzZoq+++krXXnut2rdvr5SUFK1bt04XL17Uk08+qe7du7us7/7779fatWv19ttvS8p5e7TDfffdp/j4eL300ktq3ry5mjZtqjp16sgwDO3fv1+7du1SQECAHn74YbfPjZk+X375ZW3cuFGrVq1SnTp1dOutt+rMmTNat26dHnnkkWyBlSd069ZNr732mjZs2OCcSMfBy8tLc+fO1e23364XXnhBS5cu1fXXX699+/bpxx9/1D/+8Q/Nnj3brf3s3LlTTz31lMLDw9W8eXOFhoYqISFBGzduVHp6up544olstyX36NFDGzdu1O23364OHTrI399fYWFhmjp1qiXHfdddd2nnzp3O1+TcuXNat26dLl26pHHjxuWYYf35559Xly5dNHLkSP33v/9V1apVtX37dqWmpmrgwIGaN29ejn1c7RhiY2N16NAhLVu2TGvWrFHTpk1Vq1YtpaSkaPfu3dq3b5969uzpfFRBQV4PwzC0ceNGhYSE6JZbbrHkHJYEjGAEAAAAAMBD6tWrp59++klTpkxRzZo1tWXLFn3yySf6/fffdeONN+rNN9/MEezFxMRo586devTRR2UYhpYvX67vvvtOwcHBmjRpUrYZpgMDA7Vx40ZNnDhRYWFh+uyzz7Rp0ya1aNFCCxcuVGxsbK619enTxzmxR2RkpDPkdOXFF1/Uxo0b1adPH504cULLly/X+vXrlZWVpeHDh+uzzz7L97nJb5+VK1fWd999p+HDhzvPy5EjRzR16lS3n71XmNq3b6/69etr2bJlysjIyLH+5ptv1ubNm9W9e3cdOXJEn332mcqVK6cVK1aob9++bu/nrrvu0rhx41S/fn3t3LlTS5YsUXx8vNq2batly5bleM2ffPJJjRs3TgEBAVq2bJnee+89S28pDw0N1ZYtW9SxY0etX79eGzZsUKNGjfTBBx9o8uTJObbv2LGjPvvsM7Vs2VI7duzQxo0b1apVK/3www+5zt58tWPw8/PT6tWrNW/ePN18883as2ePli5dqh9//FHh4eGaOHGiXn311Wx9mn09vv32Wx09elQPPPBAsZgYp6jYjL+Pp0axER0dLUmKj4/3cCUAAKA0MjsisKRhBCNQNOx2u/P2xAYNGlgy8y5Q2sTGxmrkyJFaunSp2xP7oGR55JFHNGfOHP3yyy/OXCcv+X3vLK5ZEbdIAwAAlGBlJSQEAKA0eOSRR/T6669r6tSpBIyl0PHjxzV//nwNGDDArXCxNOGflAAAAAAAAIpAhQoVNHnyZP3444/6/PPPPV0OLPbKK69IUo6JYcoCAkYAAAAAAIAi8uCDD8owDN11112eLgUWmzFjhtLS0lSrVi1Pl1LkCBgBAAAAAAAAmEbACAAAAAAAAMA0AkYAAAAAAAAAphEwAgAAAAAAADCNgBEAAAAAUGA2m835/3a73YOVAEDJceX75ZXvoyUNASMAAAAAoMBsNpt8fHwkSSkpKR6uBgBKBsf7pY+PT4kOGMt5ugAAAAAAQOkQGBiopKQknTx5UpLk7+8vLy/GtQDA39ntdqWkpDjfLwMDAz1cUcEQMAIAAAAALBEaGqqUlBRdvHhRx44d83Q5AFAiVKhQQaGhoZ4uo0AIGAEAAAAAlvD29latWrWUlJSk5ORkZWRkeLokACi2fHx8FBgYqNDQUHl7e3u6nAIhYAQAAAAAWMbb21sRERGKiIiQYRgyDMPTJQFAsWOz2Ur0Mxf/joARAAAAAFAoStsf0AAA13jaLgAAAAAAAADTCBgBAAAAAAAAmEbACAAAAAAAAMA0AkYAAAAAAAAAphEwAgAAAAAAADCNgBEAAAAAAACAaQSMAAAAAAAAAEwjYAQAAAAAAABgGgEjAAAAAAAAANMIGAEAAAAAAACYRsAIAAAAAAAAwDQCRgAAAAAAAACmETACAAAAAAAAMI2AEQAAAAAAAIBpBIwAAAAAAAAATCNgBAAAAAAAAGAaASMAAAAAAAAA0wgYAQAAAAAAAJhGwAgAAAAAAADANAJGAAAAAAAAAKYRMAIAAAAAAAAwjYARAAAAAAAAgGkEjAAAAAAAAABMI2AEAAAAAAAAYBoBIwAAAAAAAADTCBgBAAAAAAAAmEbACAAAAAAAAMC0cp4uAAAAAChMi5+LM92234u9LawEAACgdGIEIwAAAAAAAADTCBgBAAAAAAAAmEbACAAAAAAAAMA0AkYAAAAAAAAAppXYgHH79u2aOnWq7r77btWsWVM2m002my3X7SdMmODcxtXX2LFj811DVlaWpk+frhtuuEF+fn4KDw/X//3f/2nPnj0FOTQAAAAAAACgxCixs0hPnjxZn376ab7btWnTRnXr1s2xvHnz5vnqx263q2/fvoqLi1NISIi6deumxMRELV26VCtXrtT69et100035bs+AAAAAAAAoCQpsQFj69at1bhxY7Vs2VItW7ZUVFSU0tPTr9pu6NChGjRoUIH3//777ysuLk716tXTpk2bVKVKFUnSsmXLdM899+j+++/Xnj17VK5ciT3FAAAAAAAAwFWV2PRrzJgxHt3/66+/Lkl69dVXneGiJPXp00c9evTQZ599pk8//VR9+vTxVIkAAAAAAABAoSuxz2D0pIMHD2rPnj3y8/NTt27dcqy/5557JEkrVqwo6tIAAAAAAACAIlViRzCatW7dOv3888+6ePGiatasqTvuuCPfz1/cuXOnJOn6669X+fLlc6xv1qyZJGnXrl0FLxgAAJQJi5+L83QJKIHsdruSkpIs6y80NFReXoxBAAAA+VPmAsYPP/ww2/fjx49Xnz59NHfuXAUEBLjVx5EjRyRJNWvWdLnesfzw4cMFqBQAAADIW1JSkiIiIizr79SpUwoPD7esPwAAUDaUmYCxbt26mjZtmu644w5FRkbqzJkz+uabbzR69GgtW7ZMWVlZiotzb+TAhQsXJEkVK1Z0ud7f31+SlJyc7FZ/0dHRLpfv379fUVFRSkxMdKsfAABQcnkFeroCuFLcfw+zcvSioz+bzWZpnwAAwDpZWVny9vb2dBk5lJmAccCAAdm+9/f313333acOHTrohhtu0PLly7Vlyxa1atXKQxUCAAAAAAAAJU+ZCRhzU61aNQ0ePFjTpk3TmjVr3AoYHbdSp6amulyfkpIiSQoMdG8oQnx8vMvljpGNYWFhbvUDAABKLrt7Nz6giBX338MMw7C0v9DQ0GJ/zAAAlGXFcfSiRMAoSapXr54k6fjx425tX6tWLUnSn3/+6XK9Y3lkZKQF1QEAAADu2717t1shYWJioho1alQEFQEAgNKOgFHSmTNnJP3v2YlX06RJE0nSr7/+qkuXLuWYSXrHjh2SpMaNG1tYJQAAAHB1YWFhTNQCAACKlJenC/A0wzCck7s0a9bMrTa1a9fWddddp7S0NK1cuTLH+qVLl0qSunfvbl2hAAAAAAAAQDFUJgLGhIQEvfnmmzlmdb5w4YKGDx+urVu3qmrVqrr77ruzrd+2bZsaNmyo22+/PUefo0aNkiSNHj1ap06dci7/5JNP9Nlnn6lu3brq2bNnIRwNAAAAAAAAUHyU2FukV65cqcmTJzu/z8jIkKRsk7SMHz9e3bp1U0pKih5//HGNHTtWLVu2VLVq1ZSQkKAdO3YoKSlJISEhWrp0qSpWrJhtH6mpqdq7d68uXryYY/9DhgzRqlWrFBcX5wwhExMTtXHjRvn5+WnBggUqV67Enl4AAAAAAADALSU2AUtISNDWrVtzLL9yWUJCgqTLs+GNGTNGW7Zs0e+//67vv/9e3t7eql27tgYNGqSnnnpKNWrUyNf+vby8tGTJEsXGxur999/X559/Ln9/f/Xp00cTJ07kgdkAAAAAAAAoE2yGYRieLgKuRUdHS5Li4+M9XAkAAChsi5+L83QJcKHfi709XUKeEhISFBERkW3ZqVOn3JrkpSBtAQCAZxTXrKhMPIMRAAAAAAAAQOEgYAQAAAAAAABgGgEjAAAAAAAAANMIGAEAAAAAAACYRsAIAAAAAAAAwDQCRgAAAAAAAACmETACAAAAAAAAMI2AEQAAAAAAAIBpBIwAAAAAAAAATCNgBAAAAAAAAGAaASMAAAAAAAAA0wgYAQAAAAAAAJhGwAgAAAAAAADANAJGAAAAAAAAAKYRMAIAAAAAAAAwjYARAAAAAAAAgGkEjAAAAAAAAABMI2AEAAAAAAAAYBoBIwAAAAAAAADTCBgBAAAAAAAAmEbACAAAAAAAAMA0AkYAAAAAAAAAphEwAgAAAAAAADCtnKcLAAAAAIqrxc/FmWrX78XeFlcCAABQfDGCEQAAAAAAAIBpjGAEAACwiNnRbgAAAEBJxghGAAAAAAAAAKYRMAIAAAAAAAAwjYARAAAAAAAAgGkEjAAAAAAAAABMI2AEAAAAAAAAYBoBIwAAAAAAAADTCBgBAAAAAAAAmEbACAAAAAAAAMA0AkYAAAAAAAAAphEwAgAAAAAAADCNgBEAAAAAAACAaQSMAAAAAAAAAEwjYAQAAAAAAABgGgEjAAAAAAAAANMIGAEAAAAAAACYRsAIAAAAAAAAwDQCRgAAAAAAAACmETACAAAAAAAAMI2AEQAAAAAAAIBpBIwAAAAAAAAATCNgBAAAAAAAAGAaASMAAAAAAAAA0wgYAQAAAAAAAJhGwAgAAAAAAADANAJGAAAAAAAAAKaV83QBAAAAQGmz+Lk40237vdjbwkoAAAAKHyMYAQAAAAAAAJhGwAgAAAAAAADANAJGAAAAAAAAAKYRMAIAAAAAAAAwjYARAAAAAAAAgGkEjAAAAAAAAABMI2AEAAAAAAAAYFqJDRi3b9+uqVOn6u6771bNmjVls9lks9lcbmu327Vp0yaNHj1azZs3V2BgoHx9fVWnTh09+uijOnjwYL73P2jQIOc+XX29/fbbBT1EAAAAAAAAoNgr5+kCzJo8ebI+/fRTt7Y9cOCAbr31VklS1apVddttt8nb21vbtm3TO++8o4ULF2rVqlVq27Ztvuvo0qWLqlatmmN5gwYN8t0XAAAAAAAAUNKU2ICxdevWaty4sVq2bKmWLVsqKipK6enpLre12Wzq1KmTxo4dqw4dOjhHOqanp+vRRx/V3Llzdf/992vfvn0qX758vuoYO3asYmJiCno4AAAAAAAAQIlUYgPGMWPGuL1tnTp19OWXX+ZY7uvrq9mzZysuLk5HjhzR999/r/bt21tZJgAAAAAAAFCqldhnMFrFz89P9evXlyQdO3bMw9UAAAAAAAAAJUuJHcFoFbvdrsOHD0uSy2cpXs0nn3yiZcuWKSsrS7Vr11b37t3VsGFDq8sEAAAAAAAAiqUyHzAuWrRIp06dUnh4uG655ZZ8t585c2a278eMGaPhw4crNjZW5cqV+dMLAAAAAACAUq5MJ2BHjx7VyJEjJUmTJk2Sr6+v221vvPFGtW7dWrfddptq1qypEydOaPXq1Ro3bpxmz54tHx8fTZ8+3a2+oqOjXS7fv3+/oqKilJiY6HZdAADAc7wCPV0BSoP8/O6XlJTkcpljUsPCagsAADwjKytL3t7eni4jhzIbMKakpOjuu+9WYmKievXqpUcffTRf7UeMGJHt+9q1a+sf//iH2rdvr2bNmmnWrFkaNWqUrrnmGivLBgAARWDdu5s8XQIAAABQYpTJgPHSpUvq27evfvzxR7Vt21YLFy60rO/o6Gj16NFDS5cu1dq1azVo0KCrtomPj8+1L0kKCwuzrD4AAHB19mRPV4CyLD+/+xmGkWNZaGioW30UpC0AAPCM4jh6USqDs0jb7XYNHDhQq1evVtOmTbVixQr5+flZuo969epJko4fP25pvwAAAAAAAEBxU+YCxieeeEKLFi1S/fr19cUXXygkJMTyfZw5c0aS5O/vb3nfAAAAAAAAQHFSpgJGxwQstWrV0ldffaWIiAjL95Genq6VK1dKkpo1a2Z5/wAAAAAAAEBxUmYCxunTp+vFF19U1apV9fXXX6tWrVpXbbNt2zY1bNhQt99+e7blv/32mz788EOlp6dnW56QkKB+/frp6NGjatKkidq0aWPpMQAAAAAAAADFTYmd5GXlypWaPHmy8/uMjAxJUqtWrZzLxo8fr27duunnn3/WP//5T0mXZ3t+8cUXXfY5dOhQtW3b1vl9amqq9u7dq4sXL2bb7sSJE3rwwQc1YsQItWjRQuHh4Tp27Ji2b9+u5ORk1axZUx9//LFsNptlxwsAAAAAAAAURyU2YExISNDWrVtzLL9yWUJCgiTp7NmzzlnyNm/erM2bN7vsMyYmJlvAmJv69etr5MiR2rJli3755RclJSXJ19dX9evXV/fu3TVixAhVqlTJzGEBAAAAAAAAJUqJDRgHDRqkQYMGubVtTEyMM2DMj9zaVa9eXdOnT893fwAAAAAAAEBpU2aewQgAAAAAAADAegSMAAAAAAAAAEwrsbdIAwAAAKXR4ufi3N72fMq5QqwEAADAPYxgBAAAAAAAAGAaASMAAAAAAAAA0wgYAQAAAAAAAJhGwAgAAAAAAADANAJGAAAAAAAAAKYxizQAAACAMiE/M3Rfqd+LvS2uBACA0oWAEQAAAPAwu2HXhdTkfLdLTst/GwAAAKsRMAIAAAAediE1WY/EDvZ0GQAAAKYQMAIAAAAWMDsKUZLOp563rI64F1cqyD/46vtMOWfZPgEAQNlGwAgAAABYgFGIAACgrGIWaQAAAAAAAACmMYIRAAAAKIZeezhWQRWD8t0uoGJgIVQDAACQOwJGAAAAoBgKqhjk1rMUAQAAPI2AEQAAACgk04a9oUA/cyMKGYkIAABKCgJGAAAAoJAE+gUyChEAAJR6TPICAAAAAAAAwDQCRgAAAAAAAACmcYs0AAAAcAW7YdeF1OR8t0tOy38bAACA0oCAEQAAALjChdRkPRI72NNlAAAAlBjcIg0AAAAAAADANEYwAgAAAJAkxb24Ml+zXvd7sXchVgMAAEoKRjACAAAAAAAAMI0RjAAAAMBVTBv2hgL9AvPdLqBi/tsAAACUNASMAAAAwFUE+gXm69ZhAACAsoRbpAEAAAAAAACYRsAIAAAAAAAAwDQCRgAAAAAAAACmETACAAAAAAAAMI2AEQAAAAAAAIBpBIwAAAAAAAAATCNgBAAAAAAAAGBaOU8XAAAAAKBkWvxcnOm2/V7sXeT7BAAAhYOAEQAAAKWO3bDrQmqyqbbJaebaAQAAlFUEjAAAACh1LqQm65HYwZ4uAwAAoEzgGYwAAAAAAAAATGMEIwAAKJV4ThsAAABQNAgYAQAAUGyZfZYiz1EEAAAoOgSMAAAAKLasfJbitGFvKNAv0FTbgIrm2gEAAJQFBIwAAAAoEwL9AhXkH+zpMgAAAEodAkYAAABcldlblXMTUDFQXjbmGwQAACgNCBgBAABwVVbeqixJ74z4gNGEAAAApQQBIwAAAEoUs89S5DmKAAAAhYOAEQAAACUKz1IEAAAoXnjwDQAAAAAAAADTGMEIAAAAU9y9VTk5LVlP/+fJIqgIAAAAnkDACAAAAFO4VRkAAACSxQHj4MGD9cgjj6hVq1ZWdgsAAIBSJjkt2dLtAAAA4DmWBozz5s3T/Pnz1ahRIz388MN64IEHVKlSJSt3AQAAgFKAW6ax+Lk4T5cAAAAsYukkLwsWLNCtt96q+Ph4PfXUU6pRo4YeeOABffPNN1buBgAAAAAAAEAxYekIxvvuu0/33Xef9u/frzlz5mjevHn66KOPtHDhQtWvX19Dhw7VwIEDFRYWZuVuAQAAAKDQFGS0Zb8Xe1tYCQAAxZOlIxgd6tSpo6lTp+ro0aNaunSpunTpoj/++EPPPPOMatasqX79+mnt2rWFsWsAAAAAAAAARahQZ5EuV66c7r77bt199906evSoXn31Vb355ptasmSJlixZotq1a+uxxx7TI488oooVKxZmKQAAAPCQgIqBemfEB5b2BwAAgOKjUANGh3Xr1mnOnDlavny5JMnPz0/NmjXT5s2b9fTTTys2Nlaff/65rr/++qIoBwAAAEXIy+alIP9gT5cBAACAQlIot0hL0smTJzV16lTVq1dPnTp10n//+1/VrVtXb7zxho4dO6ZvvvlGBw8e1KOPPqojR47oySeZSRAAAAAAAAAoaSwdwWgYhtasWaM5c+Zo5cqVunTpknx9fdW/f389+uijatu2bbbta9asqTfffFN79+7Vli1brCwFAAAAAAAAQBGwNGCMiorSn3/+KcMwVLduXQ0bNkyDBw9WaGjoVdutX7/eylIAAAAAAAAAFAFLb5E+duyYevfurS+//FK///67nn766auGi5I0evRorVu3Ll/72r59u6ZOnaq7775bNWvWlM1mk81mu2q7uXPn6qabblJAQIAqV66sO++8U99//32+9u2QlZWl6dOn64YbbpCfn5/Cw8P1f//3f9qzZ4+p/gAAAAAAAICSxtIRjEePHlXVqlXz3a5+/fqqX79+vtpMnjxZn376ab7ajBw5UrGxsfLz81Pnzp118eJFffXVV/ryyy+1dOlS9erVy+2+7Ha7+vbtq7i4OIWEhKhbt25KTEzU0qVLtXLlSq1fv1433XRTvuoDAAAAAAAAShpLRzD+61//0vvvv3/V7ebOnashQ4YUaF+tW7fW+PHj9dlnn+n48ePy9fXNc/uvv/5asbGxCg0N1c6dO7V8+XKtWbNG33zzjby9vTV48GCdPXvW7f2///77iouLU7169fTbb79p6dKl2rBhg5YsWaLU1FTdf//9yszMLNAxAgAAAAAAAMWdpQHj3Llz9e233151u++++07z5s0r0L7GjBmjSZMmqXv37m6Nmnz99dclSePGjVO9evWcy1u3bq1HH31UZ8+e1Xvvvef2/h39vfrqq6pSpYpzeZ8+fdSjRw/t27cv3yMsAQAAAAAAgJLG0oDRXRkZGfL29i6y/aWlpTmf8XjPPffkWO9YtmLFCrf6O3jwoPbs2SM/Pz9169atwP0BAAAUFbth1/mUc/n+Sk5L9nTpAAAAKKYsfQajOwzD0I4dOxQeHl5k+9y7d6/S09MVHh6umjVr5ljfrFkzSdKuXbvc6m/nzp2SpOuvv17ly5cvcH8AAABF5UJqsh6JHezpMgAAAFCKFDhgvO2227J9v2bNmhzLHDIzM7V//36dOHFCDzzwQEF37bYjR45IkstwUZL8/f0VEhKiM2fOKDk5WYGBgQXqz7H88OHDZksGAAAAAAAASoQCB4wbNmxw/r/NZtOJEyd04sSJXLcvX7687rrrLk2bNq2gu3bbhQsXJEkVK1bMdRt/f3+dPXvWrYDxav35+/tLkpKT3buVKDo62uXy/fv3KyoqSomJiW71AwAA/scr74/zMsvLZmFfAZe/UDK5uhZ4Ta3H7/IAACtlZWUV6WMH3VXggPHgwYOSLt/6fO211+qee+7Ra6+95nJbHx8fhYWFubytGAAAAAAAAEDJU+CAMTIy0vn/L7zwgm688cZsy4qDgIDL/wybmpqa6zYpKSmSdNXRi+70l5++JCk+Pt7lcsfIxrCwMLf6AQAA/2NnThKX7Ck5l00b9oYC/fI/5LOiPZDzXIK5uhbsFyS7UfS1lGb8Lg8AsFJxHL0oWTzJywsvvGBld5apVauWJOnPP/90uT4lJUVnz55VpUqV3AoFr9afY3lxC1oBAABcCfQLVJB/sKfLAAAAQAlV5LNIe0KDBg3k6+urhIQE/fXXX6pRo0a29Tt27JAkNW7c2K3+mjRpIkn69ddfdenSpRy3fOe3PwAAgPywG3ZdSDU3dDA5jSGHAAAAsFaBAkYvLy95eXlp9+7dql+/fr6GadpsNmVmZhZk927z8/PTbbfdptWrV2vJkiUaOXJktvVLly6VJHXv3t2t/mrXrq3rrrtOe/bs0cqVK9WrV68C9QcAAHK3+Lk4T5dQ7FxITdYjsYM9XQYAAAAgqYABY61atWSz2Zwj+K655hrZbBZOTWihUaNGafXq1ZoyZYq6deumevXqSZI2b96sd955RyEhIXrooYeytdm2bZsefPBB1ahRQ2vXrs3R38MPP6zRo0frlltuUUREhCTpk08+0Weffaa6deuqZ8+eRXNwAACgRDI7EvF86vlCqAYAAAAwp0AB46FDh/L8vjCtXLlSkydPdn6fkZEhSWrVqpVz2fjx49WtWzdJUseOHTVixAjFxsaqadOm6tSpkzIyMvTVV1/JMAx98MEHCgkJybaP1NRU7d27VxcvXsyx/yFDhmjVqlWKi4tTw4YNdfvttysxMVEbN26Un5+fFixYoHLlysQd6AAAwCRGIgIAAKA0KLEJWEJCgrZu3Zpj+ZXLEhISsq2bMWOGmjZtqlmzZumrr76Sj4+POnbsqPHjx+uWW27J1/69vLy0ZMkSxcbG6v3339fnn38uf39/9enTRxMnTlSjRo3MHRgAAAAAAABQghRpwJiYmKiQkBBLRvYNGjRIgwYNKtR2MTExMgwj1/Xe3t4aNWqURo0ale86AAAArPTaw7EKqhhkqm1AxUCLqwEAAEBZ4mVlZz/++KMmTZqk3bt3Z1seFxenqlWrqkqVKgoNDVVsbKyVuwUAACjzgioGKcg/2NSXl83SXwkBAABQxlg6gnHmzJn673//q8cee8y57ODBg+rXr58uXbqkatWq6eTJkxo1apSaNGmimJgYK3cPAABQ4k0b9oYC/fI/opBRiAAAAPAUS/+5esuWLbrxxhsVGhrqXPb+++/r0qVLmjZtmv766y9t3bpVXl5ejGIEAABwIdAvkFGIAAAAKFEs/U305MmTqlWrVrZlX331lfz9/fX4449Lkpo3b6527dpp586dVu4aAAAAAAAAgAdYGjBmZWUpMzPT+f2FCxe0Y8cOtWnTRj4+Ps7l1atX14kTJ6zcNQAAAAAAAAAPsDRgrFWrlrZv3+78fuXKlcrMzFTHjh2zbXf+/HkFBwdbuWsAAAAAAAAAHmBpwNi9e3cdOXJEd999t2bOnKmnn35aXl5e6tmzZ7btfvrpJ0VGRlq5awAAAAAAAAAeYOks0k8//bQ+/vhjLV++XMuXL5ckjRo1SvXq1XNus3XrVv3111/q37+/lbsGAADwCLth14XUZFNtk9PMtQMAAACKE0sDxrCwMO3atUtLly5VQkKCmjdvrttuuy3bNidOnNCIESM0YMAAK3cNAADgERdSk/VI7GBPlwEAAAB4jKUBoyQFBARo0KBBua7v2bNnjlumAQAAAAAAAJRMlj6DEQAAAAAAAEDZYvkIRkk6ePCgNm3apOPHjys9Pd3lNjabTePHjy+M3QMAAAAAAAAoIpYGjBkZGRo6dKg++ugjSZJhGLluS8AIAABKq2nD3lCgX6CptgEVzbUDAAAAPMXSgPH555/XggULFBISogEDBqh+/foKDOSXZAAAULYE+gUqyD/Y02UAAAAARcLSgHHhwoUKCQnRTz/9pMjISCu7BgAAAAAAAFAMWTrJy6lTp9SuXTvCRQAAAAAAAKCMsHQEI8EiAAAoqeyGXRdSk/PdLjkt/20AAACA0sTSgHHIkCF66aWXlJCQoPDwcCu7BgAAKFQXUpP1SOxgT5cBAAAAlDiW3iL9zDPP6I477lCHDh20fv36PGeRBgAAAAAAAFDyWTqCsW7dupKkw4cPq2PHjipfvryqVq0qL6+cOabNZtP+/fut3D0AAAAAAACAImZpwHjo0KFs32dkZOjIkSNW7gIAAAAAAABAMWJpwGi3263sDgAAwKOmDXtDgX6B+W4XUDH/bQAAAICSytKAEQAAwJPMzgQtuZ4NOtAvUEH+wQUtCwAAACjVCBgBAECpwUzQAAAAQNGzdBZphy+//FK9e/dWjRo15Ovrq4ceesi57osvvtCoUaN07Nixwtg1AAAoBex2uxISEpSQkKDzKefc/0o97+nSAQAAgDLH8hGMI0aM0KxZs2QYhgICAnTp0iUZhuFcX61aNc2YMUPXXHONnnrqKat3DwAASoGkpCRFRER4ugwAAAAAbrA0YJw/f75mzpypFi1a6D//+Y+aNm0qL6/sgyQbN26sa665RitWrCBgBACgFLPb7UpKSjLVNiEhweJqAAAAABQWSwPGt956SyEhIVq5cqXCw8Nz3a5x48b65ZdfrNw1AAAoZorLKMTXHo5VUMUgU22ZDRoAAAC4OksDxl9//VXt27fPM1yUpODgYJ08edLKXQMAALgUVDGImaABAACAQmT5MxhtNttVtzl27Jj8/Pys3jUAACjFzI5EZBQiAAAAULgsDRjr1aunHTt26NKlSypfvrzLbZKTk/Xzzz8rOjrayl0DAIBSjpGIAAAAQPFkacDYt29fPffccxo7dqz+/e9/u9zm2Wef1blz59SvXz8rdw0AAEqAacPeUKCfuRGFjEQEAAAAiidLA8aRI0dq8eLFmjFjhr7//nv17NlTkrR//35Nnz5dcXFx+vbbb9WsWTM9/PDDVu4aAACUAIF+gYxCBAAAAEoZSwNGPz8/ff311xo0aJBWr16tbdu2SZI2bdqkTZs2SZI6deqkBQsWyMfHx8pdAwAAAAAAAPAAyyd5CQ8P18qVK7Vz5059+eWXOnTokOx2u2rWrKlOnTrppptusnqXAAAAAAAAADzE8oDRoUmTJmrSpElhdQ8AAAAAAACgGChQwDh//vwC7fzBBx8sUHsAAAAAAAAAnlWggHHQoEGy2Wz5bmcYhmw2GwEjAAAlgN1uV1JSUr7bJSYmFkI1AAAAAIqbAgWMzz//fI6Acf/+/VqwYIEqVqyozp07KyoqSpJ0+PBhffnll0pJSdGAAQNUp06dguwaAAAUkaSkJEVERHi6DAAAAADFVIECxgkTJmT7/o8//tBNN92kAQMGaMaMGapcuXK29WfOnNHIkSO1YsUKbdmypSC7BgAAAAAAAFAMeFnZ2bPPPqtKlSrpgw8+yBEuSlKlSpX03nvvKSQkRM8++6yVuwYAAAAAAADgAZYGjBs2bFCrVq3k7e2d6zblypVTq1attHHjRit3DQAAAAAAAMADCnSL9N+lpaXp+PHjV93uxIkTunjxopW7BgAARWj37t0KCwtze/u4F1dKkgIqBhZWSQAAAAA8xNKAsXHjxtq0aZO+/vprdezY0eU2a9eu1TfffKObbrrJyl0DAIAiFBYWpvDwcLe3D/IPLsRqAAAAAHiS5c9gtNvtuuuuuzRkyBB98cUX+u233/Tbb7/piy++0EMPPaRu3brJMAyNHTvWyl0DAAAAAAAA8ABLRzD26NFDs2fP1qhRozR37lzNmzcv23rDMOTr66uZM2eqR48eVu4aAAAAAAAAgAdYGjBK0qOPPqo777xT7733nr799lsdO3ZMklStWjW1a9dOgwcPVlRUlNW7BQAAAAAAAOABlgeMklSrVi1NnDixMLoGAAAm2O12JSUlmWqbmJhocTUAAAAASpNCCRgBAEDxkpSUpIiICE+XAQAAAKAUsnSSFwAAAAAAAABlCwEjAAAAAAAAANMIGAEAAAAAAACYxjMYAQAoQcxO1uJqopbdu3crLCzMVB2hoaGm2gEAAAAofQgYAQAoQaycrCUsLEzh4eGW9AUAAACg7OIWaQAAAAAAAACmETACAAAAAAAAMI2AEQAAAAAAAIBpPIMRAIASzuxkLUzUAgAAAMAKBIwAAJRwTNYCAAAAwJPKzC3SGzZskM1mu+rXpEmT3OovKioqz35+++23Qj4iAAAAAAAAwPPKzAjGqlWrauDAgS7XZWVlacGCBZKkdu3a5avf3PoMDg7OX4EAgDLDbrcrKSnJVNvExESLqwEAAACAgikzAWPDhg01d+5cl+tWr16tBQsW6JprrlFMTEy++s2tTwAAcpOUlKSIiAhPlwEAAAAAligzAWNeHKMX77//ftlsNg9XAwBA8bX4uThPlwAAAACgmCnzAWNKSoo+/fRTSdIDDzzg4WoAACWJ2Vuduc0ZAAAAQGlS5gPGTz75RCkpKbrxxhvVqFGjfLd/7bXXtH//fvn6+io6Olq9e/dmJk8AKCO41RkAAAAACBidt0ebHb04evTobN8/9dRTmjlzpoYMGVLg2gAAZcfu3bsVFhZmqm1oaKjF1QAAAACA+8p0wHj8+HGtXbtW3t7e6t+/f77a9ujRQx06dFDz5s0VHh6uAwcO6P3331dsbKyGDh2q0NBQ9ezZ062+oqOjXS7fv3+/oqKiuJUOAAqR3W7X6dOnTbU1284Vm81m+jnAVtZxNV6BRbYrAIXMy8VbjlfA5S9Yh9/lAQBWysrKkre3t6fLyKFMB4yLFi1SVlaWunbtqqpVq+ar7RtvvJHt++joaP373/9Ww4YNNWzYMI0ZM8btgBEA4DmnT5/Wdddd5+kyAAAAAKDEKtMBY0Fvj3bloYce0rhx47R3714dOnRIUVFRV20THx/vcrljZKPZW+YAAFdnGIal/Zm91Tk0NFReXl6W1lIY7MmergCAVewpLpZdkOzWvi2WefwuDwCwUnEcvSiV4YBxz549+umnnxQQEKBevXpZ1q+Xl5fq1KmjU6dO6fjx424FjACA0iMsLIzJvgAAAACUKcV/qEQh+fDDDyVJd999typWrGhp32fOnJEk+fv7W9ovAAAAAAAAUNyUyRGMhmFo4cKFkqy9PVq6fLvz3r17VbFiRTVs2NDSvgEARYMZnQEAAADAfWUyYNy0aZMOHz6sGjVq6Lbbbst1u1mzZmnWrFnq3bu3Xn75ZefyVatWqUKFCjna7tq1S/369ZNhGBo6dKh8fHwK7RgAAIWH25wBAAAAwH1lMmB0TO5y33335flA/cTERO3du1fHjx/Ptnzbtm2aOHGiIiMj1aRJE1WsWFEHDhzQjh07lJmZqZiYGE2dOrVQjwEAAAAAAAAoDspcwJienq6lS5dKkgYMGGCqjy5duujo0aP64Ycf9N133+ncuXMKCgpS27Ztdf/992vw4MHFdlYfAAAAAAAAwEplLmD09fXV6dOn3dp2woQJmjBhQo7lrVu3VuvWrS2uDAAAAAAAACh5yuws0gAAAAAAAAAKrsyNYAQAlE52u11JSUn5bpeYmFgI1QAAAABA2UHACAAoFZKSkhQREeHpMgAAAACgzOEWaQAAAAAAAACmETACAAAAAAAAMI2AEQAAAAAAAIBpPIMRAFBq7d69W2FhYfluFxoaWgjVAAAAAEDpRMAIACg2zM4ELbmeDTosLEzh4eEFLQsAAAAAkAcCRgBAscFM0AAAAABQ8vAMRgAAAAAAAACmETACAAAAAAAAMI2AEQAAAAAAAIBpPIMRAGApqydqMTsTtMRs0AAAAABQFAgYAQAumQ0KExISFB0dbVkdzAQNAAAAAMUbASMAwCVmdAYAAAAAuINnMAIAAAAAAAAwjYARAAAAAAAAgGncIg0AKHTx8fGmn6PIRC0AAAAAULwRMAIA3GZ2RufQ0FB5eTFoHgAAAABKIwJGAIDbmNEZAAAAAPB3BIwAUIrZ7XYlJSWZapuYmGhxNQAAAACA0oiAEQBKsaSkJEVERHi6DBQzi5+L83QJAAAAAEoRHogFAAAAAAAAwDQCRgAAAAAAAACmcYs0AJQAZp+lyHMUAQAAAACFjYARAEoAK5+luHv3boWFhZlqGxoaakkNAAAAAIDSg4ARAMqYsLAwhYeHe7oMAAAAAEApQcAIAEXE7G3OErc6AwAAAACKLwJGACgiVt7mDAAAAABAcUHACAAllNlnKfIcRQAAAACAlQgYAaCE4lmKAAAAAIDiwMvTBQAAAAAAAAAouRjBCAD5ZHayFlcTtZi9zVniVmcAAAAAQPFAwAgA+WTlZC3c5gwAAAAAKOm4RRoAAAAAAACAaQSMAAAAAAAAAEwjYAQAAAAAAABgGs9gBAALmJ2shYlaAAAAAAAlHQEjgDLJ7EzQkuvZoJmsBQAAAABQVhEwAiiTrJwJGgAAIDeLn4sz1a7fi70trgQAgMLDMxgBAAAAAAAAmMYIRgAlmtlbnV3d5gwAAAAAAPKPgBFAicatzgAAAAAAeBYBIwD8f2ZngpaYDRoAAAAAUHYRMBZzWVlZSkhIKFAfoaGh8vLicZvA1TATNAAAAAAA+UfAWMzt3bu3wLd/njp1itAEAAAAAAAAhYKAEUCpY/ZWZ25zBgAAAAAg/wgYAZQ63OoMAAAAAEDR4cF8AAAAAAAAAExjBGMJ4e4tn4mJiWrUqFERVAQAAAAAAAAQMJYY3PIJAAAAAACA4oiAEYDH2e12JSUlmWqbmJhocTUAAAAAACA/CBgBWMZsUJiQkKDo6OhCqAgAAAAAABQ2AkYAlklKSlJERISnywDKjMXPxXm6BAAAAABgFmkAAAAAAAAA5hEwAgAAAAAAADCNW6QBZFNcJlyJj483PXN6aGioZXUAAAAAAIC8ETACyMbq5yju3r1bYWFh+W4XGhoqLy8GWQMAAAAAUNwRMAIoVGFhYaZHIgIAAAAAgOKP4UEAAAAAAAAATCtTAWNMTIxsNluuX2vWrMlXf2fOnNGIESMUGRkpX19fRUZGauTIkTp79mzhHAAAAAAAAABQzJTJW6T79OmjgICAHMtr1Kjhdh+JiYlq3bq19u3bp2uvvVa9evVSfHy8YmNjtXr1am3evFmVK1e2smwgX8xO1uJqohazz1GUmHAFAAAAAIDSrkwGjNOmTVNUVFSB+hg5cqT27dunu+++W//9739VrtzlU/nkk09q5syZGjVqlObOnVvwYgGTrJyshecoAgAAAACA3JSpW6Stcvz4cS1atEg+Pj6aPXu2M1yUpNdee03h4eFasGCBTp065cEqAQAAAAAAgMJHwGjCmjVrZLfb1a5dO1WpUiXbOl9fX3Xv3l1ZWVlatWqVhyoEAAAAAAAAikaZvEX6vffeU1JSkry8vFS/fn316tVLtWrVcrv9zp07JUnNmjVzub5Zs2Z6//33tWvXLkvqBQAAAAAAAIqrMhkwTpkyJdv3Tz/9tMaPH6/x48e71f7IkSOSpJo1a7pc71h++PBht/qLjo52uXz//v3O/09KSpLNZrtqX64m9XC3LUoXV9fCd999Z2ryIcMwXE7+AsCzvAI9XQGAkszLxa+HXgGXv+B5/O4FAHAlKytL3t7eni4jhzIVMN56660aOnSobrnlFlWrVk1Hjx7V0qVLNWXKFD3//PMKCgrSiBEjrtrPhQsXJEkVK1Z0ud7f31+SlJycbF3xgAUqV65sejZoAAAAAAAAV8pUwDhp0qRs39evX1//+te/1KJFC3Xp0kUTJkzQsGHD5OfnV6R1xcfHu1weHR2t3bt3S5JCQ0PdCoYMw8ixzN22KF24FoDSz86/YwEoAHuKi2UXJHvOXyHgAfzOBgBwpTiOXpSY5EWS1LlzZ7Vo0UJnz57V1q1br7p9QMDl+0ZSU1Ndrk9JufzbWmAg964BAAAAAACgdCNg/P/q1asnSTp+/PhVt3VMCPPnn3+6XO9YHhkZaVF1AAAAAAAAQPFUpm6RzsuZM2ck/e/5iXlp0qSJJGnHjh0u1zuWN27c2KLqAACl1eLn4jxdAgAAAAAUCAGjpISEBG3atEmS1KxZs6tu37VrV3l5eWnTpk06deqUIiIinOvS09O1YsUKeXt768477yy0mlE22O12l7NBu4OZB4GiRVAIAAAAoKwqM7dIf//991q+fLmysrKyLT906JB69+6tlJQU9ejRQzVr1nSumzVrlho2bKhnn302W5tq1aqpf//+ysjI0D/+8Q9lZmY6140ePVoJCQkaMGBAtuARMCMpKUkRERGmvho1auTp8gEAAAAAQBlQZkYw/v777xo8eLCqVq2qZs2aKSQkRIcPH9b27dt18eJFRUdHa86cOdnaJCYmau/evS6fyzhjxgxt2bJFy5YtU8OGDdWiRQvFx8fr119/Vb169fT6668X1aEBAAAAAAAAHlNmRjDefPPNGj58uKpXr64ffvhBH3/8sX799Vc1bdpU//73v/XDDz/ka8RhWFiYtm3bpieeeEIZGRmKi4vTuXPn9OSTT2rbtm2qXLlyIR4NAAAAAAAAUDyUmRGM1113nWbPnp2vNhMmTNCECRNyXV+5cmW98cYbeuONNwpYHQAAAAAAAFAylZmAEfAks5O1uJqoZffu3QoLCzNVR2hoqKl2AAAAAAAAuSFgBIqAY7IWK4SFhSk8PNySvgAAAAAAAAqqzDyDEQAAAAAAAID1CBgBAAAAAAAAmEbACAAAAAAAAMA0nsEIeIjZyVqYqAUAAAAAABQnBIyAm8zOBC25ng2ayVoAAAAAAEBpQMAIuMnKmaABAAAAAABKC57BCAAAAAAAAMA0RjACAPD/LX4uztMlAAAAAECJwwhGAAAAAAAAAKYxghEoALMzQUvMBg0AAAAAAEoHAkagAJgJGgAAAAAAlHXcIg0AAAAAAADANAJGAAAAAAAAAKYRMAIAAAAAAAAwjYARAAAAAAAAgGkEjAAAAAAAAABMI2AEAAAAAAAAYFo5TxcAFCW73a6kpCRTbRMTEy2uBgAAAAAAoOQjYESZkpSUpIiICE+XAQAAAAAAUGpwizQAAAAAAAAA0wgYAQAAAAAAAJhGwAgAAAAAAADANJ7BiBLJ7GQtriZq2b17t8LCwkzVERoaaqodAAAAAABAaUHACI8pyIzOCQkJio6OtqSOsLAwhYeHW9IXAAAAAABAWUPACI9hRmcAAAAAAICSj2cwAgAAAAAAADCNgBEAAAAAAACAadwijVIjPj7e1LMUmagFAAAAAADAPAJGFFhxmtHZy4tBuQAAAAAAAEWJgBEFZuVkLczoDAAAAAAAULIw3AsAAAAAAACAaQSMAAAAAAAAAEwjYAQAAAAAAABgGs9gRKEwO1kLMzoDAAAAAACULASMKBRM1gIAAAAAAFA2cIs0AAAAAAAAANMIGAEAAAAAAACYRsAIAAAAAAAAwDQCRgAAAAAAAACmETACAAAAAAAAMI2AEQAAAAAAAIBp5TxdAAAAVlv8XJynSwAAAACAMoMRjAAAAAAAAABMI2AEAAAAAAAAYBq3SEOSZLfblZSUZKptYmKixdUAAAAAAACgpCBghCQpKSlJERERni4DAAAAAAAAJQwBYxngzgjDhISEIqgEAAAAAAAApQ0BYxnQqFEjT5cAAAAAAACAUopJXgAAAAAAAACYxghG5Co+Pl7h4eGm2oaGhlpcDQAAAAAAAIojAkbkKjw83HTACAAAAAAAgLKBgLGUCQ0N1alTpyzrCwAAAAAAAMgLAWMp4+XlxahDAAAAAAAAFBkmeQEAAAAAAABgGgEjAAAAAAAAANMIGAEAAAAAAACYRsAIAAAAAAAAwLQyEzCmpqZq+fLleuihh9SgQQNVqFBB/v7+atKkiSZNmqQLFy7kq7+oqCjZbLZcv3777bdCOhIAAAAAAACg+Cgzs0gvXLhQDz/8sCTpuuuuU48ePXT+/Hl9//33euGFF7Ro0SJt3LhRERER+ep34MCBLpcHBwcXuGYAAAAAAACguCszAWP58uU1bNgwjRw5Utddd51z+fHjx9WtWzf99NNPGjlypBYuXJivfufOnWtxpQAAAAAAAEDJUWZukR44cKDeeeedbOGiJFWrVk1vvvmmJOmTTz5RRkaGJ8oDAAAAAAAASqQyEzDmpUmTJpKk9PR0JSUlebgaAAAAAAAAoOQoM7dI5+XAgQOSLt9GXbly5Xy1fe2117R//375+voqOjpavXv3Vnh4eGGUCQAAAAAAABQ7BIySYmNjJUldu3aVr69vvtqOHj062/dPPfWUZs6cqSFDhlhWHwAAAAAAAFBclfmAcdWqVXrvvfdUvnx5TZ482e12PXr0UIcOHdS8eXOFh4frwIEDev/99xUbG6uhQ4cqNDRUPXv2dKuv6Ohol8v379/v/P+kpCTZbDa36wOAsswr0NMVAEDx5+XiV0uvgMtf8LzExERPlwAAKIaysrLk7e3t6TJyKNMB42+//aYBAwbIMAy99tprzmcxuuONN97I9n10dLT+/e9/q2HDhho2bJjGjBnjdsAIAAAAAAAAlFRlNmD866+/1LVrV505c0ajRo3SiBEjLOn3oYce0rhx47R3714dOnRIUVFRV20THx/vcnl0dLR2794tSQoNDVVYWJglNQJAaWdP9nQFAFD82VNcLLsg2Y2irwU58bs/AMCV4jh6USqjs0ifPn1anTt31uHDhzV48GBNmzbNsr69vLxUp04dSdLx48ct6xcAAAAAAAAojspcwHjhwgXdcccd2r17t+6++27NmTPH8mcbnjlzRpLk7+9vab8AAAAAAABAcVOmAsb09HT17NlT27ZtU5cuXbRo0SLLh5bGx8dr7969qlixoho2bGhp3wAAAAAAAEBxU2YCxqysLPXv31/r1q1Tu3bt9Mknn8jHxyfPNrNmzVLDhg317LPPZlu+atUqrVu3Lsf2u3btUt++fWUYhoYOHXrV/gEAAAAAAICSrsxM8jJr1izFxcVJuvzA5H/84x8ut5s2bZrzgcqJiYnau3dvjmcpbtu2TRMnTlRkZKSaNGmiihUr6sCBA9qxY4cyMzMVExOjqVOnFu4BAQAAAAAAAMVAmQkYHc9FlOQMGl2ZMGHCVWds69Kli44ePaoffvhB3333nc6dO6egoCC1bdtW999/vwYPHlxsZ/UBAAAAAAAArFRmAsYJEyZowoQJlrRp3bq1WrdubU1hAAAAAAAAQAlWZp7BCAAAAAAAAMB6BIwAAAAAAAAATCNgBAAAAAAAAGAaASMAAAAAAAAA0wgYAQAAAAAAAJhGwAgAAAAAAADANAJGAAAAAAAAAKYRMAIAAAAAAAAwrZynCwAAAAAAZLf4uTjTbfu92NvCSgAAuDpGMAIAAAAAAAAwjYARAAAAAAAAgGkEjAAAAAAAAABM4xmMAIBiqSDPngIAAAAAFB1GMAIAAAAAAAAwjYARAAAAAAAAgGkEjAAAAAAAAABMI2AEAAAAAAAAYBoBIwAAAAAAAADTCBgBAAAAAAAAmEbACAAAAAAAAMA0AkYAAAAAAAAAphEwAgAAAAAAADCNgBEAAAAAAACAaQSMAAAAAAAAAEwjYAQAAAAAAABgGgEjAAAAAAAAANMIGAEAAAAAAACYRsAIAAAAAAAAwDQCRgAAAAAAAACmETACAAAAAAAAMI2AEQAAAAAAAIBpBIwAAAAAAAAATCNgBAAAAAAAAGAaASMAAAAAAAAA0wgYAQAAAAAAAJhGwAgAAAAAAADANAJGAAAAAAAAAKYRMAIAAAAAAAAwjYARAAAAAAAAgGkEjAAAAAAAAABMI2AEAAAAAAAAYBoBIwAAAAAAAADTCBgBAAAAAAAAmFbO0wUAAEqvxc/FeboEAAAAAEAhYwQjAAAAAAAAANMIGAEAAAAAAACYRsAIAAAAAAAAwDQCRgAAAADA/2vvzqO6rvI/jr++gCyKSQruiqK4pLkgLUwqmTNpmamJnUxTtJpWl5rR9GhpZXUax4WjmWnHsmOOpKYT5VKZ25i4ZGWS6YhLpqigSCgIiPf3Rz++E7F//C7A9/k4x3Py3s+99/35fnt78e1nAQDAMgqMAAAAAAAAACyjwAgAAAAAAADAMgqMAAAAAAAAACzzcXcAAAAAAADHWTFljeWxD702yIGRAAA8BVcwAgAAAAAAALCMAiMAAAAAAAAAyygwAgAAAAAAALCMAiMAAAAAAAAAyygwAgAAAAAAALCMAiMAAAAAAAAAyygwAgAAAAAAALDMx90BuFp2drbeeOMNrVixQj///LPq1q2rvn376tVXX1WTJk0qNFd6erqmT5+utWvX6syZM2rYsKEGDRqk6dOnKygoyDknAABusGLKGneHAAAAAACopDyqwHjlyhXdddddSkxMVKNGjTRgwAAdP35c7733nj799FMlJiYqLCysXHOlpaUpKipKR44cUVhYmAYOHKikpCTFxcVp/fr12rlzp+rWrevkMwIAAAAAx7H6j4oPvTbIwZEAAKoSj7pFesaMGUpMTFRUVJQOHz6s+Ph47dq1S7NmzVJqaqpGjx5d7rnGjx+vI0eO6IEHHtChQ4cUHx+vAwcOaMyYMTp8+LCef/55J54JAAAAAAAAUDl4TIExNzdX8+fPlyS99dZbCgwMtPc9//zz6tSpk7Zu3apvvvmmzLlSUlL0r3/9S76+vlqwYIF8fP53IejMmTMVEhKiZcuW6dy5c44/EQAAAAAAAKAS8ZhbpHfs2KGMjAy1atVKXbt2LdIfExOj/fv3KyEhQd26dSt1rg0bNujatWvq0aOHGjRoUKjPz89P/fv315IlS7Ru3TrFxsY68jQAwDKeowgAAJzlen7O4PZqAKj6PKbA+P3330uSIiIiiu0vaN+/f79D5lqyZEm55gIAAAAqi8zsTHeHAA+0aPz7lsYNmtLPsYEAQBWQn58vb29vd4dRhMcUGH/++WdJUtOmTYvtL2g/ceKES+cCgIriSkQAgLP8fdFYd4cAlNsTce6OAADc46abbnJ3CEV4TIHx0qVLkqSaNWsW21+rVi1JUmZm2f9q68i5JKlDhw7Ftv/000/2/46Kiir0rEcAVdvl9Cx3hwAA8HD51/LdHQIAALCg4MK3yoSKVSVms9kUGBio5s2buzsUoFySk5MlSa1atXJzJJXfDcG13R0CUCHkN1A9Xcg8L4ncBqob9m2g+vrpp5+UnZ3t7jCK8JgCY8Fbo7Oyir9q6PLly5Kk2rXL/ku/I+eSpKSkpHIdB1R2BVfj8v80UP2Q30D1RG4D1RO5DVRfJd0F625e7g7AVQquAvzll1+K7S9oDw0NdelcAAAAAAAAQFXmMQXGzp07S5L27dtXbH9Be6dOnVw6FwAAAAAAAFCVeUyB8Y477lCdOnWUnJys7777rkj/qlWrJEn9+/cvc66+ffvKy8tL27dv17lz5wr15eTkKCEhQd7e3rr33nsdEjsAAAAAAABQWXlMgdHX11fPPvusJOmZZ56xPydRkmbPnq39+/crOjpa3bp1s7fPnz9f7dq10+TJkwvN1ahRIw0dOlS5ubl6+umndfXqVXvfxIkTlZqaquHDh6t+/fpOPisAAAAAAADAvTzmJS+SNHXqVH355Zf6+uuvFR4erh49eujEiRPatWuXQkJCtGTJkkLHp6Wl6dChQ0pJSSky19y5c5WYmKjVq1erXbt2ioyMVFJSkg4cOKDw8HDNnj3bVacFAAAAAAAAuI3HXMEoSf7+/tq8ebNefPFF1axZU2vXrtWJEycUGxurffv2KSwsrNxzBQcHa/fu3RozZoxyc3O1Zs0aZWRkaOzYsdq9e7fq1q3rxDMBKqekpCTeVAdUU+Q3UD2R20D1RG4D1VdlzW+bMca4OwgAAAAAAAAAVZNHXcEIAAAAAAAAwLEoMAIAAAAAAACwjAIjAAAAAAAAAMsoMAIAAAAAAACwjAIjAAAAAAAAAMsoMAIAAAAAAACwjAIjAGVnZ+ull15SmzZt5O/vr8aNG2v06NE6depUhedKT0/XuHHjFBoaKj8/P4WGhmr8+PG6ePFiscfHxsbKZrOV+GvhwoXXeXaA53JUbm/dulUvv/yy+vXrp5CQENlsNrVo0aLMcfn5+ZozZ45uvvlmBQQEKCQkRA8++KAOHjxo8YwASO7NbfZtwLkckd8XL17U8uXLNXToULVs2VK+vr6qXbu2brvtNsXFxSkvL6/EsezdgHO4M7ddtXfbjDHGITMBqJKuXLmiXr16KTExUY0aNVKPHj10/Phx7d69WyEhIUpMTFRYWFi55kpLS1NUVJSOHDmisLAwRUZGKikpSUlJSWrTpo127typunXrFhoTGxurpUuXqk+fPmrYsGGROUeOHKlevXo55FwBT+LI3O7SpYu+//77Qm2hoaE6fvx4iWOuXbummJgYrVmzRkFBQerdu7fS0tK0bds2BQQEaPPmzbr11luv5xQBj+Tu3GbfBpzHUfk9depUvfbaa7LZbOrSpYvatGmj1NRU7dixQzk5Oerevbs2btyomjVrFhrH3g04h7tz22V7twHg0aZMmWIkmaioKJOZmWlvnzVrlpFkoqOjyz3XsGHDjCTzwAMPmLy8PHv7mDFjjCQzcuTIImNGjhxpJJnNmzdfx1kA+CNH5vaECRPMjBkzzMaNG01SUpKRZEJDQ0sds3jxYiPJhIeHmzNnztjbV61aZSSZ1q1bF/pzAkD5uDu32bcB53FUfr/++utm4sSJ5sSJE4XaDx8+bJo3b24kmcmTJxcZx94NOIe7c9tVezcFRsCD5eTkmDp16hhJZt++fUX6O3XqZCSZvXv3ljnX6dOnjZeXl/H19S30A4kxxly5csWEhIQYb29vc/bs2UJ9/EUFcDxH5vYfpaSklKsI0b59eyPJrFmzpkjf/fffbySZVatWVXh9wJNVhtxm3wacw5n5/XvLly83kkyLFi2K9LF3A45XGXLbVXs3z2AEPNiOHTuUkZGhVq1aqWvXrkX6Y2JiJEkJCQllzrVhwwZdu3ZNPXr0UIMGDQr1+fn5qX///srPz9e6descEzyAEjkyt604duyYDh48qICAAPXr18/l6wPVlbtzG4DzuCq/O3fuLEk6ffp0oXb2bsA53J3bruTjtpUBuF3Bc5ciIiKK7S9o379/v0PmWrJkSYlzffzxx1q9erXy8/PVsmVL9e/fX+3atStzXQBFOTK3r2f9jh07qkaNGi5fH6iu3J3bv8e+DTiWq/L76NGjklTkOWzs3YBzuDu3f8/ZezcFRsCD/fzzz5Kkpk2bFttf0H7ixAmnzzVv3rxCv3/hhRf01FNPKS4uTj4+/FEFVIQjc7sqrg9UV5Upt9i3AcdyVX7HxcVJkgYMGOCW9QFP4+7c/j1n793cIg14sEuXLklSkbdMFahVq5YkKTMz02lzde3aVQsXLtThw4eVlZWlo0eP6q233lJQUJAWLFigCRMmlO9kANg5Mrer4vpAdVUZcot9G3AOV+T3woUL9eWXXyooKEiTJk1y+fqAJ3J3bkuu27spMAJwq3HjxumJJ55QeHi4AgIC1LJlSz399NPavn27fH19NX/+fJ08edLdYQIAALFvA1XV9u3bNW7cONlsNi1ZskSNGzd2d0gAHKA8ue2qvZsCI+DBAgMDJUlZWVnF9l++fFmSVLt2bZfOJUkdOnTQ/fffr6tXr2rTpk3lGgPgN47Ox6q2PlBdVebcYt8Gro8z8/vAgQMaMGCAcnNzFRcXp0GDBrl0fcCTuTu3S+PovZsCI+DBmjdvLkn65Zdfiu0vaA8NDXXpXAXCw8MlSSkpKeUeA8A5+ViV1geqq8qeW+zbgHXOyu9jx47p7rvvVnp6uqZPn64xY8a4dH3A07k7t8viyL2bAiPgwQpeZb9v375i+wvaO3Xq5NK5CqSnp0v633MpAJSPM/LRyvoHDhxQXl6ey9cHqit353ZZ2LcB65yR3ykpKfrLX/6ilJQUjRs3TtOmTStzffZuwLHcndtlceTeTYER8GB33HGH6tSpo+TkZH333XdF+letWiVJ6t+/f5lz9e3bV15eXtq+fbvOnTtXqC8nJ0cJCQny9vbWvffeW67YcnJy9Nlnn0mSIiIiyjUGwG8cmdtWtGzZUu3bt1d2drY9j125PlBduTu3S8O+DVwfR+d3enq6+vTpo+TkZI0aNUpz5swp9Xj2bsA53J3bpXH43m0AeLQpU6YYSeZPf/qTuXTpkr191qxZRpKJjo4udPy8efNM27ZtzaRJk4rMNWzYMCPJDB482OTl5dnbx44daySZkSNHFjr+4MGD5oMPPjBXrlwp1H7u3DkzcOBAI8l07tzZXLt27fpPFPAwjszt30tJSTGSTGhoaKnHLV682Egy4eHh5uzZs/b21atXG0mmdevWhf6cAFA+7sxt9m3AuRyV35cvXzZRUVFGknnwwQfN1atXy7U+ezfgHO7MbVfu3T7XX6IEUJVNnTpVX375pb7++muFh4erR48eOnHihHbt2qWQkBAtWbKk0PFpaWk6dOhQsc9omDt3rhITE7V69Wq1a9dOkZGRSkpK0oEDBxQeHq7Zs2cXOv7MmTMaMWKExo0bp8jISIWEhOj06dP65ptvlJmZqaZNm+qjjz6SzWZz6mcAVEeOzO13331X7777riTZb5tKSUnR7bffbj9mwYIFhf7lc/To0Vq3bp3WrFmjdu3aqXfv3kpLS9PWrVsVEBCgZcuWyceHH0OAinJnbrNvA87lqPyeMmWKdu7cKW9vb/n4+OjRRx8tdr3333+/0O/ZuwHncGduu3Tvvu4SJYAqLysry7z44oumVatWxtfX1zRs2NDExsaakydPFjl22rRpxV6NWOD8+fNmzJgxplmzZsbX19c0a9bMjB071qSnpxc59tSpU2b8+PHm9ttvNw0bNjQ1atQwgYGBJiIiwkybNs1cuHDBwWcKeBZH5XZBX2m/Nm/eXGTc1atXzaxZs0yHDh2Mv7+/qVevnomJiTFJSUlOOFvAc7grt9m3AedzRH6PHDmyzNwuqRTA3g04h7ty25V7t80YY66/TAkAAAAAAADAE/GSFwAAAAAAAACWUWAEAAAAAAAAYBkFRgAAAAAAAACWUWAEAAAAAAAAYBkFRgAAAAAAAACWUWAEAAAAAAAAYBkFRgAAAAAAAACWUWAEAAAAAAAAYBkFRgAAAAAAAACWUWAEAAAAAAAAYBkFRgAAAAAAAACWUWAEAAAAAAAAYBkFRgAAAKCS27t3r0aMGKHWrVvLZrNp6tSpJR47b948RUVFSZKWLl2qyMhIBQUFqVatWoqIiNCKFStcFTYAAPAQPu4OAAAAAEDpduzYocTERHXv3l1paWmlHrt+/Xrdc889kqT09HQNHDhQXbp0kb+/v9auXauhQ4fK399fAwcOdEHkAADAE9iMMcbdQQAAAAAo2bVr1+Tl9dvNRy1atNDw4cM1Y8aMIsdduXJFdevW1datW3XLLbcUO1f37t3VqFEjrVy50qkxAwAAz8Et0gAAAEAlV1BcLMuWLVsUGBioyMjIEo+pV6+e8vLyHBUaAAAABUYAAOCZbDab/dfOnTtLPO6jjz6yH9eiRQvXBegA7o7ZZrPpzjvvdNv6Vrzyyivy8vLSDz/84O5QLFm3bp369Okjm81WqP3q1av69ddfFR8fry+++EJPPPGEU9ZPSUlRQECAnn76aafMDwAAKicKjAAAwON9+OGHJfYtW7bMhZHAnc6ePauZM2cqJiZGN998s7vDseT3z18scObMGdWoUUN16tTRsGHDNHfu3CLHOEqjRo3017/+VYsXL9bhw4edsgYAAKh8eMkLAADwWN7e3rrpppsUHx+vuXPnysen8I9G58+f14YNGxQREaF9+/a5KUrrDh48qBo1arg7jCrj9ddf16VLlzR58mSnr3Xx4kWdOXOm1GNq1qyp5s2bl3vOI0eO6OjRo7r77rsLtQcHB2vPnj3KzMzUhg0b9Oyzz6pevXoaPHiwpdjLMnHiRM2fP18vvvii4uPjnbIGAACoXCgwAgAAjzZs2DBNmjRJGzduVL9+/Qr1xcfHKy8vT8OHD6+SBcZ27dq5O4QqIysrS0uXLlXHjh3VtWtXp6+3YsUKPfXUU6UeEx0drS1btpR7zvXr1+uWW25RcHBwoXYfHx/7Mxl79eqlCxcuaPLkyU4rMDZp0kS9evXSmjVrdPbsWTVo0MAp6wAAgMqDW6QBAIBHe/jhh2Wz2Yq9FXrZsmUKDAzUgAEDShz/2WefafTo0Wrfvr1uuOEG1apVS507d9brr7+unJycQsceP37c/lzC7OxsTZo0SaGhofLz81Pr1q315ptvyhhTZA2r44p7BqPVuSTp448/1u23366aNWsqODhYQ4YM0ZEjRzR9+nTZbDa9//77JX5Ov3fgwAENHz5cYWFh8vf3V0hIiLp06aLx48crJSWlzPHXcw4lWblypTIyMjR06NBS17t8+bKef/55NWvWTAEBAYqIiFBCQkKheW677TbVqlVLDRo00NixY5WdnV1kzieffFLGmFJ/VaS4KP32/MXy3PrcpUsXHT16tEJzV/Q7e/jhh5WXl1fu/ycAAEDVxhWMAADAozVr1kw9e/bUJ598okuXLikwMFCSdPToUe3cuVOPPPKIatasWeL4Rx99VNnZ2erYsaM6deqkjIwM7d69W1OmTNGmTZv0+eefy9vbu9CY3Nxc3X333frxxx/tRautW7dq0qRJyszM1IwZM4pdy+o4R8wVFxen8ePHy8vLSz179lTDhg21a9cu3Xrrrerfv3+51/3mm2/UvXt3XblyRZ06ddKAAQOUlZWlo0ePKi4uTgMHDlSjRo2ccg6l+fTTTyWp1JfS5Obmqnfv3jp27Jh69uyptLQ0bdu2TYMGDdKGDRv0ww8/aOLEiYqOjlafPn20bds2zZs3T+fPny/1OZ+OkJ2drS1btujll18u89ivv/66Qi//sfKdFXyOn332mV544YWKnAoAAKiKDAAAgAeSZLy9vY0xxixevNhIMkuXLrX3v/LKK0aS2bhxo0lJSTGSTGhoaJF51q5da7Kysgq1/frrr+a+++4rMuexY8eMJCPJREdHm4yMDHvfnj17jLe3t6lZs6bJzMwsNJ/VccXFbGWu5ORk4+vra3x9fc1XX31lb8/LyzOjRo2yz/fee+8V+Xz+aMSIEUaS+ec//1mk7+DBg+b06dNlzmH18yhNgwYNjI+PT5Hv8o/r3XXXXebSpUv2vvfee89IMq1btzY33nij2bNnj73v1KlTpn79+kaSSU5OLncsxTl37pxZuXKlWblypQkJCTGDBw82K1euNOvWrTPGGLNu3ToTHBxs8vPzC4278847zbx588wXX3xhEhISzGOPPWYkmUWLFpV7bavfWXBwsPHz8zPZ2dkVOFMAAFAVcYs0AADweDExMfLz8yt0ldmHH36oRo0aqXfv3qWOHTBggAICAgq11a5dW3PmzJEk/fvf/y4yxsvLS++8845uuOEGe1tkZKTuueceZWVlae/evcWuZXXc9c61ZMkS5ebm6pFHHlGvXr3s7T4+Ppo9e7b9qs/ySE1NlST9+c9/LtLXrl27cl+9WNFzKM25c+d09uxZ+23Ppa339ttvq1atWva2ESNGKDg4WEeOHNEzzzxjf9ahJDVu3FjDhg2TJG3btq3c51WcpKQkDRkyREOGDFFqaqpWr16tIUOG2J/juH79evXp00deXoV/vO/cubPmzZun+++/X6NGjdLhw4eVkJCgxx9/vNxrW/3O2rZtq5ycHB08eLDcawEAgKqJAiMAAPB4QUFB6tevnzZt2qQzZ85oz549OnTokB566KEitzcX57///a/i4uI0ZswYjR49WrGxsXr11VftfX8UGhqqtm3bFmlv06aNJJX4HEKr4653rh07dkiShgwZUuT4oKCgIm8tLk23bt0kSc8884y2bNmiq1evlnvsHznq8zh37pwk6cYbbyz1uBYtWtjnLuDl5aXQ0FBJKvZzCAsLq1AsJbnzzjuLfU7j8ePHJf1WYOzbt2+RcXPnztWhQ4eUlZWl1NRUbd26Vffdd1+F1rb6ndWtW1fS/wqUAACg+uIZjAAAAJKGDx+ujz/+WCtWrNCxY8fsbaUxxujvf/+75syZU+JLRTIzM4u0NW3atNhja9euLUlFXg5zveOud66C4lizZs2KHdO8efNyrzthwgT95z//0ZYtW9SrVy8FBgYqKipK/fr1U2xsrOrUqVPuuRz1eWRkZBQaV5ImTZoU215wBWdx/QV9FflurCiukO0oVr+zgitLL1686LTYAABA5cAVjAAAAJLuvfdeBQUF6YMPPlB8fLzat2+viIiIUsfEx8dr9uzZatq0qVatWqVTp04pNzdXxhh7Qam4wuMfb2MtL6vjnD1XRdxwww366quvtH37dk2cOFE33XSTvvrqK40fP15t27atUKHMUedQUCArrhhckfXc9Zk6m9XvrKBwGxQU5MJoAQCAO1TPn4IAAAAqyM/PT0OGDNG3336rs2fPlnn1oiStWbNGkvT2229r8ODBaty4sWrUqCHpt7dQVxcFz9g7efJksf0ltZfEZrOpe/fuevPNN7Vr1y6dPn1aQ4cO1dmzZzVlypTrjrei6tevL0m6cOGCy9euKqx8Z+np6ZKkkJAQV4YKAADcgAIjAADA/3vkkUdUr149BQcH21/OUZqCAkpxt+p+9NFHDo/PXe644w5J0urVq4v0ZWRk6PPPP7+u+evXr6/p06dLkg4cOHBdc1ldv2HDhjp58qSysrJcvn5VVJ7v7KeffpKfn5/at2/vwsgAAIA7UGAEAAD4fz169FBaWppSU1PtL+4oTcELPxYtWlToVujt27dr5syZTovT1UaNGiVfX1998MEHhd6GnJ+fr7/97W9l3lr8ewsXLrQ/4/L31q1bJ6nk5zw6W48ePZSfn69vv/3WLetXZla+s+TkZJ0/f1633nqr/P39nR4jAABwLwqMAAAAFo0dO1a1atXSggUL1LFjRw0dOlQ9e/ZUdHS0nnzySXeH5zCtWrXSP/7xD+Xk5KhXr1666667NHToULVp00arV6+2307u6+tb5lwLFy5UWFiYOnTooJiYGD300EPq0qWLnnvuOfn7++ull15y9ukUq1+/fpKkLVu2uGX9yszKd1bwORZ8rgAAoHqjwAgAAGBRmzZttHfvXvXv319paWn65JNPdOnSJb3zzjvV6gpGSRo3bpxWrVqlyMhIJSYmauPGjerSpYt27dplv0KtXr16Zc7z6quvavTo0bLZbNq0aZMSEhKUnZ2txx57TN999539dmxXe/DBB1WnTh0tX77cLetXZla+s+XLl6tGjRqKjY11fcAAAMDlbKa4VxsCAAAA5ZCfn69OnTrp4MGDOn36tBo2bOjukCx77rnnNHfuXO3du1fdunVzdzhV1i+//KLQ0FDFxMQoPj7e3eEAAAAX4ApGAAAAlCk5OVkXL14s1JaTk6OJEyfqxx9/VO/evat0cVGSJk+erMDAQL3xxhvuDqVKmzlzpry8vPTKK6+4OxQAAOAiPu4OAAAAAJXfypUrNW3aNHXr1k3NmjXTr7/+qu+//14pKSkKDg7W/Pnz3R3idatfv74mTJig6dOn64cfftDNN9/s7pCqnJSUFC1atEiPP/642rZt6+5wAACAi3CLNAAAAMq0Z88ezZ49W4mJiUpNTdXVq1fVpEkT9enTR5MnT3bb258BAADgfhQYAQAAAAAAAFjGMxgBAAAAAAAAWEaBEQAAAAAAAIBlFBgBAAAAAAAAWEaBEQAAAAAAAIBlFBgBAAAAAAAAWEaBEQAAAAAAAIBlFBgBAAAAAAAAWEaBEQAAAAAAAIBlFBgBAAAAAAAAWEaBEQAAAAAAAIBlFBgBAAAAAAAAWEaBEQAAAAAAAIBlFBgBAAAAAAAAWEaBEQAAAAAAAIBlFBgBAAAAAAAAWEaBEQAAAAAAAIBlFBgBAAAAAAAAWEaBEQAAAAAAAIBl/wdjtv1JGbWqUgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# --- Distribution overlay (x-axis anchored to YAML range [0.015, 0.25]) ----\n", + "fig, ax = plt.subplots(figsize=(10, 5), dpi=150)\n", + "ax.hist(tn, bins=80, range=(0.015, 0.25), color=\"black\", histtype=\"step\", lw=2, label=\"truth n\", density=True)\n", + "ax.hist(rn, bins=80, range=(0.015, 0.25), color=\"#6c2178\", alpha=0.6, label=f\"recovered n ({ARM})\", density=True)\n", + "ax.set_xlim(0.015, 0.25)\n", + "ax.set_xlabel(\"Manning's n (m$^{-1/3}$ s)\")\n", + "ax.set_ylabel(\"density\")\n", + "ax.set_title(f\"n distribution: truth vs recovered — {ARM}\")\n", + "ax.legend(); ax.grid(axis=\"y\", alpha=0.3)\n", + "out = PLOT_DIR / f\"n_hist_truth_vs_recovered_{ARM}.png\"\n", + "fig.savefig(out, dpi=300, bbox_inches=\"tight\", facecolor=\"white\")\n", + "print(f\"saved {out}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5e7c3d83", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-29T00:12:43.319941Z", + "iopub.status.busy": "2026-07-29T00:12:43.319852Z", + "iopub.status.idle": "2026-07-29T00:12:43.888773Z", + "shell.execute_reply": "2026-07-29T00:12:43.888406Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saved /home/tbindas/projects/ddrs/output/synthetic_n/plots/geometry_recovery_distributed.png\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# --- Geometry recovery: q_spatial and p_spatial ----------------------------\n", + "fig, axes = plt.subplots(1, 2, figsize=(15, 6.5), dpi=150)\n", + "for ax, var, rng in zip(axes, [\"q_spatial\", \"p_spatial\"], [(0.0, 1.0), (1.0, 30.0)]):\n", + " tv, rv = truth[var].values, rec[var].values\n", + " c = np.corrcoef(tv, rv)[0, 1]\n", + " m = np.median(np.abs(rv - tv))\n", + " hb = ax.hexbin(tv, rv, gridsize=60, cmap=\"viridis\", mincnt=1, bins=\"log\")\n", + " fig.colorbar(hb, ax=ax, label=\"count (log)\")\n", + " ax.plot(rng, rng, \"k--\", lw=1.2)\n", + " ax.set_xlim(rng); ax.set_ylim(rng)\n", + " ax.set_xlabel(f\"truth {var} (consensus geometry)\")\n", + " ax.set_ylabel(f\"recovered {var}\")\n", + " ax.set_title(f\"{var} (corr={c:.3f}, median|err|={m:.3f})\")\n", + " ax.grid(alpha=0.3)\n", + "fig.suptitle(f\"Geometry recovery — {ARM} student\", fontsize=14)\n", + "out = PLOT_DIR / f\"geometry_recovery_{ARM}.png\"\n", + "fig.savefig(out, dpi=300, bbox_inches=\"tight\", facecolor=\"white\")\n", + "print(f\"saved {out}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8f702f87", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-29T00:12:43.889623Z", + "iopub.status.busy": "2026-07-29T00:12:43.889547Z", + "iopub.status.idle": "2026-07-29T00:15:22.971855Z", + "shell.execute_reply": "2026-07-29T00:15:22.971411Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "shapefile join: 346,321 COMIDs\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saved /home/tbindas/projects/ddrs/output/synthetic_n/plots/map_n_truth_conus.png\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saved /home/tbindas/projects/ddrs/output/synthetic_n/plots/map_n_recovered_distributed_conus.png\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "saved /home/tbindas/projects/ddrs/output/synthetic_n/plots/map_n_error_distributed_conus.png\n" + ] + } + ], + "source": [ + "# --- Spatial maps: truth n, recovered n, signed error (CONUS) --------------\n", + "gdf = gpd.read_file(SHAPEFILE).set_index(\"COMID\")\n", + "shared = np.intersect1d(gdf.index.values, tc)\n", + "print(f\"shapefile join: {len(shared):,} COMIDs\")\n", + "n_t = pd.Series(tn, index=tc).reindex(gdf.index)\n", + "n_r = pd.Series(rn, index=tc).reindex(gdf.index)\n", + "gdf[\"n_truth\"] = n_t.values\n", + "gdf[\"n_rec\"] = n_r.values\n", + "gdf[\"n_err\"] = (n_r - n_t).values\n", + "gdf = gdf.set_crs(epsg=4326)\n", + "BBOX = (-125, 24, -66, 53)\n", + "\n", + "def n_map(col, title, cmap, vmin, vmax, fname, center=False):\n", + " g = gdf.dropna(subset=[col]).sort_values(col if not center else col, key=(np.abs if center else None))\n", + " fig, ax = plt.subplots(figsize=(12, 7), dpi=150)\n", + " g.plot(ax=ax, column=col, cmap=cmap, linewidth=0.3, vmin=vmin, vmax=vmax, zorder=1)\n", + " try:\n", + " import contextily as cx\n", + " cx.add_basemap(ax, crs=g.crs, source=cx.providers.CartoDB.Positron, alpha=0.6, zorder=0, attribution=False)\n", + " except Exception as e:\n", + " print(f\"basemap skipped ({type(e).__name__})\"); ax.set_facecolor(\"#f0f0f0\")\n", + " ax.set_xlim(BBOX[0], BBOX[2]); ax.set_ylim(BBOX[1], BBOX[3])\n", + " ax.set_xticks([]); ax.set_yticks([])\n", + " ax.set_title(title, fontsize=14)\n", + " cax = make_axes_locatable(ax).append_axes(\"right\", size=\"3%\", pad=0.1)\n", + " sm = plt.cm.ScalarMappable(cmap=cmap); sm.set_array([]); sm.set_clim(vmin, vmax)\n", + " fig.colorbar(sm, cax=cax).set_label(\"n (m$^{-1/3}$ s)\" if not center else \"recovered − truth n\")\n", + " fig.savefig(PLOT_DIR / fname, dpi=300, bbox_inches=\"tight\", facecolor=\"white\")\n", + " plt.close(fig)\n", + " print(f\"saved {PLOT_DIR / fname}\")\n", + "\n", + "n_map(\"n_truth\", \"Truth n (Leopold-Maddock) — CONUS\", \"plasma_r\", 0.015, 0.15, \"map_n_truth_conus.png\")\n", + "n_map(\"n_rec\", f\"Recovered n ({ARM} student) — CONUS\", \"plasma_r\", 0.015, 0.15, f\"map_n_recovered_{ARM}_conus.png\")\n", + "n_map(\"n_err\", f\"n error (recovered − truth), {ARM} — CONUS\", \"RdBu_r\", -0.08, 0.08, f\"map_n_error_{ARM}_conus.png\", center=True)" + ] + } + ], + "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.13.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/scripts/generate_run_notebooks.py b/scripts/generate_run_notebooks.py new file mode 100644 index 0000000..0dc27f9 --- /dev/null +++ b/scripts/generate_run_notebooks.py @@ -0,0 +1,290 @@ +"""Generates and executes per-run parameter_map + metrics_distribution +notebooks for the 2026-07-16 AORC2F/LSTM Q' campaign (4 runs), following +the ddrs-eval-plots skill conventions. + +Run from ddrs-py's venv: + cd ddrs-py && uv run python ../scripts/generate_run_notebooks.py +""" +from __future__ import annotations + +import subprocess +import sys +from datetime import datetime +from pathlib import Path + +import nbformat as nbf + +REPO = Path(__file__).resolve().parent.parent +SHAPEFILE = REPO.parent / "ddr/data/merit/cat_pfaf_7_MERIT_Hydro_v07_Basins_v01_bugfix1.shp" +ATTRS_NC = REPO.parent / "ddr/data/merit_global_attributes_v2.nc" + +RUNS = [ + { + "label": "AORC2F distributed", + "run_dir": REPO / ".ddrs/runs/2026-07-16T02-22-14Z-train-and-test", + "baseline_dir": REPO / ".ddrs/baselines/86b907e4b17de998", + }, + { + "label": "AORC2F lumped", + "run_dir": REPO / ".ddrs/runs/2026-07-16T02-23-20Z-train-and-test", + "baseline_dir": REPO / ".ddrs/runs/2026-07-16T02-23-20Z-train-and-test/baseline", + }, + { + "label": "daily-lstm", + "run_dir": REPO / ".ddrs/runs/2026-07-16T11-31-50Z-train-and-test", + "baseline_dir": REPO / ".ddrs/baselines/7ffd117fc9161734", + }, + { + "label": "hourly-lstm", + "run_dir": REPO / ".ddrs/runs/2026-07-16T11-31-52Z-train-and-test", + "baseline_dir": REPO / ".ddrs/runs/2026-07-16T11-31-52Z-train-and-test/baseline", + }, +] + +SKILL_SCRIPTS = REPO / ".claude/skills/ddrs-eval-plots/scripts" + + +def md(text: str): + return nbf.v4.new_markdown_cell(text) + + +def code(src: str): + return nbf.v4.new_code_cell(src) + + +def build_parameter_map_nb(run) -> nbf.NotebookNode: + nb = nbf.v4.new_notebook() + nb.cells = [ + md(f"# Parameter map — {run['label']}\n\n" + f"Checkpoint: `{run['run_dir']}/checkpoints/epoch_5_mb_35`\n\n" + f"Params: `{run['run_dir']}/kan_parameters.nc`\n\n" + f"Generated: {datetime.utcnow().strftime('%Y-%m-%d')} (auto, ddrs-eval-plots skill)"), + code(f""" +from pathlib import Path +import contextily as cx +import geopandas as gpd +import matplotlib.pyplot as plt +import numpy as np +import xarray as xr +from mpl_toolkits.axes_grid1 import make_axes_locatable + +PARAMS_NC = Path("{run['run_dir']}/kan_parameters.nc") +RUN_DIR = Path("{run['run_dir']}") +SHAPEFILE = Path("{SHAPEFILE}") +ATTRS_NC = Path("{ATTRS_NC}") +LABEL = "{run['label']}" +BBOX = (-125, 24, -66, 53) + +PLOT_DIR = RUN_DIR / "plots" +PLOT_DIR.mkdir(exist_ok=True) + +ds = xr.open_dataset(PARAMS_NC) +gdf_full = gpd.read_file(SHAPEFILE).set_index("COMID") +print(f"{{len(ds.COMID):,}} params, {{len(gdf_full):,}} shapefile reaches") +"""), + code(""" +PLOT_CONFIGS = { + "n": {"title": "Manning's Roughness", "unit": "m$^{-1/3}$ s", "cmap": "plasma_r", "vmax": 0.2, "range": (0.015, 0.25)}, + "q_spatial": {"title": "Width-Depth Exponent (q)", "unit": "–", "cmap": "viridis", "vmax": None, "range": (0.0, 1.0)}, + "p_spatial": {"title": "Width Coefficient (p)", "unit": "–", "cmap": "viridis", "vmax": None, "range": (1.0, 200.0)}, +} + +def make_map(var): + cfg = PLOT_CONFIGS[var] + gdf = gdf_full.copy() + shared = np.intersect1d(gdf.index.values, ds.COMID.values) + gdf.loc[shared, var] = ds.sel(COMID=shared)[var].values + gdf = gdf.set_crs(epsg=4326) + xmin, ymin, xmax, ymax = BBOX + gdf = gdf.cx[xmin:xmax, ymin:ymax] + gdf_clean = gdf.dropna(subset=[var]).sort_values(var, ascending=True) + + vmin = float(np.nanmin(gdf_clean[var])) + vmax = cfg["vmax"] if cfg["vmax"] is not None else float(np.nanmax(gdf_clean[var])) + + fig, ax = plt.subplots(figsize=(10, 6), dpi=150) + gdf_clean.plot(ax=ax, column=var, cmap=cfg["cmap"], linewidth=0.3, vmin=vmin, vmax=vmax, zorder=1) + try: + cx.add_basemap(ax, crs=gdf_clean.crs, source=cx.providers.CartoDB.Positron, alpha=0.6, zorder=0, attribution=False) + except Exception as e: + print(f"basemap skipped: {e}") + ax.set_xlim(xmin, xmax); ax.set_ylim(ymin, ymax) + ax.set_xticks([]); ax.set_yticks([]) + ax.set_title(f"{cfg['title']} — {LABEL} (CONUS)", fontsize=13) + cax = make_axes_locatable(ax).append_axes("right", size="3%", pad=0.1) + sm = plt.cm.ScalarMappable(cmap=cfg["cmap"]); sm.set_array([]); sm.set_clim(vmin, vmax) + fig.colorbar(sm, cax=cax).set_label(f"{var} ({cfg['unit']})") + out = PLOT_DIR / f"parameter_map_{var}_conus.png" + fig.savefig(out, dpi=300, bbox_inches="tight", facecolor="white") + plt.close(fig) + print(f"saved {out}") + return cfg + +for var in ["n", "q_spatial", "p_spatial"]: + make_map(var) +"""), + md("## Distribution histograms (full CONUS population, x-axis anchored to declared parameter_ranges)"), + code(""" +for var in ["n", "q_spatial", "p_spatial"]: + cfg = PLOT_CONFIGS[var] + v_all = ds[var].values + v_finite = v_all[np.isfinite(v_all)] + vmin_hist, vmax_hist = cfg["range"] + fig, ax = plt.subplots(figsize=(9, 4.5), dpi=150) + ax.hist(v_finite, bins=80, range=(vmin_hist, vmax_hist), color="#6c2178", edgecolor="white", linewidth=0.3) + ax.axvline(float(np.nanmedian(v_finite)), color="black", linestyle="--", linewidth=1.5, label=f"median = {float(np.nanmedian(v_finite)):.4f}") + ax.axvline(float(np.nanmean(v_finite)), color="#c63", linestyle=":", linewidth=1.5, label=f"mean = {float(np.nanmean(v_finite)):.4f}") + ax.set_xlabel(f"{var} ({cfg['unit']})") + ax.set_ylabel(f"reach count (total = {len(v_finite):,})") + ax.set_title(f"Distribution of learned {var} — {LABEL}") + ax.set_xlim(vmin_hist, vmax_hist) + ax.legend(loc="upper right", frameon=True) + ax.grid(axis="y", alpha=0.3) + out = PLOT_DIR / f"parameter_hist_{var}.png" + fig.savefig(out, dpi=300, bbox_inches="tight", facecolor="white") + plt.close(fig) + print(f"saved {out}") +"""), + md("## Parameter vs log10(drainage area) hexbin (sanity check against the KAN's own input)"), + code(""" +attrs = xr.open_dataset(ATTRS_NC) +shared_a = np.intersect1d(attrs.COMID.values, ds.COMID.values) +print(f"joined {len(shared_a):,} COMIDs") +attrs_s = attrs.sel(COMID=shared_a) +ds_s = ds.sel(COMID=shared_a) +log_da = attrs_s["log10_uparea"].values + +for var in ["n", "q_spatial", "p_spatial"]: + cfg = PLOT_CONFIGS[var] + vmin_hist, vmax_hist = cfg["range"] + y_vals = ds_s[var].values + mask = np.isfinite(log_da) & np.isfinite(y_vals) + lx, ly = log_da[mask], y_vals[mask] + fig, ax = plt.subplots(figsize=(9, 5.5), dpi=150) + hb = ax.hexbin(lx, ly, gridsize=80, cmap="viridis", mincnt=1, extent=(lx.min(), lx.max(), vmin_hist, vmax_hist)) + fig.colorbar(hb, ax=ax, label="reach count per hex") + ax.set_xlabel(r"$\\log_{10}$(drainage area, km$^2$)") + ax.set_ylabel(f"learned {var} ({cfg['unit']})") + ax.set_title(f"{var} vs drainage area — {LABEL} ({len(ly):,} reaches)") + ax.set_ylim(vmin_hist, vmax_hist) + ax.grid(alpha=0.3) + bin_edges = np.linspace(lx.min(), lx.max(), 21) + bin_idx = np.digitize(lx, bin_edges) - 1 + med = np.array([np.nanmedian(ly[bin_idx == b]) if np.any(bin_idx == b) else np.nan for b in range(len(bin_edges) - 1)]) + bin_centers = 0.5 * (bin_edges[:-1] + bin_edges[1:]) + ax.plot(bin_centers, med, color="#ff4500", lw=2.0, label=f"median {var} per bin") + ax.legend(loc="upper right", frameon=True) + out = PLOT_DIR / f"parameter_scatter_{var}_vs_log10_uparea.png" + fig.savefig(out, dpi=300, bbox_inches="tight", facecolor="white") + plt.close(fig) + print(f"saved {out}") +"""), + ] + return nb + + +def build_metrics_nb(run) -> nbf.NotebookNode: + nb = nbf.v4.new_notebook() + nb.cells = [ + md(f"# Metrics distribution — {run['label']}\n\n" + f"Run: `{run['run_dir']}`\n\n" + f"Baseline: `{run['baseline_dir']}`\n\n" + f"Generated: {datetime.utcnow().strftime('%Y-%m-%d')} (auto, ddrs-eval-plots skill)"), + code(f""" +import sys, json +from pathlib import Path +import numpy as np +import matplotlib.pyplot as plt + +sys.path.insert(0, "{SKILL_SCRIPTS}") +from load_ddrs_predictions import load_predictions_zarr +from ddr.validation import Metrics, plot_box_fig, plot_cdf + +RUN_DIR = Path("{run['run_dir']}") +BASELINE_DIR = Path("{run['baseline_dir']}") +LABEL = "{run['label']}" +PLOT_DIR = RUN_DIR / "plots" +PLOT_DIR.mkdir(exist_ok=True) + +def load_baseline_f32(bdir): + man = json.load(open(bdir / "manifest.json")) + g, t = man["n_gauges"], man["n_days"] + pred = np.fromfile(bdir / "predictions.f32", dtype="12}{'median KGE':>12}") +for lbl, r in zip(labels, results): + d = dict(r) + print(f"{lbl:<20}{np.nanmedian(d['nse']):>12.4f}{np.nanmedian(d['kge']):>12.4f}") +"""), + ] + return nb + + +def main(): + for run in RUNS: + run_dir = run["run_dir"] + plots_dir = run_dir / "plots" + plots_dir.mkdir(exist_ok=True) + + pm_nb = build_parameter_map_nb(run) + pm_path = plots_dir / "parameter_map_conus.ipynb" + nbf.write(pm_nb, pm_path) + print(f"wrote {pm_path}") + + met_nb = build_metrics_nb(run) + met_path = plots_dir / "metrics_distribution.ipynb" + nbf.write(met_nb, met_path) + print(f"wrote {met_path}") + + +if __name__ == "__main__": + main() diff --git a/scripts/hydrograph_comparison.py b/scripts/hydrograph_comparison.py new file mode 100644 index 0000000..3beb921 --- /dev/null +++ b/scripts/hydrograph_comparison.py @@ -0,0 +1,115 @@ +"""HUC-grouped hydrograph comparison across the 2026-07-16 AORC2F/LSTM Q' +campaign's 4 runs: one randomly-selected gauge per USGS major-basin region +(first 2 digits of STAID, a HUC2-like grouping), all 4 models + observations +overlaid for the eval-window year with the best observation coverage. + +Run from ddrs-py's venv: + cd ddrs-py && uv run python ../scripts/hydrograph_comparison.py +""" +from __future__ import annotations + +import csv +import random +import sys +from collections import defaultdict +from pathlib import Path + +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd + +REPO = Path(__file__).resolve().parent.parent +sys.path.insert(0, str(REPO / ".claude/skills/ddrs-eval-plots/scripts")) +from load_ddrs_predictions import load_predictions_zarr # noqa: E402 + +GAGES_CSV = REPO.parent / "ddr/references/gage_info/gages_3000.csv" +OUT_DIR = REPO / "output/2026-07-16-wave-comparison/hydrographs" +OUT_DIR.mkdir(parents=True, exist_ok=True) + +RUNS = [ + {"label": "AORC2F distributed", "pred_zarr": REPO / ".ddrs/runs/2026-07-16T02-22-14Z-train-and-test/eval/predictions.zarr", "color": "#1f4fd8"}, + {"label": "AORC2F lumped", "pred_zarr": REPO / ".ddrs/runs/2026-07-16T02-23-20Z-train-and-test/eval/predictions.zarr", "color": "#d81f6a"}, + {"label": "daily-lstm", "pred_zarr": REPO / ".ddrs/runs/2026-07-16T11-31-50Z-train-and-test/eval/predictions.zarr", "color": "#1fb01f"}, + {"label": "hourly-lstm", "pred_zarr": REPO / ".ddrs/runs/2026-07-16T11-31-52Z-train-and-test/eval/predictions.zarr", "color": "#d88a1f"}, +] + +# --- Region grouping + random gauge selection ------------------------------ +rows = list(csv.DictReader(open(GAGES_CSV))) +valid = [r for r in rows if r["DA_VALID"] == "True"] +regions = defaultdict(list) +for r in valid: + regions[r["STAID"][:2]].append(r["STAID"]) + +# --- Load all 4 runs' predictions/observations ----------------------------- +datasets = [] +for run in RUNS: + ds = load_predictions_zarr(run["pred_zarr"]) + datasets.append(ds) + +# Union of gauges present in at least one run's eval gauge subset (the eval +# set is a filtered subset of gages_3000.csv — DA_VALID plus gages_adjacency +# headwater/coverage drops — so not every DA_VALID gauge is actually usable). +present = set() +for ds in datasets: + present |= set(ds.gage_ids.values.tolist()) + +random.seed(42) +selected = {} +for region, staids in sorted(regions.items()): + candidates = [s for s in staids if s in present] + if not candidates: + print(f"region {region}: no DA_VALID gauge present in any run's eval set, skipping region") + continue + selected[region] = random.choice(candidates) +print(f"selected {len(selected)} gauges (one per region, restricted to gauges present in the eval set):") +for region, staid in selected.items(): + print(f" region {region}: {staid}") + +# --- Plot one hydrograph per selected gauge -------------------------------- +for region, staid in selected.items(): + # Find the gauge in each run's dataset; skip runs missing it (shouldn't happen, same gauge set) + series = [] + obs_ref = None + for run, ds in zip(RUNS, datasets): + if staid not in ds.gage_ids.values: + series.append(None) + continue + pred = ds.sel(gage_ids=staid).predictions.values + obs = ds.sel(gage_ids=staid).observations.values + time = ds.time.values + series.append((time, pred)) + if obs_ref is None: + obs_ref = (time, obs) + + if obs_ref is None or all(s is None for s in series): + print(f"region {region} ({staid}): no data in any run, skipping") + continue + + time_obs, obs = obs_ref + df_obs = pd.Series(obs, index=pd.to_datetime(time_obs)) + # Pick the water-year (Oct-Sep) with the most non-NaN observation coverage. + water_year = df_obs.index.year + (df_obs.index.month >= 10).astype(int) + coverage = df_obs.notna().groupby(water_year).sum() + best_wy = coverage.idxmax() + start, end = f"{best_wy - 1}-10-01", f"{best_wy}-09-30" + + fig, ax = plt.subplots(figsize=(11, 5), dpi=150) + obs_window = df_obs.loc[start:end] + ax.plot(obs_window.index, obs_window.values, color="black", lw=1.2, label="Observed", zorder=5) + + for run, s in zip(RUNS, series): + if s is None: + continue + time, pred = s + pred_series = pd.Series(pred, index=pd.to_datetime(time)).loc[start:end] + ax.plot(pred_series.index, pred_series.values, color=run["color"], lw=1.0, alpha=0.85, label=run["label"]) + + ax.set_title(f"USGS {staid} (region {region}) — water year {best_wy} (best coverage in eval window)") + ax.set_ylabel("Q (m³/s)") + ax.legend(loc="upper right", fontsize=8, frameon=True) + ax.grid(alpha=0.3) + fig.autofmt_xdate() + out = OUT_DIR / f"hydrograph_region{region}_{staid}.png" + fig.savefig(out, dpi=200, bbox_inches="tight", facecolor="white") + plt.close(fig) + print(f"saved {out}") diff --git a/scripts/synthetic_n_consensus_geometry.py b/scripts/synthetic_n_consensus_geometry.py new file mode 100644 index 0000000..1953d86 --- /dev/null +++ b/scripts/synthetic_n_consensus_geometry.py @@ -0,0 +1,114 @@ +"""Consensus geometry for the synthetic-n recoverability experiment +(docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md). + +Runs `dump_parameters` against the 4 already-converged real-Q'-source +checkpoints from this campaign, then computes the per-COMID MEDIAN +q_spatial/p_spatial across them — the "most common trained value trend", +used as the FIXED geometry truth for every synthetic-n student. + +Run from ddrs-py's venv: + cd ddrs-py && uv run python ../scripts/synthetic_n_consensus_geometry.py +""" +from __future__ import annotations + +import subprocess +from pathlib import Path + +import numpy as np +import xarray as xr + +REPO = Path(__file__).resolve().parent.parent +OUT_DIR = REPO / "output/synthetic_n" +OUT_DIR.mkdir(parents=True, exist_ok=True) + +CHECKPOINTS = [ + { + "label": "aorc2f_distributed", + "config": REPO / ".ddrs/runs/2026-07-16T02-22-14Z-train-and-test/config.yaml", + "checkpoint": REPO / ".ddrs/runs/2026-07-16T02-22-14Z-train-and-test/checkpoints/epoch_5_mb_35/head", + }, + { + "label": "aorc2f_lumped", + "config": REPO / ".ddrs/runs/2026-07-16T02-23-20Z-train-and-test/config.yaml", + "checkpoint": REPO / ".ddrs/runs/2026-07-16T02-23-20Z-train-and-test/checkpoints/epoch_5_mb_35/head", + }, + { + "label": "daily_lstm", + "config": REPO / ".ddrs/runs/2026-07-16T11-31-50Z-train-and-test/config.yaml", + "checkpoint": REPO / ".ddrs/runs/2026-07-16T11-31-50Z-train-and-test/checkpoints/epoch_5_mb_35/head", + }, + { + "label": "hourly_lstm", + "config": REPO / ".ddrs/runs/2026-07-16T11-31-52Z-train-and-test/config.yaml", + "checkpoint": REPO / ".ddrs/runs/2026-07-16T11-31-52Z-train-and-test/checkpoints/epoch_5_mb_35/head", + }, +] + + +def _is_intact(path: Path) -> bool: + """A prior run killed mid-write (OOM, disk full, Ctrl-C) can leave a + `.nc` file that exists but is truncated or missing variables — silently + reusing it would poison the "fixed geometry truth" every downstream + synthetic-n student depends on. Require both q_spatial and p_spatial to + actually be readable before trusting an existing dump.""" + try: + with xr.open_dataset(path) as ds: + return "q_spatial" in ds and "p_spatial" in ds + except Exception: + return False + + +def dump_one(ckpt: dict) -> Path: + out = OUT_DIR / f"{ckpt['label']}_kan_parameters.nc" + if out.exists(): + if _is_intact(out): + print(f"{out} already exists, skipping dump_parameters re-run") + return out + print(f"{out} exists but is truncated/corrupt — removing and re-running dump_parameters") + out.unlink() + cmd = [ + "cargo", "run", "--release", "--bin", "dump_parameters", "--", + "--backend", "cpu", + "--config", str(ckpt["config"]), + "--checkpoint", str(ckpt["checkpoint"]), + "--output", str(out), + ] + print("running:", " ".join(cmd)) + subprocess.run(cmd, cwd=REPO, check=True) + return out + + +def main() -> None: + dumps = [dump_one(c) for c in CHECKPOINTS] + + datasets = [xr.open_dataset(d) for d in dumps] + comids_0 = datasets[0]["COMID"].values + for d, ds in zip(dumps, datasets): + if not np.array_equal(np.sort(ds["COMID"].values), np.sort(comids_0)): + raise SystemExit( + f"{d}: COMID set differs from {dumps[0]} — cannot take a per-COMID " + "median across checkpoints with different networks" + ) + + # Re-index every dump to dumps[0]'s COMID order before stacking, since + # dump_parameters row order isn't guaranteed identical across runs. + order = comids_0 + q_stack = np.stack([ds.set_index(COMID="COMID").sel(COMID=order)["q_spatial"].values for ds in datasets]) + p_stack = np.stack([ds.set_index(COMID="COMID").sel(COMID=order)["p_spatial"].values for ds in datasets]) + + q_median = np.median(q_stack, axis=0).astype(np.float32) + p_median = np.median(p_stack, axis=0).astype(np.float32) + + out = OUT_DIR / "consensus_geometry.nc" + xr.Dataset( + { + "q_spatial": ("COMID", q_median), + "p_spatial": ("COMID", p_median), + }, + coords={"COMID": order}, + ).to_netcdf(out) + print(f"consensus geometry ({len(order)} reaches) -> {out}") + + +if __name__ == "__main__": + main() diff --git a/scripts/synthetic_n_recoverability_analysis.py b/scripts/synthetic_n_recoverability_analysis.py new file mode 100644 index 0000000..c345bbb --- /dev/null +++ b/scripts/synthetic_n_recoverability_analysis.py @@ -0,0 +1,128 @@ +"""Pre-registered verdicts S1-S5 for the synthetic-n recoverability +experiment (docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md §3). + +Run from ddrs-py's venv, after all 4 students' dump_parameters outputs exist: + cd ddrs-py && uv run python ../scripts/synthetic_n_recoverability_analysis.py +""" +from __future__ import annotations + +from pathlib import Path + +import numpy as np +import pandas as pd +import xarray as xr +from scipy.stats import pearsonr + +REPO = Path(__file__).resolve().parent.parent +OUT_DIR = REPO / "output/synthetic_n" +ATTRS = REPO.parent / "ddr/data/merit_global_attributes_v2.nc" + +ARMS = ["distributed", "lumped", "daily_lstm", "hourly_lstm"] + +# Mean daily Q' volume ratio of each real store vs the standard benchmark +# store, for S5 — filled in manually from `ddrs import --dry-run` / +# icechunk inspection once available; None disables S5 for that arm. S5 is +# WIRED IN below (pearsonr against n_errors) but only computed when at +# least 3 arms have a non-None ratio — with only 4 arms total, fewer points +# than that isn't a meaningful correlation, so it's reported as +# "not computed", never silently skipped without saying why. +VOLUME_RATIO_VS_TRUTH: dict[str, float | None] = { + "distributed": None, + "lumped": None, + "daily_lstm": None, + "hourly_lstm": None, +} + + +def median_abs_error(recovered: np.ndarray, truth: np.ndarray) -> float: + return float(np.median(np.abs(recovered - truth))) + + +def fitted_slope(log10_uparea: np.ndarray, n: np.ndarray) -> float: + return float(np.polyfit(log10_uparea, n, 1)[0]) + + +def main() -> None: + truth = xr.open_dataset(OUT_DIR / "truth_leopold_maddock.nc") + truth_comids = truth["COMID"].values + truth_n = truth["n"].values + truth_q = truth["q_spatial"].values + truth_p = truth["p_spatial"].values + + attrs = xr.open_dataset(ATTRS).set_index(COMID="COMID").sel(COMID=truth_comids) + log10_uparea = attrs["log10_uparea"].values.astype(np.float64) + true_slope = fitted_slope(log10_uparea, truth_n) + + rows = [] + n_errors, geom_errors = {}, {} + for arm in ARMS: + rec = xr.open_dataset(OUT_DIR / f"recovered_{arm}.nc").set_index(COMID="COMID").sel( + COMID=truth_comids + ) + n_err = median_abs_error(rec["n"].values, truth_n) + q_err = median_abs_error(rec["q_spatial"].values, truth_q) + p_err = median_abs_error(rec["p_spatial"].values, truth_p) + slope = fitted_slope(log10_uparea, rec["n"].values) + n_errors[arm] = n_err + geom_errors[arm] = (q_err + p_err) / 2.0 + rows.append( + { + "arm": arm, + "n_median_abs_error": n_err, + "q_median_abs_error": q_err, + "p_median_abs_error": p_err, + "recovered_n_slope": slope, + "true_n_slope": true_slope, + "slope_sign_flipped": bool(slope > 0 and true_slope < 0), + } + ) + + df = pd.DataFrame(rows) + csv_path = OUT_DIR / "recoverability_rows.csv" + df.to_csv(csv_path, index=False) + + n_spread = max(n_errors.values()) - min(n_errors.values()) + geom_spread = max(geom_errors.values()) - min(geom_errors.values()) + s4_ratio = n_spread / geom_spread if geom_spread > 0 else float("inf") + + any_flip = df["slope_sign_flipped"].any() + + # S5: pearsonr of n_errors against VOLUME_RATIO_VS_TRUTH, restricted to + # arms with a filled-in ratio. Needs >=3 points to be worth reporting at + # all (spec §3: "only 4 data points" — 2 points is a line, not a + # correlation). Prints an explicit reason when it can't run, rather than + # silently doing nothing. + filled = {a: r for a, r in VOLUME_RATIO_VS_TRUTH.items() if r is not None} + if len(filled) >= 3: + arms_with_ratio = list(filled.keys()) + s5_r, s5_p = pearsonr( + [n_errors[a] for a in arms_with_ratio], + [filled[a] for a in arms_with_ratio], + ) + s5_line = f" [S5] pearson r={s5_r:.3f} (p={s5_p:.3f}) over {len(filled)} arms: {filled}" + else: + s5_r = s5_p = None + s5_line = ( + f" [S5] not computed — only {len(filled)}/{len(ARMS)} arms have a filled-in " + "VOLUME_RATIO_VS_TRUTH (need >=3). Fill in the dict from `ddrs import --dry-run` " + "/ icechunk mean-daily-volume inspection per arm to enable this." + ) + + print(df.to_string(index=False)) + print() + print("========================================================================") + print("VERDICTS (bars pre-registered in the design spec)") + print("========================================================================") + print(f" [S1] n median-abs-error per arm: {n_errors}") + print(f" [S2] true slope={true_slope:.5f}; any arm sign-flipped positive: {any_flip}") + print(f" [S3] geometry median-abs-error per arm: {geom_errors}") + print(f" [S4 {'PASS' if s4_ratio >= 3 else 'FAIL'}] n-spread/geom-spread = {s4_ratio:.2f} (bar: >=3)") + print(s5_line) + print(f" HEADLINE: {'PASS' if (s4_ratio >= 3 and any_flip) else 'FAIL'} " + "(requires S4>=3x AND at least one slope sign flip; S5 is supporting evidence only)") + print() + print(f"per-arm rows -> {csv_path}") + + +if __name__ == "__main__": + main() diff --git a/scripts/synthetic_n_truth_fields.py b/scripts/synthetic_n_truth_fields.py new file mode 100644 index 0000000..ad51bf5 --- /dev/null +++ b/scripts/synthetic_n_truth_fields.py @@ -0,0 +1,85 @@ +"""Prescribed truth-n fields for the synthetic-n recoverability experiment +(docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md §1). + +Combines each prescribed n field with the fixed consensus geometry +(scripts/synthetic_n_consensus_geometry.py) into a single donor NetCDF per +variant, in the dump_parameters::write_netcdf schema (COMID dim, f32 vars) +that probe_zeta_gradient's --mode teacher --donor-params-nc reads. + +Run from ddrs-py's venv, AFTER synthetic_n_consensus_geometry.py: + cd ddrs-py && uv run python ../scripts/synthetic_n_truth_fields.py +""" +from __future__ import annotations + +from pathlib import Path + +import numpy as np +import xarray as xr + +REPO = Path(__file__).resolve().parent.parent +OUT_DIR = REPO / "output/synthetic_n" +ATTRS = REPO.parent / "ddr/data/merit_global_attributes_v2.nc" + +N_LO, N_HI = 0.015, 0.15 +N_CENTER = 0.08 +SEED = 42 + + +def leopold_maddock_n(log10_uparea: np.ndarray) -> np.ndarray: + """Decreasing power law, calibrated against the REAL CONUS log10_uparea + distribution so the field actually spans [N_LO, N_HI] (not just + approximately): n falls linearly in log-log space from N_HI at the 1st + percentile of log10_uparea (smallest headwaters) to N_LO at the 99th + percentile (largest rivers). Anchoring on the 1st/99th percentile rather + than the true min/max avoids a handful of extreme-tail reaches + compressing the realized range for everyone else — log10_uparea here is + right-skewed (median much closer to the min than the max), so a fixed + exponent centered on the median (an earlier version of this function) + undershoots both bounds; this anchors directly to the bounds instead. + Reaches beyond the 1st/99th percentile are clipped to N_HI/N_LO. + """ + lo_x, hi_x = np.percentile(log10_uparea, [1, 99]) + log_n = np.log10(N_HI) + (log10_uparea - lo_x) * ( + np.log10(N_LO) - np.log10(N_HI) + ) / (hi_x - lo_x) + n = 10.0**log_n + return np.clip(n, N_LO, N_HI).astype(np.float32) + + +def gaussian_noise_n(n_reaches: int) -> np.ndarray: + """IID Gaussian field, no spatial structure — the null control.""" + rng = np.random.default_rng(SEED) + spread = (N_HI - N_LO) / 4.0 # ~2 std devs to each bound from N_CENTER + n = rng.normal(loc=N_CENTER, scale=spread, size=n_reaches) + return np.clip(n, N_LO, N_HI).astype(np.float32) + + +def main() -> None: + geom = xr.open_dataset(OUT_DIR / "consensus_geometry.nc") + attrs = xr.open_dataset(ATTRS) + attrs_by_comid = attrs.set_index(COMID="COMID").sel(COMID=geom["COMID"].values) + log10_uparea = attrs_by_comid["log10_uparea"].values.astype(np.float64) + + variants = { + "truth_leopold_maddock.nc": leopold_maddock_n(log10_uparea), + "truth_gaussian.nc": gaussian_noise_n(len(geom["COMID"])), + } + + for filename, n_vals in variants.items(): + out = OUT_DIR / filename + xr.Dataset( + { + "n": ("COMID", n_vals), + "q_spatial": ("COMID", geom["q_spatial"].values), + "p_spatial": ("COMID", geom["p_spatial"].values), + }, + coords={"COMID": geom["COMID"].values}, + ).to_netcdf(out) + print( + f"{out}: n range [{n_vals.min():.4f}, {n_vals.max():.4f}], " + f"median {np.median(n_vals):.4f} ({len(n_vals)} reaches)" + ) + + +if __name__ == "__main__": + main() diff --git a/src/bin/probe_zeta_gradient.rs b/src/bin/probe_zeta_gradient.rs index 8f6a3f8..f9752c7 100644 --- a/src/bin/probe_zeta_gradient.rs +++ b/src/bin/probe_zeta_gradient.rs @@ -32,11 +32,22 @@ //! --probe-plan output/probe_plan.csv --eval-days 1095 \ //! --output output/perturb_runs/ //! -//! Stage 3 (`--mode teacher`): planted-leakance world — overrides the KAN -//! head's normalized leakance outputs at specified reaches with values from a -//! CSV, then runs the chunked eval loop and writes (a) synthetic daily gauge -//! observations as a zarr-v2 store and (b) a per-reach zeta answer key netCDF. +//! Stage 3 (`--mode teacher`): synthetic-twin ground-truth generator — runs +//! the chunked eval loop and writes synthetic daily gauge observations as a +//! zarr-v2 store. Two INDEPENDENT, orthogonal overrides may be combined or +//! used alone: +//! (a) planted-leakance world (`--plant-file` + `--zeta-output`) — overrides +//! the KAN head's normalized leakance outputs at specified reaches with +//! values from a CSV; also writes a per-reach zeta answer-key netCDF. +//! Requires `params.use_leakance: true`. +//! (b) routing-parameter donor world (`--donor-params-nc`, docs: +//! docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md) +//! — overrides ALL THREE of n/q_spatial/p_spatial from a +//! `dump_parameters::write_netcdf`-schema donor NetCDF (the same +//! mechanism `--mode eval-loss`'s "full-swap" composition uses). //! `--output` is not used in teacher mode. +//! +//! Leakance-only (original usage, unchanged): //! cargo run --release --bin probe_zeta_gradient -- \ //! --mode teacher \ //! --config config/experiments/leakance_hourly_on.yaml \ @@ -46,6 +57,15 @@ //! --obs-output output/teacher_obs/ \ //! --zeta-output output/teacher_zeta.nc //! +//! Routing-parameter donor only (no leakance, no --plant-file/--zeta-output): +//! cargo run --release --bin probe_zeta_gradient -- \ +//! --mode teacher --backend cpu \ +//! --config config/experiments/synthetic_n_teacher.yaml \ +//! --checkpoint .ddrs/runs/2026-07-16T02-22-14Z-train-and-test/checkpoints/epoch_5_mb_35 \ +//! --eval-days 999999 \ +//! --donor-params-nc output/synthetic_n/truth_leopold_maddock.nc \ +//! --obs-output output/synthetic_n/synthetic_obs/ +//! //! Stage 4 (`--mode floor`): per-day windowed |pred-obs| residuals for //! transient-floor curves. Teacher weights + self-generated synthetic obs → //! measures the IC-transient noise floor at every warmup post-hoc (one run per @@ -200,17 +220,31 @@ struct Cli { probe_plan: Option, /// teacher mode: plant CSV (comid,k_d_norm,d_gw_norm,factor_norm,...). + /// Optional — omit together with --zeta-output when only overriding + /// n/q_spatial/p_spatial via --donor-params-nc (no leakance planting). #[arg(long)] plant_file: Option, - /// teacher mode: directory for the synthetic-obs zarr-v2 store. + /// teacher mode: directory for the synthetic-obs zarr-v2 store. Always + /// required in teacher mode regardless of which override(s) are active. #[arg(long)] obs_output: Option, /// teacher mode: answer-key netCDF (zeta accumulation over the window). + /// Required IFF --plant-file is given (leakance-planting world only); + /// omit both together for a routing-parameter-donor-only teacher run. #[arg(long)] zeta_output: Option, + /// teacher mode: continuous-forward chunk length in days. The default + /// (365) peaks at ~65 GB RSS over the 64,892-reach eval network — on a + /// 93 GB desktop with ambient apps this gets OOM-killed; 180 halves the + /// peak at the cost of doubling disagg boundary-artifact density + /// (0.55% → 1.1% of days over the 29-year window; artifacts stay rare). + /// State continuity across chunks is exact either way. + #[arg(long, default_value_t = 365)] + chunk_days: usize, + /// Backend: "cpu" (NdArray, deterministic; forces sparse_solver=cpu) or "cuda". #[arg(long, default_value = "cpu")] backend: String, @@ -229,6 +263,12 @@ struct Cli { /// COMID-keyed, physical units) supplying n/q_spatial/p_spatial for any /// composition other than "own". Required unless --compositions is "own" /// only. + /// + /// teacher mode: same donor-NetCDF schema, but ALL THREE of + /// n/q_spatial/p_spatial are always overridden together (no partial + /// swap) — the synthetic-twin ground-truth generator (see + /// docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md). + /// Optional; independent of --plant-file/--zeta-output. #[arg(long)] donor_params_nc: Option, @@ -334,21 +374,26 @@ fn main() -> Result<(), Box> { .into()); } - // --donor-params-nc/--compositions/--loss-output/--per-gauge-output are - // only valid in eval-loss mode. - if (cli.donor_params_nc.is_some() - || cli.compositions.is_some() - || cli.loss_output.is_some() - || cli.per_gauge_output.is_some()) + // --compositions/--loss-output/--per-gauge-output are only valid in + // eval-loss mode. --donor-params-nc is ALSO valid in teacher mode (the + // synthetic-n routing-parameter donor override). + if (cli.compositions.is_some() || cli.loss_output.is_some() || cli.per_gauge_output.is_some()) && mode != Mode::EvalLoss { return Err(format!( - "--donor-params-nc/--compositions/--loss-output/--per-gauge-output are only \ + "--compositions/--loss-output/--per-gauge-output are only \ valid in --mode eval-loss (got --mode {})", cli.mode ) .into()); } + if cli.donor_params_nc.is_some() && mode != Mode::EvalLoss && mode != Mode::Teacher { + return Err(format!( + "--donor-params-nc is only valid in --mode eval-loss or --mode teacher (got --mode {})", + cli.mode + ) + .into()); + } // --params-nc-a/--params-nc-b/--surface-output/--barrier-output/ // --single-point are only valid in landscape mode. @@ -1063,13 +1108,23 @@ fn run_teacher( // Large chunk size reduces disagg boundary-artifact density (left-clamp at chunk // day 0 and precip right-clamp at chunk day C-1). With C=365 each artifact appears // only ~14 times over 5115 teacher days (0.82%), vs 341 times with C=15 (20%). - // 70 GB RAM easily holds a 365-day AORC precip chunk (~2.3 GB). - const BATCH_SIZE_DAYS: usize = 365; - assert!(cfg.params.use_leakance, "teacher requires params.use_leakance: true"); + // Peak RSS scales with chunk length (~65 GB at C=365 on the 64,892-reach eval + // network) — --chunk-days trades artifact density for memory headroom. + let batch_size_days = cli.chunk_days; + assert!(batch_size_days >= 3, "--chunk-days too small: {batch_size_days} (need >= 3)"); + + let plants = match &cli.plant_file { + Some(p) => parse_plant_file(p)?, + None => Vec::new(), + }; + let leakance_active = !plants.is_empty(); + if leakance_active { + assert!( + cfg.params.use_leakance, + "teacher requires params.use_leakance: true when --plant-file is given" + ); + } - let plants = parse_plant_file( - cli.plant_file.as_ref().ok_or("--plant-file is required in teacher mode")?, - )?; let obs_dir = cli.obs_output.as_ref().ok_or("--obs-output is required in teacher mode")?; if obs_dir.exists() && obs_dir.read_dir()?.next().is_some() { return Err(format!( @@ -1079,14 +1134,23 @@ fn run_teacher( ) .into()); } - let zeta_path = cli.zeta_output.as_ref().ok_or("--zeta-output is required in teacher mode")?; - if let Some(p) = zeta_path.parent() { - if !p.as_os_str().is_empty() && !p.exists() { - return Err( - format!("--zeta-output parent dir does not exist: {}", p.display()).into(), - ); + let zeta_path: Option = if leakance_active { + let p = cli + .zeta_output + .as_ref() + .ok_or("--zeta-output is required in teacher mode when --plant-file is given")?; + if let Some(parent) = p.parent() { + if !parent.as_os_str().is_empty() && !parent.exists() { + return Err( + format!("--zeta-output parent dir does not exist: {}", parent.display()) + .into(), + ); + } } - } + Some(p.clone()) + } else { + None + }; let checkpoint = cli.checkpoint.as_ref().ok_or("--checkpoint is required in teacher mode")?; let head_section = cfg.kan_head.as_ref().expect("kan_head config required"); @@ -1138,19 +1202,61 @@ fn run_teacher( let comid_col: HashMap = network_comids.iter().enumerate().map(|(i, &c)| (c, i)).collect(); let n_reaches = network_comids.len(); - let mut ov = LeakanceOverride { - mask: vec![0.0; n_reaches], - k_d: vec![0.0; n_reaches], - d_gw: vec![0.0; n_reaches], - factor: vec![0.0; n_reaches], + + let leakance_ov: Option = if leakance_active { + let mut ov = LeakanceOverride { + mask: vec![0.0; n_reaches], + k_d: vec![0.0; n_reaches], + d_gw: vec![0.0; n_reaches], + factor: vec![0.0; n_reaches], + }; + for &(comid, k, d, f) in &plants { + let col = comid_col[&comid]; + ov.mask[col] = 1.0; + ov.k_d[col] = k; + ov.d_gw[col] = d; + ov.factor[col] = f; + } + Some(ov) + } else { + None + }; + + // Optional n/q_spatial/p_spatial donor override (the synthetic-n + // routing-parameter twin — docs/superpowers/specs/2026-07-22-synthetic-n- + // recoverability-design.md). Reuses the same --donor-params-nc / + // load_comid_field / gather_by_comid / physical_to_normalized machinery + // as --mode eval-loss's full-swap composition. + let param_ov: Option = match &cli.donor_params_nc { + Some(donor_path) => { + let log_space = + |name: &str| cfg.params.log_space_parameters.iter().any(|s| s == name); + let n_map = load_comid_field(donor_path, "n")?; + let q_map = load_comid_field(donor_path, "q_spatial")?; + let p_map = load_comid_field(donor_path, "p_spatial")?; + let n_vals = gather_by_comid(&n_map, &network_comids)?; + let q_vals = gather_by_comid(&q_map, &network_comids)?; + let p_vals = gather_by_comid(&p_map, &network_comids)?; + Some(RoutingParamOverride { + n: Some(physical_to_normalized( + &n_vals, + cfg.params.parameter_ranges.n, + log_space("n"), + )), + q_spatial: Some(physical_to_normalized( + &q_vals, + cfg.params.parameter_ranges.q_spatial, + log_space("q_spatial"), + )), + p_spatial: Some(physical_to_normalized( + &p_vals, + cfg.params.parameter_ranges.p_spatial, + log_space("p_spatial"), + )), + }) + } + None => None, }; - for &(comid, k, d, f) in &plants { - let col = comid_col[&comid]; - ov.mask[col] = 1.0; - ov.k_d[col] = k; - ov.d_gw[col] = d; - ov.factor[col] = f; - } // Chunked CONTINUOUS forward with overrides + zeta accumulation. Continuity // across chunks is maintained by injecting the previous chunk's final @@ -1161,14 +1267,14 @@ fn run_teacher( // leaving 15-day-periodic discontinuities 10-15x the day-to-day baseline on // large basins). The per-reach forward is used so the final column can be // extracted; gauge aggregation happens here via scatter_add_by_group. - let mut zeta_sink = ZetaSums::::new(); + let mut zeta_sink: Option> = leakance_active.then(ZetaSums::::new); let mut predictions_full = Array2::::zeros((n_all_gauges, n_hours)); - let n_chunks_total = n_days.div_ceil(BATCH_SIZE_DAYS); + let n_chunks_total = n_days.div_ceil(batch_size_days); let mut day_offset = 0usize; let mut chunk_idx = 0usize; let mut prev_final_state: Option> = None; while day_offset < n_days { - let chunk_n = (n_days - day_offset).min(BATCH_SIZE_DAYS); + let chunk_n = (n_days - day_offset).min(batch_size_days); let win = TestWindow::new(&axis, day_offset, chunk_n); // Disagg lookahead: pass one extra daily Q' row so the disagg "next" // for the last day of this chunk uses the NEXT chunk's first day instead @@ -1200,9 +1306,9 @@ fn run_teacher( &head, &device, false, - Some(&mut zeta_sink), - Some(&ov), - None, + zeta_sink.as_mut(), + leakance_ov.as_ref(), + param_ov.as_ref(), ); let chunk_hours = win.n_hourly(); let runoff_vec: Vec = runoff.clone().into_data().into_vec().unwrap(); @@ -1250,24 +1356,31 @@ fn run_teacher( daily.dim().1 ); - // Answer key: zeta means over the routed window. - let scale = 1.0_f32 / zeta_sink.steps as f32; - assert!(scale.is_finite() && scale > 0.0, "zeta accumulation empty — leakance inactive?"); - let mean_vec = |t: Option>| -> Vec { - (t.expect("zeta sums present") * scale).into_data().into_vec().unwrap() - }; - write_zeta_netcdf( - zeta_path, - &network_comids, - &mean_vec(zeta_sink.abs_sum), - &mean_vec(zeta_sink.net_sum), - &mean_vec(zeta_sink.depth_sum), - &mean_vec(zeta_sink.area_z_sum), - &mean_vec(zeta_sink.q_sum), - &format!("teacher:{}", checkpoint.display()), - ) - .map_err(|e| -> Box { e })?; - println!("answer key → {} ({} reaches)", zeta_path.display(), network_comids.len()); + // Answer key: zeta means over the routed window (only when leakance was + // planted — a routing-parameter-donor-only teacher run has no zeta term + // to report). + if let Some(sink) = zeta_sink { + let zeta_path = zeta_path.expect("zeta_path is set whenever leakance_active"); + let scale = 1.0_f32 / sink.steps as f32; + assert!(scale.is_finite() && scale > 0.0, "zeta accumulation empty — leakance inactive?"); + let mean_vec = |t: Option>| -> Vec { + (t.expect("zeta sums present") * scale).into_data().into_vec().unwrap() + }; + write_zeta_netcdf( + &zeta_path, + &network_comids, + &mean_vec(sink.abs_sum), + &mean_vec(sink.net_sum), + &mean_vec(sink.depth_sum), + &mean_vec(sink.area_z_sum), + &mean_vec(sink.q_sum), + &format!("teacher:{}", checkpoint.display()), + ) + .map_err(|e| -> Box { e })?; + println!("answer key → {} ({} reaches)", zeta_path.display(), network_comids.len()); + } else { + println!("no --plant-file given — skipping zeta answer-key write"); + } Ok(()) } @@ -2454,7 +2567,8 @@ fn run_state_cache( cli: Cli, device: I::Device, ) -> Result<(), Box> { - // Must match run_teacher's BATCH_SIZE_DAYS so state boundaries align. + // Must match the teacher run's chunk length (--chunk-days, default 365) + // so state boundaries align. const BATCH_SIZE_DAYS: usize = 365; let output = cli.output.as_ref().ok_or("--output is required in state-cache mode")?; diff --git a/tests/teacher_donor_override_parity.rs b/tests/teacher_donor_override_parity.rs new file mode 100644 index 0000000..5ef28b8 --- /dev/null +++ b/tests/teacher_donor_override_parity.rs @@ -0,0 +1,123 @@ +//! Parity gate for teacher mode's new n/q_spatial/p_spatial donor override +//! (docs/superpowers/specs/2026-07-22-synthetic-n-recoverability-design.md). +//! +//! Injecting a checkpoint's OWN dump_parameters output as the teacher's +//! donor field must reproduce (within tolerance) the SAME synthetic gauge +//! observations as running teacher mode with no donor override at all — +//! this exercises the real donor-file I/O path (COMID keying, f32 +//! round-trip, gather-by-comid) that `RoutingParamOverride`'s unit tests in +//! `src/training/forward.rs` don't cover, mirroring +//! `tests/eval_loss_own_parity.rs`'s pattern applied to teacher mode. +//! +//! Tolerance, not byte-identical: the donor round-trip goes through +//! `denormalize` -> `physical_to_normalized` (an f32 `ln`/`exp` round-trip +//! for log-space params like `p_spatial`), which +//! `src/training/forward.rs`'s own `routing_param_override_own_dump_round_trip_matches_baseline` +//! test documents as accurate to < 1e-3 m³/s absolute, not bit-exact. A +//! byte-identical assertion here failed on exactly this expected noise +//! (~7.6e-6 abs on ~100 m³/s discharge, ~130x inside that floor) — this +//! test now checks the same tolerance the donor mechanism is actually +//! specified to. +//! +//! Skips gracefully if the real checkpoint/dump aren't present (machine-local, +//! gitignored) so CI on a clean checkout doesn't break. + +use std::path::{Path, PathBuf}; +use std::process::Command; + +const CONFIG: &str = "/home/tbindas/projects/ddrs/config/experiments/synthetic_n_teacher.yaml"; +const CHECKPOINT: &str = + "/home/tbindas/projects/ddrs/.ddrs/runs/2026-07-16T02-22-14Z-train-and-test/checkpoints/epoch_5_mb_35"; +const OWN_DUMP: &str = "/home/tbindas/projects/ddrs/output/synthetic_n/own_dump_for_parity_test.nc"; + +fn skip_if_missing(path: &str) -> Option { + let p = PathBuf::from(path); + p.exists().then_some(p) +} + +fn run_teacher(donor: Option<&Path>, obs_output: &Path) { + let mut cmd = Command::new(env!("CARGO_BIN_EXE_probe_zeta_gradient")); + cmd.args(["--mode", "teacher", "--backend", "cpu", "--config", CONFIG]) + .arg("--checkpoint") + .arg(CHECKPOINT) + .args(["--eval-days", "10"]) + .arg("--obs-output") + .arg(obs_output); + if let Some(d) = donor { + cmd.arg("--donor-params-nc").arg(d); + } + let status = cmd.status().expect("run probe_zeta_gradient"); + assert!(status.success(), "teacher mode run failed (donor={donor:?})"); +} + +#[test] +fn own_donor_reproduces_no_donor_synthetic_obs() { + let Some(config) = skip_if_missing(CONFIG) else { + eprintln!("skipping: {CONFIG} not present on this machine"); + return; + }; + let Some(checkpoint_head) = skip_if_missing(&format!("{CHECKPOINT}/head.mpk")) else { + eprintln!("skipping: {CHECKPOINT}/head.mpk not present on this machine"); + return; + }; + let Some(own_dump) = skip_if_missing(OWN_DUMP) else { + eprintln!( + "skipping: {OWN_DUMP} not present — generate via \ + `cargo run --release --bin dump_parameters -- --backend cpu \ + --config {CONFIG} --checkpoint {CHECKPOINT}/head --output {OWN_DUMP}`" + ); + return; + }; + drop((config, checkpoint_head)); + + let tmp = std::env::temp_dir().join(format!( + "teacher_donor_parity_{}", + std::process::id() + )); + let no_donor = tmp.join("no_donor"); + let with_donor = tmp.join("with_donor"); + std::fs::create_dir_all(&tmp).unwrap(); + + run_teacher(None, &no_donor); + run_teacher(Some(&own_dump), &with_donor); + + // Compare decoded daily discharge values (obs_writer.rs writes one + // little-endian f64 array per gauge, single chunk named "0") within the + // documented < 1e-3 m³/s absolute tolerance, not byte-identical — see + // the module doc comment for why. + const TOLERANCE_M3S: f64 = 1e-3; + let mut compared = 0; + let mut max_abs_diff = 0.0_f64; + for entry in std::fs::read_dir(&no_donor).unwrap() { + let entry = entry.unwrap(); + if !entry.path().is_dir() { + continue; + } + let gauge = entry.file_name(); + let a = std::fs::read(entry.path().join("0")).unwrap(); + let b = std::fs::read(with_donor.join(&gauge).join("0")).unwrap(); + assert_eq!(a.len(), b.len(), "gauge {gauge:?}: chunk length mismatch"); + for (chunk_a, chunk_b) in a.chunks_exact(8).zip(b.chunks_exact(8)) { + let va = f64::from_le_bytes(chunk_a.try_into().unwrap()); + let vb = f64::from_le_bytes(chunk_b.try_into().unwrap()); + if va.is_nan() && vb.is_nan() { + continue; + } + let abs_diff = (va - vb).abs(); + max_abs_diff = max_abs_diff.max(abs_diff); + assert!( + abs_diff < TOLERANCE_M3S, + "gauge {gauge:?}: own-donor value {vb} diverged from no-donor value {va} \ + by {abs_diff} m³/s (tolerance {TOLERANCE_M3S})" + ); + } + compared += 1; + } + assert!(compared > 0, "no gauge chunks found to compare — obs writer produced nothing"); + eprintln!( + "compared {compared} gauges — own-donor teacher run within {TOLERANCE_M3S} m³/s of \ + no-donor (max abs diff observed: {max_abs_diff})" + ); + + std::fs::remove_dir_all(&tmp).ok(); +}