ibnr 0.2.0__tar.gz

ibnr-0.2.0/.dockerignore

@@ -0,0 +1,13 @@
+# keep the build context to what the image COPYs (pyproject/README/src/scripts)
+.git
+.venv
+analysis
+docs
+tests
+**/__pycache__
+**/*.pyc
+# locally compiled cmdstan artifacts next to the .stan sources (Windows dev
+# box) — the image compiles its own Linux executables at build time
+src/**/*.exe
+src/**/*.o
+src/**/*.d

ibnr-0.2.0/.gitattributes

@@ -0,0 +1,3 @@
+* text=auto eol=lf
+*.png binary
+*.parquet binary

ibnr-0.2.0/.github/workflows/docs.yml

@@ -0,0 +1,112 @@
+name: CI Docs
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+jobs:
+  build-docs:
+    name: "Build Docs"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0 # Full history for accurate page timestamps
+
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.11"
+
+      - name: Install package and dependencies
+        run: |
+          python -m pip install uv
+          # core deps + the `docs` group (great-docs), pinned by uv.lock.
+          # README code blocks render display-only, so the heavy `dev` group
+          # (chainladder, jupyter, ...) is not needed to build the site.
+          uv sync --no-default-groups --group docs
+
+      - name: Set up Quarto
+        uses: quarto-dev/quarto-actions/setup@v2
+
+      - name: Build docs
+        run: uv run great-docs build
+
+      - name: Save docs artifact
+        uses: actions/upload-artifact@v7
+        with:
+          name: docs-html
+          path: great-docs/_site
+          include-hidden-files: true
+
+      - name: Upload build timings
+        uses: actions/upload-artifact@v7
+        with:
+          name: build-timings
+          path: great-docs/_site/build-timings.json
+
+  publish-docs:
+    name: "Publish Docs"
+    runs-on: ubuntu-latest
+    needs: "build-docs"
+    if: github.ref == 'refs/heads/main'
+    permissions:
+      pages: write
+      id-token: write
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - uses: actions/download-artifact@v7
+        with:
+          name: docs-html
+          path: great-docs/_site
+
+      - name: Upload Pages artifact
+        uses: actions/upload-pages-artifact@v5
+        with:
+          path: great-docs/_site
+          include-hidden-files: true
+
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v5
+
+  preview-docs:
+    name: "Preview Docs"
+    runs-on: ubuntu-latest
+    needs: "build-docs"
+    if: github.event_name == 'pull_request'
+    permissions:
+      deployments: write
+      pull-requests: write
+    steps:
+      - uses: actions/download-artifact@v7
+        with:
+          name: docs-html
+          path: great-docs/_site
+
+      # Start deployment
+      - name: Configure pull release name
+        if: ${{ github.event_name == 'pull_request' }}
+        run: |
+          echo "RELEASE_NAME=pr-${{ github.event.number }}" >> $GITHUB_ENV
+
+      - name: Configure branch release name
+        if: ${{ github.event_name != 'pull_request' }}
+        run: |
+          # use branch name, but replace slashes. E.g. feat/a -> feat-a
+          echo "RELEASE_NAME=${GITHUB_REF_NAME//\//-}" >> $GITHUB_ENV
+
+      # Deploy
+      - name: Create Github Deployment
+        uses: bobheadxi/deployments@v1
+        id: deployment
+        if: ${{ !github.event.pull_request.head.repo.fork }}
+        with:
+          step: start
+          token: ${{ secrets.GITHUB_TOKEN }}
+          env: ${{ env.RELEASE_NAME }}
+          ref: ${{ github.head_ref }}
+          logs: "https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}"

ibnr-0.2.0/.github/workflows/release.yml

@@ -0,0 +1,72 @@
+name: Release
+
+# Publishes `ibnr` using PyPI Trusted Publishing (OIDC) — no API token is ever
+# stored in this repository. PyPI verifies the identity of this workflow
+# directly, so there is no long-lived secret to leak or rotate.
+#
+# Two ways to run it:
+#   * Dry run -> Actions > Release > "Run workflow". Builds and validates the
+#     distributions and uploads them as a downloadable artifact, but publishes
+#     NOTHING. Use this to rehearse a release.
+#   * Real release -> push a version tag:  git tag v0.1.0 && git push origin v0.1.0
+#
+# Publishing happens ONLY on a tag push, so a stray "Run workflow" click can
+# never release. Requires a matching "pending publisher" on PyPI (see
+# docs/publishing.md); those values must match THIS file's name (release.yml)
+# and the environment name below, or PyPI will refuse the upload.
+
+on:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch: # dry run: build + validate only, never publishes
+
+jobs:
+  build:
+    name: Build distributions
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build sdist + wheel
+        run: uv build
+
+      # Fails the run before anything is uploaded if the metadata or the
+      # README (which becomes the PyPI project description) is malformed.
+      - name: Validate distribution metadata
+        run: uvx twine check --strict dist/*
+
+      - name: Show what will be published
+        run: ls -l dist/
+
+      - uses: actions/upload-artifact@v7
+        with:
+          name: dist
+          path: dist/
+          if-no-files-found: error
+
+  pypi:
+    name: Publish to PyPI
+    needs: build
+    # Tag pushes only — a manual "Run workflow" is always a dry run.
+    if: github.event_name == 'push'
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/ibnr/
+    permissions:
+      id-token: write # required for Trusted Publishing; nothing else is needed
+    steps:
+      - uses: actions/download-artifact@v7
+        with:
+          name: dist
+          path: dist/
+
+      - uses: pypa/gh-action-pypi-publish@release/v1

ibnr-0.2.0/.gitignore

@@ -0,0 +1,27 @@
+# python / uv
+.venv/
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+
+# tooling caches
+.pytest_cache/
+.ruff_cache/
+.ipynb_checkpoints/
+.coverage
+
+# great-docs generated site (source of truth is great-docs.yml + docstrings)
+great-docs/
+
+# cmdstan compiled artifacts (model*.stan is the source of truth)
+src/**/model*.exe
+src/**/model
+src/**/model_lognormal
+src/**/model*.hpp
+src/**/model*.o
+
+# OS noise
+Thumbs.db
+.DS_Store

ibnr-0.2.0/.python-version

@@ -0,0 +1 @@
+3.12

ibnr-0.2.0/.vscode/settings.json

@@ -0,0 +1,11 @@
+{
+    "chat.agentSkillsLocations": {
+        ".agents/skills": true,
+        ".github/skills": true,
+        ".claude/skills": true,
+        "~/.agents/skills": true,
+        "~/.copilot/skills": true,
+        "~/.claude/skills": true,
+        "~/.vscode/extensions/synapsevscode.synapse-1.25.0/copilot/skills": true
+    }
+}

ibnr-0.2.0/CLAUDE.md

@@ -0,0 +1,102 @@
+# CLAUDE.md
+
+## What this project is
+
+A gallery-centric actuarial reserving package: Bayesian MCMC and neural network loss reserving methods with mandatory evaluation, model stacking, and a long-format triangle data layer backed by duckdb and polars. Designed as a companion/extension to `chainladder-python`, not a fork of it.
+
+Name: **ibnr** (PyPI availability verified 2026-06-11; import `ibnr`, repo dir name predates it). License: MPL-2.0 (deliberately matches chainladder).
+
+## Dev commands
+
+```sh
+uv sync                                   # core + dev deps (chainladder, bermuda-ledger for interop tests)
+uv sync --extra bayesian                  # + cmdstanpy/numpyro/pymc/arviz/bayesblend (works on py3.12)
+uv run pytest                             # fast suite (slow excluded via addopts); transforms run on BOTH backends
+uv run pytest -m slow                     # cmdstan tests (compile + sample); needs cmdstan installed
+uv run pytest "tests/test_transforms.py::test_as_of[polars]"   # single test, one backend
+uv run ruff check . && uv run ruff format .
+uv run python scripts/meyers_validation.py --per-line 50       # Meyers retrospective validation
+```
+
+Markers: `tieout` (chainladder comparisons), `mart` (needs the local Schedule P gold mart; auto-skips when absent), `parity`, `slow` (cmdstan; excluded by default via addopts).
+
+cmdstan on this machine: installed at `~/.cmdstan` (2.39.0), built with the RTools toolchain at `C:\rtools45` (plain `make`, not `mingw32-make` — set `MAKE=make` and prepend `C:\rtools45\x86_64-w64-mingw32.static.posix\bin` and `C:\rtools45\usr\bin` to PATH; `gallery/bayesian/meyers_ccl/model.py:_ensure_windows_toolchain` does this automatically).
+
+## Core design decisions — do not relitigate without asking
+
+1. **Long-format 2D triangles only.** No 4D arrays. A triangle is a tidy table: `origin_period, dev_lag, eval_date, field, value` + arbitrary segment columns (lob, company, ...). `eval_date` is a first-class stored column, not derived — all backtesting slices on it. Each triangle carries metadata: grain, cumulative/incremental flag, units. Reference design: Ledger Investing's `bermuda`.
+2. **ibis is the dataframe frontend.** Both duckdb and polars backends are supported — no debate, both. Transformations (incr↔cum via window functions, grain changes, pivots, `as_of()` slicing) are written once in ibis. The transformation test suite runs against BOTH backends; ibis's polars backend has weaker window-function coverage, so expect and document gaps.
+3. **The Stan `data` block is the data contract.** `kernels/contract.py` maps Triangle → standardized dict. NumPyro and PyMC implementations consume the identical dict. Never let a backend grow its own data prep.
+4. **`PredictiveDistribution` is the unifying output type** (`kernels/predictive.py`). Every gallery entry — Bayesian, NN, deterministic — must produce one. NN models require distributional heads (mixture/quantile heads or deep ensembles); point estimators cannot enter the gallery. Deterministic baselines (Mack, basic CL) are wrapped with bootstrap.
+5. **Evaluation is a contract, not a feature.** `GalleryEntry` ABC requires `.fit()`, `.predict()`, `.evaluate()`, `.card()`. An entry that fails the eval harness does not register. Eval algorithms (ELPD/LOO/WAIC, PIT calibration, stacking via `bayesblend`, ArviZ-based diagnostics) are implemented ONCE in `kernels/` — gallery entries call them, never reimplement.
+6. **Eject-pattern codegen, not a formula DSL.** Every gallery model is literal, readable source: `model.stan`, `model_numpyro.py`, `model_pymc.py` side by side. `gallery.scaffold()` copies source into the user's project for them to extend (copulas, priors, hyperparameters). Precedent: brms/bambi, but simpler.
+7. **Cross-backend parity is a feature.** `kernels/parity.py` validates that NumPyro/PyMC ports match the Stan reference posterior before any convergence/speed comparisons. Parameterization (centered vs non-centered, truncation handling, init strategy) is an explicit documented attribute of each model card. Stan implementations from the literature are ground truth.
+8. **Small public API:** `Triangle`, `gallery.list/fit/evaluate/stack/scaffold/leaderboard`.
+
+## Repository layout
+
+```
+src/<pkg>/
+  triangle/    core.py (Triangle over ibis expr), transforms.py, io.py, validate.py
+  kernels/     contract.py, predictive.py, scores.py, calibration.py,
+               multiline.py (multi-LOB contract), nn_contract.py (NN grids/masks),
+               stacking.py, parity.py, tuning.py
+  gallery/     registry.py, entry.py (GalleryEntry ABC), scaffold.py
+    bayesian/  meyers_ccl/ meyers_csr/ england_verrall_odp/ compartmental/
+    nn/        transformer/ deeptriangle/ mdn/ resnet/
+    statistical/    sur/ copula_glm/   (frequentist stochastic dependence models)
+    deterministic/  mack/ ...
+  data/        schedule_p.py (gold mart adapter)
+  viz/         tidy.py, altair_.py, site.py (quarto gallery site)
+```
+
+Each gallery model dir contains: `card.md`, `model.stan`, `model_numpyro.py`, `model_pymc.py` (bayesian) or pytorch module + config (nn) or plain-numpy `model.py` (statistical).
+
+## Tooling & conventions
+
+* `src/` layout, `uv` for env + packaging, `ruff` for lint/format, `pytest`.
+* Optional extras keep the core light: `[bayesian]` (cmdstanpy, numpyro, pymc, arviz, bayesblend), `[nn]` (torch), `[viz]` (altair, quarto tooling). Core deps ≈ ibis-framework[duckdb,polars] + scipy (scipy added 2026-07-06 for the statistical family; deliberate exception to "ibis only"). Torch must never be imported at module level — `ibnr.gallery` imports (and nn entries register) without the `[nn]` extra; `tests/test_gallery.py` enforces this in a subprocess.
+* Test markers: `-m tieout` (results match chainladder-python on raa/clrd samples), `-m parity` (cross-backend posterior matching), `-m slow` (cmdstan compilation; separate CI job).
+* CI matrix runs core and each extra in isolation to catch hidden imports.
+* Interop is sacred: `Triangle.from_chainladder/to_chainladder`, `from_bermuda/to_bermuda` must round-trip losslessly.
+
+## Related project (data source)
+
+`https://github.com/EKtheSage/cas-schedule-p-data-model` (local checkout at `C:\Users\EthanKang\Projects\cas-schedule-p-data-model`) — Ethan's CAS Schedule P database (Data Vault warehouse, versioned gold publishes). **Default consumption is via GitHub releases**: each gold promote is an immutable release tagged with its publish_id; `load_schedule_p()` with no source resolves `github://EKtheSage/cas-schedule-p-data-model@latest` through the gh CLI, caches to `~/.cache/ibnr` (or `IBNR_CACHE_DIR`), sha256-verifies against the release manifest. Local dev works the same way — the warehouse checkout is only an override (`IBNR_SCHEDULE_P_WAREHOUSE` or explicit path), mainly for producer-side pipeline work. Experiment runs should pin a concrete `@publish_id`; the harness scripts stamp it into every results CSV.
+
+Before writing `triangle/core.py` or `data/schedule_p.py`: inspect that repo. Determine storage format (duckdb file / parquet / warehouse), gold table names, column names, grains, and how realized ultimates are represented. Write the Triangle schema and the adapter against the real schema, not assumptions. The data pipeline stays in that repo; this package only consumes its gold mart via config (path/connection string). In-repo test fixtures use public samples (raa, clrd-style) so the package works without the mart.
+
+## Milestones (in order; do not skip ahead)
+
+1. **DONE (2026-06-11).** Triangle layer + transforms tie out to chainladder-python on raa/clrd, on both duckdb and polars backends. Also done: bermuda round-trip interop, `data/schedule_p.py` gold-mart adapter (ties to the published wide paid mart), `as_of()` backtest slicing. `dev_lag` is always months; eval_date convention: last day of the month `origin + dev_lag` lands in.
+2. **DONE (2026-06-13).** `meyers_ccl` (Stan) reproduces Meyers monograph validation tables from the Schedule P gold mart (train on early diagonal, score realized ultimates, PIT uniformity). Built: `kernels/contract.py` (+ predictive, calibration), gallery registry/entry ABC, meyers_ccl entry + card, `scripts/meyers_validation.py`. Final 200-company run on **net-of-bulk incurred** (`reported_loss` = IncurLoss − BulkLoss; mart rebuilt to carry bulk_loss + direct premium): all four lines AND the combined test pass KS at 5% (combined D=6.8 vs crit 9.6; Meyers' own Fig 8.5 combined was 10.8*). Critical lesson: gross-of-bulk incurred fails WC at D=36.7 — the incurred definition is load-bearing; results in `analysis/results/meyers_ccl_validation_netbulk.csv` (gross run kept alongside as `meyers_ccl_validation.csv`). Explored in `analysis/01_triangle_and_meyers_ccl.ipynb`.
+3. **DONE (2026-07-06; reordered ahead of the parity ports at Ethan's request.)** NN family opens + statistical dependence baselines, compared on the Schedule P backtest. Built: `nn_transformer` (masked-cell triangle transformer, MDN head + 5-seed deep ensemble, calendar-cutoff augmentation, eval_date validation split, autoregressive diagonal rollout; global fit → per-segment predict), `sur` (Zhang 2010 multivariate chain ladder via hand-rolled FGLS; collapses to volume-weighted CL per line at zero correlation), `copula_glm` (Shi & Frees 2011 lognormal marginals + Gaussian copula, parametric bootstrap), kernels `nn_contract.py` / `multiline.py` / `scores.py` (sample CRPS; now in `evaluate()`), new family string `"statistical"`, `scripts/compare_gallery.py` (headline field: paid_loss — lognormal marginals cannot take negative reported increments). **v2 transformer fix (2026-07-07):** pinned per-dev standardization (devs with <2 training-context values define standardized value 0, mean from observed cells at that dev, std 1; rollout draws there forced to the pooled dev mean) replaced v1's inherit-earlier-dev tail stats — the inheritance was the dominant defect (paid err +14%→+4%, rel-CRPS 0.092→0.050; reported err +148%→+1.7%, rel-CRPS 0.79→0.030, only model passing combined KS at 5%, D=26.7 vs crit 27.8). Training pool now multiline companies (≥2 screened lines; `--nn-pool market` reruns the full-mart pool). v1 results kept as `analysis/results/*_v1_inherit_stats.csv`; analysis in `analysis/02_transformer_vs_statistical.ipynb`. **v3 + multi-line study (2026-07-08):** relative calendar encoding (distance past cutoff) replaced absolute calendar embeddings, `nn_transformer_ml` opened (company cohorts, attention across lines; `config.dependence` = "ar" line-by-line AR sampling | "joint" multivariate Gaussian-mixture head with absent lines marginalized; predicts SUR layout incl. diversified totals), study widened to companies passing screens on ≥2 lines (60 companies, 152 cells; transformers train on exactly the scored pairs — looser pools measurably hurt), results CSVs carry anchor+premium, vw chain_ladder point benchmark + reserve-basis point metrics (Wilcoxon-paired) in `compare_gallery.py`. Headlines: paid calibration nn_transformer D=18.3 best; reported meyers_ccl passes KS outright (D=6.7); nn_ml_ar sharpest on 3/4 reported lines and first ML entry to edge CL on premium-normalized point reserves; implied cross-line correlation: joint 0.13/0.08 > ar 0.04/0.05 > SUR/copula 0.01-0.02; sur failed 2 companies, copula diverged on 7/152 cells, transformers 0 failures. NOTE: the single-line transformer's per-line draws are independent — only the `nn_ml_*` entries model cross-line dependence.
+4. **DONE (2026-07-21).** Full Bayesian gallery in Stan before porting anything (reordered Stan-first at Ethan's request 2026-07-20): `meyers_csr` → `england_verrall_odp` → `clark_growth_curve` (NEW: both a deterministic Clark 2003 MLE entry tied out against chainladder's `ClarkLDF` + a Bayesian Stan version, loglogistic + Weibull curves) → `compartmental` (Gesmann & Morris). Every entry got the full Meyers-style 200-company Schedule P retrospective (KS/PIT on realized ultimates). **Checkpoint (2026-07-20):** meyers_ccl NumPyro + PyMC ports pass parity (kernels/parity.py gates mean/SD in MCSE units + marginal KS against the Stan reference; 2 WC triangles; convergence CSVs in analysis/results; open question: PyMC blow-up in the ta08 run on company 11347). **compartmental (2026-07-21):** two ablatable variants from the monograph's case study, priors verbatim from its appendix 7.2 brms code — `gaussian` (Model 1: OS + cumulative paid amounts, correlated (RLR,RRF) AY effects, LKJ) and `lognormal` (Model 2: OS + incremental paid loss ratios, AY+dev effects on all four parameters); new joint paid+outstanding contract `kernels.contract.compartmental_stan_data` (delta-stacked cells, t in years, OS = reported − paid). Retro (no clamp, zero failures both arms): gaussian combined **D=39.9*** (too sharp, CV≈2.5%, and the single-company priors bias OL to est/outcome 0.84); lognormal combined **D=16.1*** with CA passing outright (12.5) — the best-calibrated paid entry after CSR (paid panel: CSR 4.1 < comp-lognormal 16.1* < comp-gaussian 39.9* < ODP 47.9* < clark 49.6–63.4*). Monograph sampler settings (adapt_delta .99, treedepth 15) cost ~160–250 s/company sequential — addressed by the parallel harness (below). Open ablation: `hierarchical` variant with per-line mart-derived prior medians / cross-company pooling. **Parallel retro harness (2026-07-21):** `kernels/harness.py` — `RetroTask`/`SamplerSettings`/`ConvergenceGates`/`run_retro`: spawn-based process pool over companies (default = all cores − 1; `IBNR_MAX_WORKERS` in containers), staged sampler escalation (re-fit only fits failing the convergence gates), entries gained `parallel_chains`/`max_treedepth`/`precompile()`, workers consume a `schedule_p.pinned_source()` so they never resolve `@latest` or call gh. `meyers_validation.py` runs it by default (`--serial`/`--no-escalate` reproduce the published sequential behavior; compartmental stage 1 relaxed to 0.9/12 → ~4x/company, stage 2 = monograph settings). `Dockerfile` packages package + cmdstan 2.39.0 + precompiled gallery Stan models as the compute image other services call (build untested — no Docker on the dev box); long-term the same harness is the seam for a hosted scoring API.
+5. NumPyro + PyMC ports for the rest of the family pass parity; cross-backend convergence comparison (R-hat/ESS/divergences/runtime) published in model cards.
+6. Full Bayesian gallery with held-out-diagonal ELPD, PIT calibration, and bayesblend stacking. Leaderboard works.
+7. Rest of the NN family joins the same leaderboard via PredictiveDistribution (deeptriangle, mdn, resnet; HPO in kernels/tuning.py).
+8. (Secondary) viz/site.py renders the gallery as a quarto static site with interactive altair charts.
+
+## Key references
+
+* Meyers, Stochastic Loss Reserving Using Bayesian MCMC Models (CAS monograph; published Stan code = ground truth for CCL/CSR).
+* England & Verrall, Stochastic Claims Reserving in General Insurance (ODP).
+* Clark, LDF Curve-Fitting and Stochastic Reserving: A Maximum Likelihood Approach (CAS Forum 2003; loglogistic/Weibull growth curves, ODP likelihood — chainladder's `ClarkLDF` is the MLE reference).
+* Gesmann & Morris, Hierarchical Compartmental Reserving Models (CAS; Stan/brms code; hardest parity case — ODEs).
+* Kuo, DeepTriangle (original in Keras; reimplement in pytorch).
+* Ledger Investing: `bermuda` (triangle design reference), `bayesblend` (stacking).
+* chainladder-python: backends are numpy/cupy/sparse/dask 4D duck arrays; polars is input-only via dataframe interchange. We intentionally diverge.
+
+## Gotchas
+
+* ibis polars backend (ibis 10.x): **no window-function support at all** (`OperationNotDefinedError` for any `WindowFunction`), no `ScalarSubquery` either. Transforms use equi-join + group-by formulations instead (see `triangle/transforms.py`). Also: after `cross_join`, mutate derived expressions into real columns *before* filtering on them, or polars loses the joined column (`ColumnNotFoundError: 1__anchor`).
+* chainladder semantics worth remembering (all encoded in the tieout tests):
+  * valuation timestamps are end-of-day, so `tri[tri.valuation <= "1985-12-31"]` *excludes* the 1985 diagonal; use `< "1986"`.
+  * triangle arithmetic treats missing cells as zero inside the observed region, so `cum_to_incr` fabricates increments at cells absent from the source and stores zero increments as NaN. Our long format means absent = unobserved, zero = explicit; we deliberately do NOT densify (it would fabricate data on `as_of` slices).
+  * `grain('OYDY')` anchors dev buckets to the latest diagonal (ages 3, 15, 27... when the latest valuation is Q1). `change_dev_grain` matches this.
+* bermuda's `Cell.dev_lag` measures from period *end* (first diagonal = 0); ours is months from origin *start* (first diagonal = 12). `from_bermuda` recomputes; never copy bermuda's dev_lag.
+* "Same model" across PPLs is only same if parameterization is held constant — otherwise convergence comparisons measure implementation accidents.
+* Schedule P triangles are small; NN overfitting is the central risk. All NN training validates across many company×LOB triangles, never one.
+* Windows dev machine: cmdstanpy needs a working toolchain (RTools/MSVC); keep cmdstan-dependent tests behind `-m slow` and runnable on CI Linux.
+* Never name modules shadowing deps (`altair_.py` not `altair.py`).
+* The Schedule P mart carries accident years beyond the Meyers study window (1988–2007, not just 1988–1997). Any outcome/aggregate computed from the full triangle must restrict to the origins present in the as_of training slice, or it silently includes post-study accident years (bit `scripts/compare_gallery.py::point_context` once — 2.4x inflated "outcomes").

ibnr-0.2.0/Dockerfile

@@ -0,0 +1,51 @@
+# ibnr compute image: the package + cmdstan + every gallery Stan model
+# COMPILED IN, so a container start pays zero toolchain cost. This is the
+# image other services call today (scripts/) and the base the hosted scoring
+# API will run on — both go through kernels/harness.py, which parallelizes
+# across all visible cores by default.
+#
+#   docker build -t ibnr .
+#   docker run --rm -e GH_TOKEN=<token with repo read> \
+#     -e IBNR_MAX_WORKERS=8 --cpus 8 \
+#     -v ibnr-cache:/data/ibnr-cache -v "$PWD/results:/app/analysis/results" \
+#     ibnr python scripts/meyers_validation.py --model compartmental --per-line 50
+#
+# IBNR_MAX_WORKERS should match --cpus: inside a cpu-limited container,
+# os.cpu_count() still reports the HOST's cores, so the env var is how the
+# orchestrator tells the harness its real budget.
+
+FROM python:3.12-slim
+
+# build-essential: cmdstan is compiled into the image below (and gallery
+# models compile against it). gh: fetches gold-mart releases at runtime from
+# the private data repo (auth via GH_TOKEN).
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends build-essential curl ca-certificates \
+    && curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg \
+         -o /usr/share/keyrings/githubcli-archive-keyring.gpg \
+    && echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" \
+         > /etc/apt/sources.list.d/github-cli.list \
+    && apt-get update && apt-get install -y --no-install-recommends gh \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY pyproject.toml README.md ./
+COPY src ./src
+RUN pip install --no-cache-dir ".[bayesian]"
+
+# cmdstan pinned to the version the reference results were produced with
+# (CLAUDE.md: 2.39.0 on the dev machine)
+RUN install_cmdstan --version 2.39.0 --cores 4
+
+# compile every gallery Stan program into the image: containers start ready,
+# and parallel workers never race the compiler (kernels.harness.precompile)
+RUN python -c "from ibnr.kernels.harness import precompile; precompile()"
+
+COPY scripts ./scripts
+RUN mkdir -p analysis/results
+
+# gold-mart release cache: mount a volume here so repeat runs skip the download
+ENV IBNR_CACHE_DIR=/data/ibnr-cache
+
+CMD ["python", "scripts/meyers_validation.py", "--help"]